[illumos-gate merge]

commit 9890ff8357a674572254e0be06b175a1e8eab4b0
    10028 loader: implement framebuffer console
    10029 common/font: create shared font.c
    10030 import pnglite into usr/src/common/pnglite
    8918 loader.efi: add vesa edid support
    10031 loader: import tem for loader console
    10032 loader: implement tem utf-8 support
    10033 ficl: add simple gfx words
    10034 loader: use term-drawrect for menu frame
    10035 loader: add alpha blending for gfx_fb
    10036 ficl: add fb-putimage
    10037 loader: add illumos.png logo
    10038 loader: replace gop and vesa with framebuffer
    10039 loader: build rules for new font setup
    10040 loader: gfx use GOP Blt() function in visual_io callbacks
commit f33b666290305a2b2c134d23cbd1e70e06bf36fd
    7796 uts: ldterm default to utf-8
commit adc2b73db62a4506a57dfd1ce89bcadc4a60a29d
    7784 uts: console input should support Unicode
commit 1f5207b7604fb44407eb4342aff613f7c4508508
    10063 basic support for smatch
    10153 checkpaths shouldn't check packaging exceptions
commit c0455f334914631f42eb41177d677e2820ee6506
    9478 etdump: Add the etdump utility for dumping El Torito boot catalog information.
commit c62757b2b8b6c26589d7704d0ff20beb107fcd9a
    10154 zfs: cast between incompatible function types
commit 781f142d2ae880bb893875d2a114552171a5c3e5
    10064 loader: zfs reader should not probe partitionless disks
commit 8a06b3d6467c15646e663c05086378f16288af85
    10155 ip: cast between incompatible function types
commit c5749750a3e052f1194f65a303456224c51dea63
    10157 sgs/libld: cast between incompatible function types
commit 5e90af26eb6ed2206c2a5f5131a1f3c377d6e8c4
    10158 sgs/rtld: cast between incompatible function types
commit adc04c2d55dd20cc6a0622f1147c0b084cdc3099
    10159 libc: cast between incompatible function types
commit 9419bc2fc61b54b25a4e45211d31fcb920ff67cc
    10162 Sun/Solaris/Kstat: cast between incompatible function types

	Conflicts:
	usr/src/tools/env/illumos.sh

1138 files changed, 223526 insertions, 2425 deletions

diff --git a/exception_lists/copyright b/exception_lists/copyright
index 2220b318f4..5032578161 100644
--- a/exception_lists/copyright
+++ b/exception_lists/copyright
@@ -24,6 +24,7 @@
 # Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 # Copyright (c) 2011 by Delphix. All rights reserved.
 # Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
+# Copyright (c) 2018, Joyent, Inc.
 #
 
 syntax: glob
@@ -425,6 +426,7 @@ usr/src/tools/btxld/btxld.c
 usr/src/tools/btxld/elfh.c
 usr/src/tools/btxld/elfh.h
 usr/src/tools/btxld/imgact_aout.h
+usr/src/tools/smatch/src/*
 usr/src/uts/intel/nsmb/ioc_check.ref
 usr/src/uts/intel/os/splashimage.xpm
 usr/src/uts/common/gssapi/mechs/krb5/crypto/block_size.c
diff --git a/exception_lists/cstyle b/exception_lists/cstyle
index 51120c1ecd..61016e88f0 100644
--- a/exception_lists/cstyle
+++ b/exception_lists/cstyle
@@ -723,6 +723,7 @@ usr/src/tools/btxld/btxld.c
 usr/src/tools/btxld/elfh.c
 usr/src/tools/btxld/elfh.h
 usr/src/tools/btxld/imgact_aout.h
+usr/src/tools/smatch/src/*
 usr/src/uts/common/fs/zfs/lua/*
 usr/src/uts/common/gssapi/gssapi.h
 usr/src/uts/common/gssapi/mechs/krb5/crypto/block_size.c
diff --git a/exception_lists/hdrchk b/exception_lists/hdrchk
index e0f0600a76..c7fed052ea 100644
--- a/exception_lists/hdrchk
+++ b/exception_lists/hdrchk
@@ -211,6 +211,7 @@ usr/src/lib/libsmbfs/netsmb/spnego.h
 usr/src/lib/libsmbfs/smb/derparse.h
 usr/src/lib/libsmbfs/smb/spnegoparse.h
 usr/src/tools/btxld/*
+usr/src/tools/smatch/src/*
 usr/src/uts/common/gssapi/mechs/krb5/include/aes_s2k.h
 usr/src/uts/common/gssapi/mechs/krb5/include/auth_con.h
 usr/src/uts/common/gssapi/mechs/krb5/include/cksumtypes.h
diff --git a/exception_lists/manlint b/exception_lists/manlint
index 0d4ea0f464..1726989d76 100644
--- a/exception_lists/manlint
+++ b/exception_lists/manlint
@@ -10,7 +10,7 @@
 #
 #
 # Copyright 2016 Toomas Soome <tsoome@me.com>
-# Copyright (c) 2018, Joyent, Inc.
+# Copyright (c) 2019, Joyent, Inc.
 #
 usr/src/boot/*
 # Not actually a manual page
@@ -24,3 +24,4 @@ usr/src/lib/libbsm/adt_record.dtd.1
 usr/src/lib/libbsm/adt_record.xsl.1
 usr/src/lib/libpool/dtd/rm_pool.dtd.1
 usr/src/lib/libzonecfg/dtd/zonecfg.dtd.1
+usr/src/tools/smatch/src/*
diff --git a/exception_lists/packaging b/exception_lists/packaging
index 1ba2b9fac9..35349e92a5 100644
--- a/exception_lists/packaging
+++ b/exception_lists/packaging
@@ -27,7 +27,7 @@
 # Copyright 2018 Nexenta Systems, Inc.
 # Copyright 2017 Toomas Soome <tsoome@me.com>
 # Copyright 2017 RackTop Systems.
-# Copyright 2018, Joyent, Inc.
+# Copyright 2019, Joyent, Inc.
 # Copyright 2018 Jason King
 #
 
@@ -1021,3 +1021,9 @@ lib/sparcv9/llib-lcustr.ln	sparc
 lib/libcustr.so
 lib/llib-lcustr
 lib/llib-lcustr.ln
+
+#
+# smatch is delivered and used only with the source tree
+#
+opt/onbld/bin/i386/smatch	i386
+opt/onbld/share/smatch		i386
diff --git a/exception_lists/wscheck b/exception_lists/wscheck
index cd76277d9c..611ab2441f 100644
--- a/exception_lists/wscheck
+++ b/exception_lists/wscheck
@@ -8,7 +8,7 @@
 # source.  A copy of the CDDL is also available via the Internet at
 # http://www.illumos.org/license/CDDL.
 #
-# Copyright 2018 Joyent, Inc.
+# Copyright 2019 Joyent, Inc.
 #
 syntax: glob
 
@@ -97,3 +97,4 @@ usr/src/uts/i86pc/sys/vmm.h
 usr/src/uts/i86pc/sys/vmm_dev.h
 usr/src/uts/i86pc/sys/vmm_instruction_emul.h
 usr/src/uts/common/io/qede/*
+usr/src/tools/smatch/src/*
diff --git a/manifest b/manifest
index e7e3a223c7..3a69b2dc3d 100644
--- a/manifest
+++ b/manifest
@@ -2424,6 +2424,7 @@ h usr/bin/encrypt=usr/lib/isaexec
 f usr/bin/enhance 0555 root bin
 f usr/bin/env 0555 root bin
 f usr/bin/eqn 0555 root bin
+f usr/bin/etdump 0555 root bin
 f usr/bin/expand 0555 root bin
 f usr/bin/expr 0555 root bin
 f usr/bin/exstr 0555 root bin
@@ -11783,6 +11784,7 @@ s usr/share/man/man1/errstr.1=ckstr.1
 s usr/share/man/man1/errtime.1=cktime.1
 s usr/share/man/man1/erruid.1=ckuid.1
 s usr/share/man/man1/erryorn.1=ckyorn.1
+f usr/share/man/man1/etdump.1 0444 root bin
 f usr/share/man/man1/expand.1 0444 root bin
 f usr/share/man/man1/expr.1 0444 root bin
 f usr/share/man/man1/exstr.1 0444 root bin
diff --git a/usr/src/Makefile.master b/usr/src/Makefile.master
index 50077e2a9c..329b8bfc10 100644
--- a/usr/src/Makefile.master
+++ b/usr/src/Makefile.master
@@ -29,6 +29,7 @@
 # Copyright 2016 Toomas Soome <tsoome@me.com>
 # Copyright 2017 Joyent, Inc.
 # Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
+# Copyright (c) 2019, Joyent, Inc.
 #
 
 #
@@ -453,6 +454,9 @@ CERRWARN +=	-_gcc=-Wno-array-bounds
 $(RELEASE_BUILD)CERRWARN += -_gcc=-Wno-unused
 $(RELEASE_BUILD)CERRWARN += -_gcc=-Wno-empty-body
 
+CERRWARN += -_smatch=-p=illumos_user
+include $(SRC)/Makefile.smatch
+
 #
 # turn warnings into errors (C++)
 CCERRWARN=		-xwe
diff --git a/usr/src/Makefile.smatch b/usr/src/Makefile.smatch
new file mode 100644
index 0000000000..028bbf9153
--- /dev/null
+++ b/usr/src/Makefile.smatch
@@ -0,0 +1,39 @@
+#
+# This file and its contents are supplied under the terms of the
+# Common Development and Distribution License ("CDDL"), version 1.0.
+# You may only use this file in accordance with the terms of version
+# 1.0 of the CDDL.
+#
+# A full copy of the text of the CDDL should have accompanied this
+# source.  A copy of the CDDL is also available via the Internet at
+# http://www.illumos.org/license/CDDL.
+#
+# Copyright (c) 2019, Joyent, Inc.
+#
+
+#
+# smatch/sparse checks we always disable, due to too many false positives (or
+# simply too much legacy).
+#
+
+SMATCH_ARGS = --disable=uninitialized,check_check_deref,unreachable
+
+# VLAs are OK by us
+SMATCH_ARGS += -Wno-vla
+# don't care
+SMATCH_ARGS += -Wno-one-bit-signed-bitfield
+# there are lots of "extern void myfunc() { ... }" around
+SMATCH_ARGS += -Wno-external-function-has-definition
+# we have lots of legacy "void foo();" in headers
+SMATCH_ARGS += -Wno-old-style-definition
+SMATCH_ARGS += -Wno-strict-prototypes
+
+CERRWARN += $(SMATCH_ARGS:%=-_smatch=%)
+
+CERRWARN += $(SMOFF:%=-_smatch=--disable=%)
+
+SMATCH_ =
+SMATCH_on =
+SMATCH_off = -_smatch=off
+
+CERRWARN += $(SMATCH_$(SMATCH))
diff --git a/usr/src/boot/Makefile.version b/usr/src/boot/Makefile.version
index f7de1f0e03..4683eed3f4 100644
--- a/usr/src/boot/Makefile.version
+++ b/usr/src/boot/Makefile.version
@@ -33,4 +33,4 @@ LOADER_VERSION = 1.1
 # Use date like formatting here, YYYY.MM.DD.XX, without leading zeroes.
 # The version is processed from left to right, the version number can only
 # be increased.
-BOOT_VERSION = $(LOADER_VERSION)-2018.12.11.1
+BOOT_VERSION = $(LOADER_VERSION)-2018.12.18.1
diff --git a/usr/src/boot/lib/libstand/pager.c b/usr/src/boot/lib/libstand/pager.c
index a966b0bd79..a916ea3cb6 100644
--- a/usr/src/boot/lib/libstand/pager.c
+++ b/usr/src/boot/lib/libstand/pager.c
@@ -1,4 +1,4 @@
-/*-
+/*
  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
  * All rights reserved.
  *
@@ -28,7 +28,6 @@
  */
 
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
 
 #include "stand.h"
 #include <string.h>
@@ -36,8 +35,10 @@ __FBSDID("$FreeBSD$");
 static int	p_maxlines = -1;
 static int	p_freelines;
 
-static char *pager_prompt1 = " --more--  <space> page down <enter> line down <q> quit ";
-static char *pager_blank   = "                                                        ";
+static char *pager_prompt1 = \
+	" --more--  <space> page down <enter> line down <q> quit ";
+static char *pager_blank   = \
+	"                                                        ";
 
 /*
  * 'open' the pager
@@ -47,9 +48,9 @@ pager_open(void)
 {
     int		nlines;
     char	*cp, *lp;
-    
+
     nlines = 24;		/* sensible default */
-    if ((cp = getenv("LINES")) != NULL) {
+    if ((cp = getenv("screen-#rows")) != NULL) {
 	nlines = strtol(cp, &lp, 0);
     }
 
@@ -85,11 +86,11 @@ pager_output(const char *cp)
 
     if (cp == NULL)
 	return(0);
-    
+
     for (;;) {
 	if (*cp == 0)
 	    return(0);
-	
+
 	putchar(*cp);			/* always emit character */
 
 	if (*(cp++) == '\n') {		/* got a newline? */
@@ -134,7 +135,7 @@ pager_file(const char *fname)
     size_t	hmuch;
     int		fd;
     int		result;
-    
+
     if ((fd = open(fname, O_RDONLY)) == -1) {
 	printf("can't open '%s': %s\n", fname, strerror(errno));
 	return(-1);
diff --git a/usr/src/boot/sys/boot/Makefile.inc b/usr/src/boot/sys/boot/Makefile.inc
index 17088d782d..cf4f1681f2 100644
--- a/usr/src/boot/sys/boot/Makefile.inc
+++ b/usr/src/boot/sys/boot/Makefile.inc
@@ -1,11 +1,31 @@
-# $FreeBSD$
+#
+# This file and its contents are supplied under the terms of the
+# Common Development and Distribution License ("CDDL"), version 1.0.
+# You may only use this file in accordance with the terms of version
+# 1.0 of the CDDL.
+#
+# A full copy of the text of the CDDL should have accompanied this
+# source.  A copy of the CDDL is also available via the Internet at
+# http://www.illumos.org/license/CDDL.
+#
 
-SSP_CFLAGS=
+#
+# Copyright 2017 Toomas Soome <tsoome@me.com>
+#
 
-.if ${MACHINE_CPUARCH} == "arm"
+# Default Console font setup.
+# We want it to be the same as kernel.
+# We build compressed, stripped down version of the default font, so we have
+# bare minimum for case we can not load font from the OS root.
+
+FONT=		8x16
+FONT_SRC=	ter-u16n.bdf
+FONT_DIR=	$(SRC)/data/consfonts
+
+#.if ${MACHINE_CPUARCH} == "arm"
 # Do not generate movt/movw, because the relocation fixup for them does not
 # translate to the -Bsymbolic -pie format required by self_reloc() in loader(8).
 # Also, the fpu is not available in a standalone environment.
-CFLAGS.clang+=  -mllvm -arm-use-movt=0
-CFLAGS.clang+=  -mfpu=none
-.endif
+#CFLAGS.clang+=  -mllvm -arm-use-movt=0
+#CFLAGS.clang+=  -mfpu=none
+#.endif
diff --git a/usr/src/boot/sys/boot/common/bootstrap.h b/usr/src/boot/sys/boot/common/bootstrap.h
index ed95d140b2..97d86bed57 100644
--- a/usr/src/boot/sys/boot/common/bootstrap.h
+++ b/usr/src/boot/sys/boot/common/bootstrap.h
@@ -108,11 +108,13 @@ struct console
     void	(*c_out)(struct console *, int);	/* emit c */
     int		(*c_in)(struct console *);	/* wait for and return input */
     int		(*c_ready)(struct console *);	/* return nonzer if input waiting */
+    int		(*c_ioctl)(struct console *, int, void *);
     void	*c_private;		/* private data */
 };
 extern struct console	*consoles[];
 void		cons_probe(void);
 void		cons_mode(int);
+void		autoload_font(void);
 
 /*
  * Plug-and-play enumerator/configurator interface.
@@ -236,6 +238,7 @@ void file_addmetadata(struct preloaded_file *fp, int type, size_t size, void *p)
 int  file_addmodule(struct preloaded_file *fp, char *modname, int version,
 	struct kernel_module **newmp);
 void build_environment_module(void);
+void build_font_module(void);
 vm_offset_t bi_copyenv(vm_offset_t);
 
 /* MI module loaders */
diff --git a/usr/src/boot/sys/boot/common/console.c b/usr/src/boot/sys/boot/common/console.c
index 5693e819c9..34488a886f 100644
--- a/usr/src/boot/sys/boot/common/console.c
+++ b/usr/src/boot/sys/boot/common/console.c
@@ -58,13 +58,13 @@ cons_probe(void)
     /* Do all console probes */
     for (cons = 0; consoles[cons] != NULL; cons++) {
 	consoles[cons]->c_flags = 0;
- 	consoles[cons]->c_probe(consoles[cons]);
+	consoles[cons]->c_probe(consoles[cons]);
     }
     /* Now find the first working one */
     active = -1;
     for (cons = 0; consoles[cons] != NULL && active == -1; cons++) {
 	consoles[cons]->c_flags = 0;
- 	consoles[cons]->c_probe(consoles[cons]);
+	consoles[cons]->c_probe(consoles[cons]);
 	if (consoles[cons]->c_flags == (C_PRESENTIN | C_PRESENTOUT))
 	    active = cons;
     }
@@ -270,7 +270,8 @@ cons_change(const char *string)
 
 	    if (active != 0) {
 		/* If no consoles have initialised we wouldn't see this. */
-		printf("console %s failed to initialize\n", consoles[cons]->c_name);
+		printf("console %s failed to initialize\n",
+		    consoles[cons]->c_name);
 	    }
 	}
     }
diff --git a/usr/src/boot/sys/boot/common/gfx_fb.c b/usr/src/boot/sys/boot/common/gfx_fb.c
new file mode 100644
index 0000000000..7a41fd242e
--- /dev/null
+++ b/usr/src/boot/sys/boot/common/gfx_fb.c
@@ -0,0 +1,1575 @@
+/*
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ */
+
+/*
+ * Copyright 2016 Toomas Soome <tsoome@me.com>
+ */
+
+/*
+ * Common functions to implement graphical framebuffer support for console.
+ */
+
+#include <sys/cdefs.h>
+#include <sys/param.h>
+#include <stand.h>
+#if defined(EFI)
+#include <efi.h>
+#include <efilib.h>
+#else
+#include <btxv86.h>
+#endif
+#include <sys/tem_impl.h>
+#include <sys/consplat.h>
+#include <sys/visual_io.h>
+#include <sys/multiboot2.h>
+#include <sys/font.h>
+#include <sys/endian.h>
+#include <gfx_fb.h>
+#include <pnglite.h>
+#include <bootstrap.h>
+
+/*
+ * Global framebuffer struct, to be updated with mode changes.
+ */
+multiboot_tag_framebuffer_t gfx_fb;
+
+/* To support setenv, keep track of inverses and colors. */
+static int gfx_inverse = 0;
+static int gfx_inverse_screen = 0;
+static uint8_t gfx_fg = DEFAULT_ANSI_FOREGROUND;
+static uint8_t gfx_bg = DEFAULT_ANSI_BACKGROUND;
+
+static int gfx_fb_cons_clear(struct vis_consclear *);
+static void gfx_fb_cons_copy(struct vis_conscopy *);
+static void gfx_fb_cons_display(struct vis_consdisplay *);
+
+#if defined (EFI)
+static int gfx_gop_cons_clear(uint32_t data, uint32_t width, uint32_t height);
+static void gfx_gop_cons_copy(struct vis_conscopy *);
+static void gfx_gop_cons_display(struct vis_consdisplay *);
+#endif
+static int gfx_bm_cons_clear(uint32_t data, uint32_t width, uint32_t height);
+static void gfx_bm_cons_copy(struct vis_conscopy *);
+static void gfx_bm_cons_display(struct vis_consdisplay *);
+
+/*
+ * Set default operations to use bitmap based implementation.
+ * In case of UEFI, if GOP is available, we will switch to GOP based
+ * implementation.
+ *
+ * Also note, for UEFI we do attempt to boost the execution by setting
+ * Task Priority Level (TPL) to TPL_NOTIFY, which is highest priority
+ * usable in application.
+ */
+struct gfx_fb_ops {
+	int (*gfx_cons_clear)(uint32_t, uint32_t, uint32_t);
+	void (*gfx_cons_copy)(struct vis_conscopy *);
+	void (*gfx_cons_display)(struct vis_consdisplay *);
+} gfx_fb_ops = {
+	.gfx_cons_clear = gfx_bm_cons_clear,
+	.gfx_cons_copy = gfx_bm_cons_copy,
+	.gfx_cons_display = gfx_bm_cons_display
+};
+
+/*
+ * Translate platform specific FB address.
+ */
+static uint8_t *
+gfx_get_fb_address(void)
+{
+#if defined(EFI)
+	return ((uint8_t *)(uintptr_t)
+	    gfx_fb.framebuffer_common.framebuffer_addr);
+#else
+	return ((uint8_t *)PTOV((uint32_t)
+	    gfx_fb.framebuffer_common.framebuffer_addr & 0xffffffff));
+#endif
+}
+
+/*
+ * Generic platform callbacks for tem.
+ */
+void
+plat_tem_get_prom_font_size(int *charheight, int *windowtop)
+{
+	*charheight = 0;
+	*windowtop = 0;
+}
+
+void
+plat_tem_get_colors(uint8_t *fg, uint8_t *bg)
+{
+	*fg = gfx_fg;
+	*bg = gfx_bg;
+}
+
+void
+plat_tem_get_inverses(int *inverse, int *inverse_screen)
+{
+	*inverse = gfx_inverse;
+	*inverse_screen = gfx_inverse_screen;
+}
+
+/*
+ * Utility function to parse gfx mode line strings.
+ */
+bool
+gfx_parse_mode_str(char *str, int *x, int *y, int *depth)
+{
+	char *p, *end;
+
+	errno = 0;
+	p = str;
+	*x = strtoul(p, &end, 0);
+	if (*x == 0 || errno != 0)
+		return (false);
+	if (*end != 'x')
+		return (false);
+	p = end + 1;
+	*y = strtoul(p, &end, 0);
+	if (*y == 0 || errno != 0)
+		return (false);
+	if (*end != 'x') {
+		*depth = -1;    /* auto select */
+	} else {
+		p = end + 1;
+		*depth = strtoul(p, &end, 0);
+		if (*depth == 0 || errno != 0 || *end != '\0')
+			return (false);
+	}
+
+	return (true);
+}
+
+/*
+ * Support for color mapping.
+ */
+uint32_t
+gfx_fb_color_map(uint8_t index)
+{
+	uint8_t c;
+	int pos, size;
+	uint32_t color;
+
+	if (gfx_fb.framebuffer_common.framebuffer_type !=
+	    MULTIBOOT_FRAMEBUFFER_TYPE_RGB) {
+		if (index < nitems (solaris_color_to_pc_color))
+			return (solaris_color_to_pc_color[index]);
+		else
+			return (index);
+	}
+
+	c = cmap4_to_24.red[index];
+	pos = gfx_fb.u.fb2.framebuffer_red_field_position;
+	size = gfx_fb.u.fb2.framebuffer_red_mask_size;
+	color = ((c >> (8 - size)) & ((1 << size) - 1)) << pos;
+
+	c = cmap4_to_24.green[index];
+	pos = gfx_fb.u.fb2.framebuffer_green_field_position;
+	size = gfx_fb.u.fb2.framebuffer_green_mask_size;
+	color |= ((c >> (8 - size)) & ((1 << size) - 1)) << pos;
+
+	c = cmap4_to_24.blue[index];
+	pos = gfx_fb.u.fb2.framebuffer_blue_field_position;
+	size = gfx_fb.u.fb2.framebuffer_blue_mask_size;
+	color |= ((c >> (8 - size)) & ((1 << size) - 1)) << pos;
+
+	return (color);
+}
+
+static bool
+color_name_to_ansi(const char *name, int *val)
+{
+	if (strcasecmp(name, "black") == 0) {
+		*val = ANSI_COLOR_BLACK;
+		return (true);
+	}
+	if (strcasecmp(name, "red") == 0) {
+		*val = ANSI_COLOR_RED;
+		return (true);
+	}
+	if (strcasecmp(name, "green") == 0) {
+		*val = ANSI_COLOR_GREEN;
+		return (true);
+	}
+	if (strcasecmp(name, "yellow") == 0) {
+		*val = ANSI_COLOR_YELLOW;
+		return (true);
+	}
+	if (strcasecmp(name, "blue") == 0) {
+		*val = ANSI_COLOR_BLUE;
+		return (true);
+	}
+	if (strcasecmp(name, "magenta") == 0) {
+		*val = ANSI_COLOR_MAGENTA;
+		return (true);
+	}
+	if (strcasecmp(name, "cyan") == 0) {
+		*val = ANSI_COLOR_CYAN;
+		return (true);
+	}
+	if (strcasecmp(name, "white") == 0) {
+		*val = ANSI_COLOR_WHITE;
+		return (true);
+	}
+	return (false);
+}
+
+/* Callback to check and set colors */
+static int
+gfx_set_colors(struct env_var *ev, int flags, const void *value)
+{
+	int val = 0;
+	char buf[2];
+	const void *evalue;
+
+	if (value == NULL)
+		return (CMD_OK);
+
+	if (color_name_to_ansi(value, &val)) {
+		snprintf(buf, sizeof (buf), "%d", val);
+		evalue = buf;
+	} else {
+		char *end;
+
+		errno = 0;
+		val = (int) strtol(value, &end, 0);
+		if (errno != 0 || *end != '\0') {
+			printf("Allowed values are either ansi color name or "
+			    "number from range [0-7].\n");
+			return (CMD_OK);
+		}
+		evalue = value;
+	}
+
+	/* invalid value? */
+	if (val < 0 || val > 7) {
+		printf("Allowed values are either ansi color name or "
+		    "number from range [0-7].\n");
+		return (CMD_OK);
+	}
+
+	if (strcmp(ev->ev_name, "tem.fg_color") == 0) {
+		/* is it already set? */
+		if (gfx_fg == val)
+			return (CMD_OK);
+		gfx_fg = val;
+	}
+	if (strcmp(ev->ev_name, "tem.bg_color") == 0) {
+		/* is it already set? */
+		if (gfx_bg == val)
+			return (CMD_OK);
+		gfx_bg = val;
+	}
+	env_setenv(ev->ev_name, flags | EV_NOHOOK, evalue, NULL, NULL);
+	plat_cons_update_mode(-1);
+	return (CMD_OK);
+}
+
+/* Callback to check and set inverses */
+static int
+gfx_set_inverses(struct env_var *ev, int flags, const void *value)
+{
+	int t, f;
+
+	if (value == NULL)
+		return (CMD_OK);
+
+	t = strcmp(value, "true");
+	f = strcmp(value, "false");
+
+	/* invalid value? */
+	if (t != 0 && f != 0)
+		return (CMD_OK);
+
+	if (strcmp(ev->ev_name, "tem.inverse") == 0) {
+		/* is it already set? */
+		if (gfx_inverse == (t == 0))
+			return (CMD_OK);
+		gfx_inverse = (t == 0);
+	}
+	if (strcmp(ev->ev_name, "tem.inverse-screen") == 0) {
+		/* is it already set? */
+		if (gfx_inverse_screen == (t == 0))
+			return (CMD_OK);
+		gfx_inverse_screen = (t == 0);
+	}
+	env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);
+	plat_cons_update_mode(-1);
+	return (CMD_OK);
+}
+
+/*
+ * Initialize gfx framework.
+ */
+void
+gfx_framework_init(struct visual_ops *fb_ops)
+{
+	int rc;
+	char *env, buf[2];
+#if defined (EFI)
+	extern EFI_GRAPHICS_OUTPUT *gop;
+
+	if (gop != NULL) {
+		gfx_fb_ops.gfx_cons_clear = gfx_gop_cons_clear;
+		gfx_fb_ops.gfx_cons_copy = gfx_gop_cons_copy;
+		gfx_fb_ops.gfx_cons_display = gfx_gop_cons_display;
+	}
+#endif
+
+	/* Add visual io callbacks */
+	fb_ops->cons_clear = gfx_fb_cons_clear;
+	fb_ops->cons_copy = gfx_fb_cons_copy;
+	fb_ops->cons_display = gfx_fb_cons_display;
+
+	/* set up tem inverse controls */
+	env = getenv("tem.inverse");
+	if (env != NULL) {
+		if (strcmp(env, "true") == 0)
+			gfx_inverse = 1;
+		unsetenv("tem.inverse");
+	}
+
+	env = getenv("tem.inverse-screen");
+	if (env != NULL) {
+		if (strcmp(env, "true") == 0)
+			gfx_inverse_screen = 1;
+		unsetenv("tem.inverse-screen");
+	}
+
+	if (gfx_inverse)
+		env = "true";
+	else
+		env = "false";
+
+	env_setenv("tem.inverse", EV_VOLATILE, env, gfx_set_inverses,
+            env_nounset);
+
+	if (gfx_inverse_screen)
+		env = "true";
+	else
+		env = "false";
+
+	env_setenv("tem.inverse-screen", EV_VOLATILE, env, gfx_set_inverses,
+            env_nounset);
+
+	/* set up tem color controls */
+	env = getenv("tem.fg_color");
+	if (env != NULL) {
+		rc = (int) strtol(env, NULL, 0);
+		if (rc >= 0 && rc <= 7)
+			gfx_fg = rc;
+		unsetenv("tem.fg_color");
+	}
+
+	env = getenv("tem.bg_color");
+	if (env != NULL) {
+		rc = (int) strtol(env, NULL, 0);
+		if (rc >= 0 && rc <= 7)
+			gfx_bg = rc;
+		unsetenv("tem.bg_color");
+	}
+
+	snprintf(buf, sizeof (buf), "%d", gfx_fg);
+	env_setenv("tem.fg_color", EV_VOLATILE, buf, gfx_set_colors,
+	    env_nounset);
+	snprintf(buf, sizeof (buf), "%d", gfx_bg);
+	env_setenv("tem.bg_color", EV_VOLATILE, buf, gfx_set_colors,
+	    env_nounset);
+}
+
+/*
+ * visual io callbacks.
+ */
+
+#if defined (EFI)
+static int
+gfx_gop_cons_clear(uint32_t data, uint32_t width, uint32_t height)
+{
+	EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
+	EFI_STATUS status;
+	extern EFI_GRAPHICS_OUTPUT *gop;
+
+	BltBuffer = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&data;
+
+	status = gop->Blt(gop, BltBuffer, EfiBltVideoFill, 0, 0,
+	    0, 0, width, height, 0);
+
+	if (EFI_ERROR(status))
+		return (1);
+	else
+		return (0);
+}
+#endif
+
+static int
+gfx_bm_cons_clear(uint32_t data, uint32_t width, uint32_t height)
+{
+	uint8_t *fb, *fb8;
+	uint32_t *fb32, pitch;
+	uint16_t *fb16;
+	uint32_t i, j;
+
+	fb = gfx_get_fb_address();
+	pitch = gfx_fb.framebuffer_common.framebuffer_pitch;
+
+	switch (gfx_fb.framebuffer_common.framebuffer_bpp) {
+	case 8:		/* 8 bit */
+		for (i = 0; i < height; i++) {
+			(void) memset(fb + i * pitch, data, pitch);
+		}
+		break;
+	case 15:
+	case 16:		/* 16 bit */
+		for (i = 0; i < height; i++) {
+			fb16 = (uint16_t *)(fb + i * pitch);
+			for (j = 0; j < width; j++)
+				fb16[j] = (uint16_t)(data & 0xffff);
+		}
+		break;
+	case 24:		/* 24 bit */
+		for (i = 0; i < height; i++) {
+			fb8 = fb + i * pitch;
+			for (j = 0; j < pitch; j += 3) {
+				fb8[j] = (data >> 16) & 0xff;
+				fb8[j+1] = (data >> 8) & 0xff;
+				fb8[j+2] = data & 0xff;
+			}
+		}
+		break;
+	case 32:		/* 32 bit */
+		for (i = 0; i < height; i++) {
+			fb32 = (uint32_t *)(fb + i * pitch);
+			for (j = 0; j < width; j++)
+				fb32[j] = data;
+		}
+		break;
+	default:
+		return (1);
+	}
+
+	return (0);
+}
+
+static int
+gfx_fb_cons_clear(struct vis_consclear *ca)
+{
+	uint32_t data, width, height;
+	int ret;
+#if defined (EFI)
+	EFI_TPL tpl;
+#endif
+
+	data = gfx_fb_color_map(ca->bg_color);
+	width = gfx_fb.framebuffer_common.framebuffer_width;
+	height = gfx_fb.framebuffer_common.framebuffer_height;
+
+#if defined (EFI)
+	tpl = BS->RaiseTPL(TPL_NOTIFY);
+#endif
+	ret = gfx_fb_ops.gfx_cons_clear(data, width, height);
+#if defined (EFI)
+	BS->RestoreTPL(tpl);
+#endif
+	return (ret);
+}
+
+#if defined (EFI)
+static void
+gfx_gop_cons_copy(struct vis_conscopy *ma)
+{
+	UINTN width, height;
+	extern EFI_GRAPHICS_OUTPUT *gop;
+
+	width = ma->e_col - ma->s_col + 1;
+	height = ma->e_row - ma->s_row + 1;
+
+	(void) gop->Blt(gop, NULL, EfiBltVideoToVideo, ma->s_col, ma->s_row,
+	    ma->t_col, ma->t_row, width, height, 0);
+}
+#endif
+
+static void
+gfx_bm_cons_copy(struct vis_conscopy *ma)
+{
+	uint32_t soffset, toffset;
+	uint32_t width, height;
+	uint8_t *src, *dst, *fb;
+	uint32_t bpp, pitch;
+
+	fb = gfx_get_fb_address();
+	bpp = roundup2(gfx_fb.framebuffer_common.framebuffer_bpp, 8) >> 3;
+	pitch = gfx_fb.framebuffer_common.framebuffer_pitch;
+
+	soffset = ma->s_col * bpp + ma->s_row * pitch;
+	toffset = ma->t_col * bpp + ma->t_row * pitch;
+	src = fb + soffset;
+	dst = fb + toffset;
+	width = (ma->e_col - ma->s_col + 1) * bpp;
+	height = ma->e_row - ma->s_row + 1;
+
+	if (toffset <= soffset) {
+		for (uint32_t i = 0; i < height; i++) {
+			uint32_t increment = i * pitch;
+			(void)memmove(dst + increment, src + increment, width);
+		}
+	} else {
+		for (int i = height - 1; i >= 0; i--) {
+			uint32_t increment = i * pitch;
+			(void)memmove(dst + increment, src + increment, width);
+		}
+	}
+}
+
+static void
+gfx_fb_cons_copy(struct vis_conscopy *ma)
+{
+#if defined (EFI)
+	EFI_TPL tpl;
+
+	tpl = BS->RaiseTPL(TPL_NOTIFY);
+#endif
+
+	gfx_fb_ops.gfx_cons_copy(ma);
+#if defined (EFI)
+	BS->RestoreTPL(tpl);
+#endif
+}
+
+/*
+ * Implements alpha blending for RGBA data, could use pixels for arguments,
+ * but byte stream seems more generic.
+ * The generic alpha blending is:
+ * blend = alpha * fg + (1.0 - alpha) * bg.
+ * Since our alpha is not from range [0..1], we scale appropriately.
+ */
+static uint8_t
+alpha_blend(uint8_t fg, uint8_t bg, uint8_t alpha)
+{
+	uint16_t blend, h, l;
+
+	/* trivial corner cases */
+	if (alpha == 0)
+		return (bg);
+	if (alpha == 0xFF)
+		return (fg);
+	blend = (alpha * fg + (0xFF - alpha) * bg);
+	/* Division by 0xFF */
+	h = blend >> 8;
+	l = blend & 0xFF;
+	if (h + l >= 0xFF)
+		h++;
+	return (h);
+}
+
+/* Copy memory to framebuffer or to memory. */
+static void
+bitmap_cpy(uint8_t *dst, uint8_t *src, uint32_t len, int bpp)
+{
+	uint32_t i;
+	uint8_t a;
+
+	switch (bpp) {
+	case 4:
+		/*
+		 * we only implement alpha blending for depth 32,
+		 * use memcpy for other cases.
+		 */
+		for (i = 0; i < len; i += bpp) {
+			a = src[i+3];
+			dst[i] = alpha_blend(src[i], dst[i], a);
+			dst[i+1] = alpha_blend(src[i+1], dst[i+1], a);
+			dst[i+2] = alpha_blend(src[i+2], dst[i+2], a);
+			dst[i+3] = a;
+		}
+		break;
+	default:
+		(void) memcpy(dst, src, len);
+		break;
+	}
+}
+
+#if defined (EFI)
+static void
+gfx_gop_cons_display(struct vis_consdisplay *da)
+{
+	EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
+	uint32_t size;
+	int bpp;
+	extern EFI_GRAPHICS_OUTPUT *gop;
+
+	bpp = roundup2(gfx_fb.framebuffer_common.framebuffer_bpp, 8) >> 3;
+	size = sizeof (*BltBuffer) * da->width * da->height;
+	BltBuffer = malloc(size);
+	if (BltBuffer == NULL && gfx_get_fb_address() != NULL) {
+		/* Fall back to bitmap implementation */
+		gfx_bm_cons_display(da);
+		return;
+	}
+
+	(void) gop->Blt(gop, BltBuffer, EfiBltVideoToBltBuffer,
+	    da->col, da->row, 0, 0, da->width, da->height, 0);
+	bitmap_cpy((void *)BltBuffer, da->data, size, bpp);
+	(void) gop->Blt(gop, BltBuffer, EfiBltBufferToVideo,
+	    0, 0, da->col, da->row, da->width, da->height, 0);
+	free(BltBuffer);
+}
+#endif
+
+static void
+gfx_bm_cons_display(struct vis_consdisplay *da)
+{
+	uint32_t size;		/* write size per scanline */
+	uint8_t *fbp;		/* fb + calculated offset */
+	int i, bpp, pitch;
+
+	bpp = roundup2(gfx_fb.framebuffer_common.framebuffer_bpp, 8) >> 3;
+	pitch = gfx_fb.framebuffer_common.framebuffer_pitch;
+
+	size = da->width * bpp;
+	fbp = gfx_get_fb_address();
+	fbp += da->col * bpp + da->row * pitch;
+
+	/* write all scanlines in rectangle */
+	for (i = 0; i < da->height; i++) {
+		uint8_t *dest = fbp + i * pitch;
+		uint8_t *src = da->data + i * size;
+		bitmap_cpy(dest, src, size, bpp);
+	}
+}
+
+static void
+gfx_fb_cons_display(struct vis_consdisplay *da)
+{
+#if defined (EFI)
+	EFI_TPL tpl;
+#endif
+
+	/* make sure we will not write past FB */
+	if ((uint32_t)da->col >= gfx_fb.framebuffer_common.framebuffer_width ||
+	    (uint32_t)da->row >= gfx_fb.framebuffer_common.framebuffer_height ||
+	    (uint32_t)da->col + da->width >
+	    gfx_fb.framebuffer_common.framebuffer_width ||
+	    (uint32_t)da->row + da->height >
+	    gfx_fb.framebuffer_common.framebuffer_height)
+		return;
+
+#if defined (EFI)
+	tpl = BS->RaiseTPL(TPL_NOTIFY);
+#endif
+	gfx_fb_ops.gfx_cons_display(da);
+#if defined (EFI)
+	BS->RestoreTPL(tpl);
+#endif
+}
+
+void
+gfx_fb_display_cursor(struct vis_conscursor *ca)
+{
+	uint32_t fg, bg;
+	uint32_t offset, size, *fb32;
+	uint16_t *fb16;
+	uint8_t *fb8, *fb;
+	uint32_t bpp, pitch;
+#if defined (EFI)
+	EFI_TPL tpl;
+#endif
+
+	fb = gfx_get_fb_address();
+	bpp = roundup2(gfx_fb.framebuffer_common.framebuffer_bpp, 8) >> 3;
+	pitch = gfx_fb.framebuffer_common.framebuffer_pitch;
+
+	size = ca->width * bpp;
+
+	/*
+	 * Build cursor image. We are building mirror image of data on
+	 * frame buffer by (D xor FG) xor BG.
+	 */
+	offset = ca->col * bpp + ca->row * pitch;
+#if defined (EFI)
+	tpl = BS->RaiseTPL(TPL_NOTIFY);
+#endif
+	switch (gfx_fb.framebuffer_common.framebuffer_bpp) {
+	case 8:		/* 8 bit */
+		fg = ca->fg_color.mono;
+		bg = ca->bg_color.mono;
+		for (int i = 0; i < ca->height; i++) {
+			fb8 = fb + offset + i * pitch;
+			for (uint32_t j = 0; j < size; j += 1) {
+				fb8[j] = (fb8[j] ^ (fg & 0xff)) ^ (bg & 0xff);
+			}
+		}
+		break;
+	case 15:
+	case 16:	/* 16 bit */
+		fg = ca->fg_color.sixteen[0] << 8;
+		fg |= ca->fg_color.sixteen[1];
+		bg = ca->bg_color.sixteen[0] << 8;
+		bg |= ca->bg_color.sixteen[1];
+		for (int i = 0; i < ca->height; i++) {
+			fb16 = (uint16_t *)(fb + offset + i * pitch);
+			for (int j = 0; j < ca->width; j++) {
+				fb16[j] = (fb16[j] ^ (fg & 0xffff)) ^
+				    (bg & 0xffff);
+			}
+		}
+		break;
+	case 24:	/* 24 bit */
+		fg = ca->fg_color.twentyfour[0] << 16;
+		fg |= ca->fg_color.twentyfour[1] << 8;
+		fg |= ca->fg_color.twentyfour[2];
+		bg = ca->bg_color.twentyfour[0] << 16;
+		bg |= ca->bg_color.twentyfour[1] << 8;
+		bg |= ca->bg_color.twentyfour[2];
+
+		for (int i = 0; i < ca->height; i++) {
+			fb8 = fb + offset + i * pitch;
+			for (uint32_t j = 0; j < size; j += 3) {
+				fb8[j] = (fb8[j] ^ ((fg >> 16) & 0xff)) ^
+				    ((bg >> 16) & 0xff);
+				fb8[j+1] = (fb8[j+1] ^ ((fg >> 8) & 0xff)) ^
+				    ((bg >> 8) & 0xff);
+				fb8[j+2] = (fb8[j+2] ^ (fg & 0xff)) ^
+				    (bg & 0xff);
+			}
+		}
+		break;
+	case 32:	/* 32 bit */
+		fg = ca->fg_color.twentyfour[0] << 16;
+		fg |= ca->fg_color.twentyfour[1] << 8;
+		fg |= ca->fg_color.twentyfour[2];
+		bg = ca->bg_color.twentyfour[0] << 16;
+		bg |= ca->bg_color.twentyfour[1] << 8;
+		bg |= ca->bg_color.twentyfour[2];
+		for (int i = 0; i < ca->height; i++) {
+			fb32 = (uint32_t *)(fb + offset + i * pitch);
+			for (int j = 0; j < ca->width; j++)
+				fb32[j] = (fb32[j] ^ fg) ^ bg;
+		}
+		break;
+	}
+#if defined (EFI)
+	BS->RestoreTPL(tpl);
+#endif
+}
+
+/*
+ * Public graphics primitives.
+ */
+
+static int
+isqrt(int num)
+{
+	int res = 0;
+	int bit = 1 << 30;
+
+	/* "bit" starts at the highest power of four <= the argument. */
+	while (bit > num)
+		bit >>= 2;
+
+	while (bit != 0) {
+		if (num >= res + bit) {
+			num -= res + bit;
+			res = (res >> 1) + bit;
+		} else
+			res >>= 1;
+		bit >>= 2;
+	}
+	return (res);
+}
+
+/* set pixel in framebuffer using gfx coordinates */
+void
+gfx_fb_setpixel(uint32_t x, uint32_t y)
+{
+	uint32_t c, offset, pitch, bpp;
+	uint8_t *fb;
+	text_color_t fg, bg;
+
+	if (plat_stdout_is_framebuffer() == 0)
+		return;
+
+	tem_get_colors((tem_vt_state_t)tems.ts_active, &fg, &bg);
+	c = gfx_fb_color_map(fg);
+
+	if (x >= gfx_fb.framebuffer_common.framebuffer_width ||
+	    y >= gfx_fb.framebuffer_common.framebuffer_height)
+		return;
+
+	fb = gfx_get_fb_address();
+	pitch = gfx_fb.framebuffer_common.framebuffer_pitch;
+	bpp = roundup2(gfx_fb.framebuffer_common.framebuffer_bpp, 8) >> 3;
+
+	offset = y * pitch + x * bpp;
+	switch (gfx_fb.framebuffer_common.framebuffer_bpp) {
+	case 8:
+		fb[offset] = c & 0xff;
+		break;
+	case 15:
+	case 16:
+		*(uint16_t *)(fb + offset) = c & 0xffff;
+		break;
+	case 24:
+		fb[offset] = (c >> 16) & 0xff;
+		fb[offset + 1] = (c >> 8) & 0xff;
+		fb[offset + 2] = c & 0xff;
+		break;
+	case 32:
+		*(uint32_t *)(fb + offset) = c;
+		break;
+	}
+}
+
+/*
+ * draw rectangle in framebuffer using gfx coordinates.
+ * The function is borrowed from fbsd vt_fb.c
+ */
+void
+gfx_fb_drawrect(uint32_t x1, uint32_t y1, uint32_t x2, uint32_t y2,
+    uint32_t fill)
+{
+	uint32_t x, y;
+
+	if (plat_stdout_is_framebuffer() == 0)
+		return;
+
+	for (y = y1; y <= y2; y++) {
+		if (fill || (y == y1) || (y == y2)) {
+			for (x = x1; x <= x2; x++)
+				gfx_fb_setpixel(x, y);
+		} else {
+			gfx_fb_setpixel(x1, y);
+			gfx_fb_setpixel(x2, y);
+		}
+	}
+}
+
+void
+gfx_fb_line(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1, uint32_t wd)
+{
+	int dx, sx, dy, sy;
+	int err, e2, x2, y2, ed, width;
+
+	if (plat_stdout_is_framebuffer() == 0)
+		return;
+
+	width = wd;
+	sx = x0 < x1? 1 : -1;
+	sy = y0 < y1? 1 : -1;
+	dx = x1 > x0? x1 - x0 : x0 - x1;
+	dy = y1 > y0? y1 - y0 : y0 - y1;
+	err = dx + dy;
+	ed = dx + dy == 0 ? 1: isqrt(dx * dx + dy * dy);
+
+	for (;;) {
+		gfx_fb_setpixel(x0, y0);
+		e2 = err;
+		x2 = x0;
+		if ((e2 << 1) >= -dx) {		/* x step */
+			e2 += dy;
+			y2 = y0;
+			while (e2 < ed * width &&
+			    (y1 != (uint32_t)y2 || dx > dy)) {
+				y2 += sy;
+				gfx_fb_setpixel(x0, y2);
+				e2 += dx;
+			}
+			if (x0 == x1)
+				break;
+			e2 = err;
+			err -= dy;
+			x0 += sx;
+		}
+		if ((e2 << 1) <= dy) {		/* y step */
+			e2 = dx-e2;
+			while (e2 < ed * width &&
+			    (x1 != (uint32_t)x2 || dx < dy)) {
+				x2 += sx;
+				gfx_fb_setpixel(x2, y0);
+				e2 += dy;
+			}
+			if (y0 == y1)
+				break;
+			err += dx;
+			y0 += sy;
+		}
+	}
+}
+
+/*
+ * quadratic Bézier curve limited to gradients without sign change.
+ */
+void
+gfx_fb_bezier(uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1, uint32_t x2,
+    uint32_t y2, uint32_t wd)
+{
+	int sx, sy, xx, yy, xy, width;
+	int dx, dy, err, curvature;
+	int i;
+
+	if (plat_stdout_is_framebuffer() == 0)
+		return;
+
+	width = wd;
+	sx = x2 - x1;
+	sy = y2 - y1;
+	xx = x0 - x1;
+	yy = y0 - y1;
+	curvature = xx*sy - yy*sx;
+
+	if (sx*sx + sy*sy > xx*xx+yy*yy) {
+		x2 = x0;
+		x0 = sx + x1;
+		y2 = y0;
+		y0 = sy + y1;
+		curvature = -curvature;
+	}
+	if (curvature != 0) {
+		xx += sx;
+		sx = x0 < x2? 1 : -1;
+		xx *= sx;
+		yy += sy;
+		sy = y0 < y2? 1 : -1;
+		yy *= sy;
+		xy = (xx*yy) << 1;
+		xx *= xx;
+		yy *= yy;
+		if (curvature * sx * sy < 0) {
+			xx = -xx;
+			yy = -yy;
+			xy = -xy;
+			curvature = -curvature;
+		}
+		dx = 4 * sy * curvature * (x1 - x0) + xx - xy;
+		dy = 4 * sx * curvature * (y0 - y1) + yy - xy;
+		xx += xx;
+		yy += yy;
+		err = dx + dy + xy;
+		do {
+			for (i = 0; i <= width; i++)
+				gfx_fb_setpixel(x0 + i, y0);
+			if (x0 == x2 && y0 == y2)
+				return;  /* last pixel -> curve finished */
+			y1 = 2 * err < dx;
+			if (2 * err > dy) {
+				x0 += sx;
+				dx -= xy;
+				dy += yy;
+				err += dy;
+			}
+			if (y1 != 0) {
+				y0 += sy;
+				dy -= xy;
+				dx += xx;
+				err += dx;
+			}
+		} while (dy < dx ); /* gradient negates -> algorithm fails */
+	}
+	gfx_fb_line(x0, y0, x2, y2, width);
+}
+
+/*
+ * draw rectangle using terminal coordinates and current foreground color.
+ */
+void
+gfx_term_drawrect(uint32_t ux1, uint32_t uy1, uint32_t ux2, uint32_t uy2)
+{
+	int x1, y1, x2, y2;
+	int xshift, yshift;
+	int width, i;
+	uint32_t vf_width, vf_height;
+
+	if (plat_stdout_is_framebuffer() == 0)
+		return;
+
+	vf_width = tems.ts_font.vf_width;
+	vf_height = tems.ts_font.vf_height;
+	width = vf_width / 4;			/* line width */
+	xshift = (vf_width - width) / 2;
+	yshift = (vf_height - width) / 2;
+	/* Terminal coordinates start from (1,1) */
+	ux1--;
+	uy1--;
+	ux2--;
+	uy2--;
+
+	/* mark area used in tem */
+	tem_image_display(tems.ts_active, uy1 - 1, ux1 - 1, uy2, ux2);
+
+	/*
+	 * Draw horizontal lines width points thick, shifted from outer edge.
+	 */
+	x1 = (ux1 + 1) * vf_width + tems.ts_p_offset.x;
+	y1 = uy1 * vf_height + tems.ts_p_offset.y + yshift;
+	x2 = ux2 * vf_width + tems.ts_p_offset.x;
+	gfx_fb_drawrect(x1, y1, x2, y1 + width, 1);
+	y2 = uy2 * vf_height + tems.ts_p_offset.y;
+	y2 += vf_height - yshift - width;
+	gfx_fb_drawrect(x1, y2, x2, y2 + width, 1);
+
+	/*
+	 * Draw vertical lines width points thick, shifted from outer edge.
+	 */
+	x1 = ux1 * vf_width + tems.ts_p_offset.x + xshift;
+	y1 = uy1 * vf_height + tems.ts_p_offset.y;
+	y1 += vf_height;
+	y2 = uy2 * vf_height + tems.ts_p_offset.y;
+	gfx_fb_drawrect(x1, y1, x1 + width, y2, 1);
+	x1 = ux2 * vf_width + tems.ts_p_offset.x;
+	x1 += vf_width - xshift - width;
+	gfx_fb_drawrect(x1, y1, x1 + width, y2, 1);
+
+	/* Draw upper left corner. */
+	x1 = ux1 * vf_width + tems.ts_p_offset.x + xshift;
+	y1 = uy1 * vf_height + tems.ts_p_offset.y;
+	y1 += vf_height;
+
+	x2 = ux1 * vf_width + tems.ts_p_offset.x;
+	x2 += vf_width;
+	y2 = uy1 * vf_height + tems.ts_p_offset.y + yshift;
+	for (i = 0; i <= width; i++)
+		gfx_fb_bezier(x1 + i, y1, x1 + i, y2 + i, x2, y2 + i, width-i);
+
+	/* Draw lower left corner. */
+	x1 = ux1 * vf_width + tems.ts_p_offset.x;
+	x1 += vf_width;
+	y1 = uy2 * vf_height + tems.ts_p_offset.y;
+	y1 += vf_height - yshift;
+	x2 = ux1 * vf_width + tems.ts_p_offset.x + xshift;
+	y2 = uy2 * vf_height + tems.ts_p_offset.y;
+	for (i = 0; i <= width; i++)
+		gfx_fb_bezier(x1, y1 - i, x2 + i, y1 - i, x2 + i, y2, width-i);
+
+	/* Draw upper right corner. */
+	x1 = ux2 * vf_width + tems.ts_p_offset.x;
+	y1 = uy1 * vf_height + tems.ts_p_offset.y + yshift;
+	x2 = ux2 * vf_width + tems.ts_p_offset.x;
+	x2 += vf_width - xshift - width;
+	y2 = uy1 * vf_height + tems.ts_p_offset.y;
+	y2 += vf_height;
+	for (i = 0; i <= width; i++)
+		gfx_fb_bezier(x1, y1 + i, x2 + i, y1 + i, x2 + i, y2, width-i);
+
+	/* Draw lower right corner. */
+	x1 = ux2 * vf_width + tems.ts_p_offset.x;
+	y1 = uy2 * vf_height + tems.ts_p_offset.y;
+	y1 += vf_height - yshift;
+	x2 = ux2 * vf_width + tems.ts_p_offset.x;
+	x2 += vf_width - xshift - width;
+	y2 = uy2 * vf_height + tems.ts_p_offset.y;
+	for (i = 0; i <= width; i++)
+		gfx_fb_bezier(x1, y1 - i, x2 + i, y1 - i, x2 + i, y2, width-i);
+}
+
+int
+gfx_fb_putimage(png_t *png)
+{
+	struct vis_consdisplay da;
+	uint32_t i, j, height, width, color;
+	int bpp;
+	uint8_t r, g, b, a, *p;
+
+	if (plat_stdout_is_framebuffer() == 0 ||
+	    png->color_type != PNG_TRUECOLOR_ALPHA) {
+		return (1);
+	}
+
+	bpp = roundup2(gfx_fb.framebuffer_common.framebuffer_bpp, 8) >> 3;
+	width = png->width;
+	height = png->height;
+	da.width = png->width;
+	da.height = png->height;
+	da.col = gfx_fb.framebuffer_common.framebuffer_width -
+	    tems.ts_p_offset.x;
+	da.col -= da.width;
+	da.row = gfx_fb.framebuffer_common.framebuffer_height -
+	    tems.ts_p_offset.y;
+	da.row -= da.height;
+
+	/*
+	 * mark area used in tem
+	 */
+	tem_image_display(tems.ts_active, da.row / tems.ts_font.vf_height - 1,
+	    da.col / tems.ts_font.vf_width - 1,
+	    tems.ts_c_dimension.height - 1,
+	    tems.ts_c_dimension.width - 1);
+
+	da.data = malloc(width * height * bpp);
+	if (da.data == NULL)
+		return (1);
+
+	/*
+	 * Build image for our framebuffer.
+	 */
+	for (i = 0; i < height * width * png->bpp; i += png->bpp) {
+		r = png->image[i];
+		g = png->image[i+1];
+		b = png->image[i+2];
+		a = png->image[i+3];
+
+		j = i / png->bpp * bpp;
+		color = r >> (8 - gfx_fb.u.fb2.framebuffer_red_mask_size)
+		    << gfx_fb.u.fb2.framebuffer_red_field_position;
+		color |= g >> (8 - gfx_fb.u.fb2.framebuffer_green_mask_size)
+		    << gfx_fb.u.fb2.framebuffer_green_field_position;
+		color |= b >> (8 - gfx_fb.u.fb2.framebuffer_blue_mask_size)
+		    << gfx_fb.u.fb2.framebuffer_blue_field_position;
+
+		switch (gfx_fb.framebuffer_common.framebuffer_bpp) {
+		case 8: {
+			uint32_t best, dist, k;
+			int diff;
+
+			color = 0;
+			best = 256 * 256 * 256;
+			for (k = 0; k < 16; k++) {
+				diff = r - cmap4_to_24.red[k];
+				dist = diff * diff;
+				diff = g - cmap4_to_24.green[k];
+				dist += diff * diff;
+				diff = b - cmap4_to_24.blue[k];
+				dist += diff * diff;
+
+				if (dist < best) {
+					color = k;
+					best = dist;
+					if (dist == 0)
+						break;
+				}
+			}
+			da.data[j] = solaris_color_to_pc_color[color];
+			break;
+		}
+		case 15:
+		case 16:
+			*(uint16_t *)(da.data+j) = color;
+			break;
+		case 24:
+			p = (uint8_t *)&color;
+			da.data[j] = p[0];
+			da.data[j+1] = p[1];
+			da.data[j+2] = p[2];
+			break;
+		case 32:
+			color |= a << 24;
+			*(uint32_t *)(da.data+j) = color;
+			break;
+		}
+	}
+
+	gfx_fb_cons_display(&da);
+	free(da.data);
+	return (0);
+}
+
+static int
+load_mapping(int fd, struct font *fp, int n)
+{
+	size_t i, size;
+	ssize_t rv;
+	struct font_map *mp;
+
+	if (fp->vf_map_count[n] == 0)
+		return (0);
+
+	size = fp->vf_map_count[n] * sizeof (*mp);
+	mp = malloc(size);
+	if (mp == NULL)
+		return (ENOMEM);
+	fp->vf_map[n] = mp;
+
+	rv = read(fd, mp, size);
+	if (rv < 0 || (size_t)rv != size) {
+		free(fp->vf_map[n]);
+		fp->vf_map[n] = NULL;
+		return (EIO);
+	}
+
+	for (i = 0; i < fp->vf_map_count[n]; i++) {
+		mp[i].font_src = be32toh(mp[i].font_src);
+		mp[i].font_dst = be16toh(mp[i].font_dst);
+		mp[i].font_len = be16toh(mp[i].font_len);
+	}
+	return (0);
+}
+
+/* Load font from file. */
+static bitmap_data_t *
+load_font(char *path)
+{
+	int fd, i;
+	uint32_t glyphs;
+	struct font_header fh;
+	struct fontlist *fl;
+	bitmap_data_t *bp = NULL;
+	struct font *fp;
+	size_t size;
+	ssize_t rv;
+
+	/* Get our entry from the font list. */
+	STAILQ_FOREACH(fl, &fonts, font_next) {
+		if (strcmp(fl->font_name, path) == 0)
+			break;
+	}
+	if (fl == NULL)
+		return (NULL);	/* Should not happen. */
+	bp = fl->font_data;
+	if (bp->font != NULL)
+		return (bp);
+
+	fd = open(path, O_RDONLY);
+	if (fd < 0) {
+		return (NULL);
+	}
+
+	size = sizeof (fh);
+	rv = read(fd, &fh, size);
+	if (rv < 0 || (size_t)rv != size) {
+		bp = NULL;
+		goto done;
+	}
+	if (memcmp(fh.fh_magic, FONT_HEADER_MAGIC, sizeof (fh.fh_magic)) != 0) {
+		bp = NULL;
+		goto done;
+	}
+	if ((fp = calloc(1, sizeof (struct font))) == NULL) {
+		bp = NULL;
+		goto done;
+	}
+	for (i = 0; i < VFNT_MAPS; i++)
+		fp->vf_map_count[i] = be32toh(fh.fh_map_count[i]);
+
+	glyphs = be32toh(fh.fh_glyph_count);
+	fp->vf_width = fh.fh_width;
+	fp->vf_height = fh.fh_height;
+
+	bp->uncompressed_size = howmany(bp->width, 8) * bp->height * glyphs;
+	size = bp->uncompressed_size;
+	if ((fp->vf_bytes = malloc(size)) == NULL)
+		goto free_done;
+
+	rv = read(fd, fp->vf_bytes, size);
+	if (rv < 0 || (size_t)rv != size)
+		goto free_done;
+	for (i = 0; i < VFNT_MAPS; i++) {
+		if (load_mapping(fd, fp, i) != 0)
+			goto free_done;
+	}
+	bp->font = fp;
+
+	/*
+	 * Release previously loaded entry. We can do this now, as
+	 * the new font is loaded. Note, there can be no console
+	 * output till the new font is in place and tem is notified.
+	 * We do need to keep fl->font_data for glyph dimensions.
+	 */
+	STAILQ_FOREACH(fl, &fonts, font_next) {
+		if (fl->font_data->width == bp->width &&
+		    fl->font_data->height == bp->height)
+			continue;
+
+		if (fl->font_data->font != NULL) {
+			for (i = 0; i < VFNT_MAPS; i++)
+				free(fl->font_data->font->vf_map[i]);
+
+			/* Unset vf_bytes pointer in tem. */
+			if (tems.ts_font.vf_bytes ==
+			    fl->font_data->font->vf_bytes) {
+				tems.ts_font.vf_bytes = NULL;
+			}
+			free(fl->font_data->font->vf_bytes);
+			free(fl->font_data->font);
+			fl->font_data->font = NULL;
+			fl->font_data->uncompressed_size = 0;
+			fl->font_flags = FONT_AUTO;
+		}
+	}
+
+	/* free the uncompressed builtin font data in tem. */
+	free(tems.ts_font.vf_bytes);
+	tems.ts_font.vf_bytes = NULL;
+
+done:
+	close(fd);
+	return (bp);
+
+free_done:
+	for (i = 0; i < VFNT_MAPS; i++)
+		free(fp->vf_map[i]);
+	free(fp->vf_bytes);
+	free(fp);
+	bp = NULL;
+	goto done;
+}
+
+
+struct name_entry {
+	char			*n_name;
+	SLIST_ENTRY(name_entry)	n_entry;
+};
+
+SLIST_HEAD(name_list, name_entry);
+
+/* Read font names from index file. */
+static struct name_list *
+read_list(char *fonts)
+{
+	struct name_list *nl;
+	struct name_entry *np;
+	char buf[PATH_MAX];
+	int fd, len;
+
+	fd = open(fonts, O_RDONLY);
+	if (fd < 0)
+		return (NULL);
+
+	nl = malloc(sizeof (*nl));
+	if (nl == NULL) {
+		close(fd);
+		return (nl);
+	}
+
+	SLIST_INIT(nl);
+	while ((len = fgetstr(buf, sizeof (buf), fd)) > 0) {
+		np = malloc(sizeof (*np));
+		if (np == NULL) {
+			close(fd);
+			return (nl);    /* return what we have */
+		}
+		np->n_name = strdup(buf);
+		if (np->n_name == NULL) {
+			free(np);
+			close(fd);
+			return (nl);    /* return what we have */
+		}
+		SLIST_INSERT_HEAD(nl, np, n_entry);
+	}
+	close(fd);
+	return (nl);
+}
+
+/*
+ * Read the font properties and insert new entry into the list.
+ * The font list is built in descending order.
+ */
+static bool
+insert_font(char *name)
+{
+	struct font_header fh;
+	struct fontlist *fp, *previous, *entry, *next;
+	size_t size;
+	ssize_t rv;
+	int fd;
+	char *font_name;
+
+	fd = open(name, O_RDONLY);
+	if (fd < 0)
+		return (false);
+	rv = read(fd, &fh, sizeof (fh));
+	close(fd);
+	if (rv < 0 || (size_t)rv != sizeof (fh))
+		return (false);
+
+	if (memcmp(fh.fh_magic, FONT_HEADER_MAGIC, sizeof (fh.fh_magic)) != 0)
+		return (false);
+
+	font_name = strdup(name);
+	if (font_name == NULL)
+		return (false);
+
+	/*
+	 * If we have an entry with the same glyph dimensions, just replace
+	 * the file name. We only support unique dimensions.
+	 */
+	STAILQ_FOREACH(entry, &fonts, font_next) {
+		if (fh.fh_width == entry->font_data->width &&
+		    fh.fh_height == entry->font_data->height) {
+			free(entry->font_name);
+			entry->font_name = font_name;
+			return (true);
+		}
+	}
+
+	fp = calloc(sizeof (*fp), 1);
+	if (fp == NULL) {
+		free(font_name);
+		return (false);
+	}
+	fp->font_data = calloc(sizeof (*fp->font_data), 1);
+	if (fp->font_data == NULL) {
+		free(font_name);
+		free(fp);
+		return (false);
+	}
+	fp->font_name = font_name;
+	fp->font_flags = FONT_AUTO;
+	fp->font_load = load_font;
+	fp->font_data->width = fh.fh_width;
+	fp->font_data->height = fh.fh_height;
+
+	if (STAILQ_EMPTY(&fonts)) {
+		STAILQ_INSERT_HEAD(&fonts, fp, font_next);
+		return (true);
+	}
+
+	previous = NULL;
+	size = fp->font_data->width * fp->font_data->height;
+
+	STAILQ_FOREACH(entry, &fonts, font_next) {
+		/* Should fp be inserted before the entry? */
+		if (size >
+		    entry->font_data->width * entry->font_data->height) {
+			if (previous == NULL) {
+				STAILQ_INSERT_HEAD(&fonts, fp, font_next);
+			} else {
+				STAILQ_INSERT_AFTER(&fonts, previous, fp,
+				    font_next);
+			}
+			return (true);
+		}
+		next = STAILQ_NEXT(entry, font_next);
+		if (next == NULL ||
+		    size > next->font_data->width * next->font_data->height) {
+			STAILQ_INSERT_AFTER(&fonts, entry, fp, font_next);
+			return (true);
+		}
+		previous = entry;
+	}
+	return (true);
+}
+
+static int
+font_set(struct env_var *ev __unused, int flags __unused, const void *value)
+{
+	struct fontlist *fl, *tmp;
+	char *eptr;
+	unsigned long x = 0, y = 0;
+
+	/*
+	 * Attempt to extract values from "XxY" string. In case of error,
+	 * we have unmaching glyph dimensions and will just output the
+	 * available values.
+	 */
+	if (value != NULL) {
+		x = strtoul(value, &eptr, 10);
+		if (*eptr == 'x')
+			y = strtoul(eptr + 1, &eptr, 10);
+	}
+	STAILQ_FOREACH(fl, &fonts, font_next) {
+		if (fl->font_data->width == x && fl->font_data->height == y)
+			break;
+	}
+	if (fl != NULL) {
+		/* Reset any FONT_MANUAL flag. */
+		STAILQ_FOREACH(tmp, &fonts, font_next)
+			tmp->font_flags = FONT_AUTO;
+
+		fl->font_flags = FONT_MANUAL;
+		/* Trigger tem update. */
+		tems.update_font = true;
+		plat_cons_update_mode(-1);
+		return (CMD_OK);
+	}
+
+	printf("Available fonts:\n");
+	STAILQ_FOREACH(fl, &fonts, font_next) {
+		printf("    %dx%d\n", fl->font_data->width,
+		    fl->font_data->height);
+	}
+	return (CMD_OK);
+}
+
+void
+autoload_font(void)
+{
+	struct name_list *nl;
+	struct name_entry *np;
+
+	nl = read_list("/boot/fonts/fonts.dir");
+	if (nl == NULL)
+		return;
+
+	while (!SLIST_EMPTY(nl)) {
+		np = SLIST_FIRST(nl);
+		SLIST_REMOVE_HEAD(nl, n_entry);
+		if (insert_font(np->n_name) == false)
+			printf("failed to add font: %s\n", np->n_name);
+		free(np->n_name);
+		free(np);
+	}
+
+	unsetenv("screen-font");
+	env_setenv("screen-font", EV_VOLATILE, NULL, font_set, env_nounset);
+	/* Trigger tem update. */
+	tems.update_font = true;
+	plat_cons_update_mode(-1);
+}
+
+COMMAND_SET(load_font, "loadfont", "load console font from file", command_font);
+
+static int
+command_font(int argc, char *argv[])
+{
+	int i, rc = CMD_OK;
+	struct fontlist *fl;
+	bitmap_data_t *bd;
+
+	if (argc > 2) {
+		printf("Usage: loadfont [file.fnt]\n");
+		return (CMD_ERROR);
+	}
+
+	if (argc == 2) {
+		char *name = argv[1];
+
+		if (insert_font(name) == false) {
+			printf("loadfont error: failed to load: %s\n", name);
+			return (CMD_ERROR);
+		}
+
+		bd = load_font(name);
+		if (bd == NULL) {
+			printf("loadfont error: failed to load: %s\n", name);
+			return (CMD_ERROR);
+		}
+
+		/* Get the font list entry and mark it manually loaded. */
+		STAILQ_FOREACH(fl, &fonts, font_next) {
+			if (strcmp(fl->font_name, name) == 0)
+				fl->font_flags = FONT_MANUAL;
+		}
+		tems.update_font = true;
+		plat_cons_update_mode(-1);
+		return (CMD_OK);
+	}
+
+	if (argc == 1) {
+		/*
+		 * Walk entire font list, release any loaded font, and set
+		 * autoload flag. If the font list is empty, the tem will
+		 * get the builtin default.
+		 */
+		STAILQ_FOREACH(fl, &fonts, font_next) {
+			if (fl->font_data->font != NULL) {
+				/* Note the tem is releasing font bytes */
+				for (i = 0; i < VFNT_MAPS; i++)
+					free(fl->font_data->font->vf_map[i]);
+				free(fl->font_data->font);
+				fl->font_data->font = NULL;
+				fl->font_data->uncompressed_size = 0;
+				fl->font_flags = FONT_AUTO;
+			}
+		}
+		tems.update_font = true;
+		plat_cons_update_mode(-1);
+	}
+	return (rc);
+}
diff --git a/usr/src/boot/sys/boot/common/gfx_fb.h b/usr/src/boot/sys/boot/common/gfx_fb.h
new file mode 100644
index 0000000000..5161383759
--- /dev/null
+++ b/usr/src/boot/sys/boot/common/gfx_fb.h
@@ -0,0 +1,115 @@
+/*
+ * This file and its contents are supplied under the terms of the
+ * Common Development and Distribution License ("CDDL"), version 1.0.
+ * You may only use this file in accordance with the terms of version
+ * 1.0 of the CDDL.
+ *
+ * A full copy of the text of the CDDL should have accompanied this
+ * source.  A copy of the CDDL is also available via the Internet at
+ * http://www.illumos.org/license/CDDL.
+ */
+
+/*
+ * Copyright 2017 Toomas Soome <tsoome@me.com>
+ */
+
+#ifndef _GFX_FB_H
+#define	_GFX_FB_H
+
+#include <stdbool.h>
+#include <sys/visual_io.h>
+#include <sys/multiboot2.h>
+#include <pnglite.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define	EDID_MAGIC	{ 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 }
+
+struct edid_header {
+	uint8_t header[8];	/* fixed header pattern */
+	uint16_t manufacturer_id;
+	uint16_t product_code;
+	uint32_t serial_number;
+	uint8_t week_of_manufacture;
+	uint8_t year_of_manufacture;
+	uint8_t version;
+	uint8_t revision;
+};
+
+struct edid_basic_display_parameters {
+	uint8_t video_input_parameters;
+	uint8_t max_horizontal_image_size;
+	uint8_t max_vertical_image_size;
+	uint8_t display_gamma;
+	uint8_t supported_features;
+};
+
+struct edid_chromaticity_coordinates {
+	uint8_t red_green_lo;
+	uint8_t blue_white_lo;
+	uint8_t red_x_hi;
+	uint8_t red_y_hi;
+	uint8_t green_x_hi;
+	uint8_t green_y_hi;
+	uint8_t blue_x_hi;
+	uint8_t blue_y_hi;
+	uint8_t white_x_hi;
+	uint8_t white_y_hi;
+};
+
+struct edid_detailed_timings {
+	uint16_t pixel_clock;
+	uint8_t horizontal_active_lo;
+	uint8_t horizontal_blanking_lo;
+	uint8_t horizontal_hi;
+	uint8_t vertical_active_lo;
+	uint8_t vertical_blanking_lo;
+	uint8_t vertical_hi;
+	uint8_t horizontal_sync_offset_lo;
+	uint8_t horizontal_sync_pulse_width_lo;
+	uint8_t vertical_sync_lo;
+	uint8_t sync_hi;
+	uint8_t horizontal_image_size_lo;
+	uint8_t vertical_image_size_lo;
+	uint8_t image_size_hi;
+	uint8_t horizontal_border;
+	uint8_t vertical_border;
+	uint8_t features;
+};
+
+struct vesa_edid_info {
+	struct edid_header header;
+	struct edid_basic_display_parameters display;
+#define	EDID_FEATURE_PREFERRED_TIMING_MODE	(1 << 1)
+	struct edid_chromaticity_coordinates chromaticity;
+	uint8_t established_timings_1;
+	uint8_t established_timings_2;
+	uint8_t manufacturer_reserved_timings;
+	uint16_t standard_timings[8];
+	struct edid_detailed_timings detailed_timings[4];
+	uint8_t number_of_extensions;
+	uint8_t checksum;
+} __packed;
+
+extern multiboot_tag_framebuffer_t gfx_fb;
+
+void gfx_framework_init(struct visual_ops *);
+uint32_t gfx_fb_color_map(uint8_t);
+void gfx_fb_display_cursor(struct vis_conscursor *);
+void gfx_fb_setpixel(uint32_t, uint32_t);
+void gfx_fb_drawrect(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+void gfx_term_drawrect(uint32_t, uint32_t, uint32_t, uint32_t);
+void gfx_fb_line(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
+void gfx_fb_bezier(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t,
+	uint32_t);
+void plat_cons_update_mode(int);
+int gfx_fb_putimage(png_t *);
+
+bool gfx_parse_mode_str(char *, int *, int *, int *);
+#ifdef  __cplusplus
+}
+#endif
+
+#endif  /* _GFX_FB_H */
diff --git a/usr/src/boot/sys/boot/common/help.common b/usr/src/boot/sys/boot/common/help.common
index ead8511faf..7342c95a55 100644
--- a/usr/src/boot/sys/boot/common/help.common
+++ b/usr/src/boot/sys/boot/common/help.common
@@ -80,8 +80,19 @@
 	will print the current device.
 
 ################################################################################
+# Tframebuffer DManage framebuffer setup
+
+	framebuffer on | off | get | list [depth] | set <display or mode number>
+
+	Switch framebuffer mode on or off, get current mode, list available
+	modes or set mode by using either display resolution or framebuffer
+	mode number. If the system does not provide display resolution via
+	EDID, the default resolution will be set to 800x600. If depth is not
+	specified, the best depth is used.
+
+################################################################################
 # Tload DLoad a kernel or module
-	
+
 	load [-t <type>] <filename> [arguments]
 
 	Loads the module contained in <filename> into memory.  If no other
@@ -172,45 +183,40 @@
 	Sets the default set of kernel boot filename(s). It may be overridden
 	by setting the bootfile variable to a semicolon-separated list of
 	filenames, each of which will be searched for in the module_path
-	directories. The default bootfile set is "kernel".
-
-################################################################################
-# Tset Sboot_askname DPrompt for root device
-
-	set boot_askname
-
-	Instructs the kernel to prompt the user for the name of the root device
-	when the kernel is booted.
+	directories. The default bootfile set is "unix".
 
 ################################################################################
-# Tset Sboot_cdrom DMount root file system from CD-ROM
+# Tset Sboot_ask DPrompt for configuration information
 
-	set boot_cdrom
+	set boot_ask
 
-	Instructs the kernel to try to mount the root file system from CD-ROM.
+	Instructs the kernel to prompt the user for the configuration
+	information when the kernel is booted.
 
 ################################################################################
-# Tset Sboot_ddb DDrop to the kernel debugger (DDB)
+# Tset Sboot_debug DDrop to the kernel debugger (kmdb)
 
-	set boot_ddb
+	set boot_debug
 
-	Instructs the kernel to start in the DDB debugger, rather than
-	proceeding to initialize when booted.
+	Instructs the kernel to start in the kmdb debugger, rather than
+	proceeding to initialize when booted. Can only be used when boot_kmdb
+	is set.
 
 ################################################################################
-# Tset Sboot_dfltroot DUse default root file system
+# Tset Sboot_kmdb DStart the kernel debugger (kmdb)
 
-	set boot_dfltroot
+	set boot_kmdb
 
-	Instructs the kernel to mount the statically compiled-in root
-	file system.
+	Instructs the kernel to start the kmdb debugger and then continue
+	with normal boot.
 
 ################################################################################
-# Tset Sboot_gdb DSelect gdb-remote mode for the kernel debugger
+# Tset Sboot_reconfigure DInitaiate reconfiguration boot
 
-	set boot_gdb
+	set boot_reconfigure
 
-	Selects gdb-remote mode for the kernel debugger by default.
+	The system will probe all attached hardware devices and configure
+	the logical namespace in /dev.
 
 ################################################################################
 # Tset Sboot_multicons DUse multiple consoles
@@ -222,50 +228,23 @@
 	by the conscontrol(8) utility.
 
 ################################################################################
-# Tset Sboot_mute DMute the console
-
-	set boot_mute
-
-	All console output is suppressed when console is muted.
-	In a running system, the state of console muting can be
-	manipulated by the conscontrol(8) utility.
-
-################################################################################
-# Tset Sboot_pause DPause after each line during device probing
-
-	set boot_pause
-
-	During the device probe, pause after each line is printed.
-
-################################################################################
-# Tset Sboot_serial DUse serial console
-
-	set boot_serial
-
-	Force the use of a serial console even when an internal console
-	is present.
-
-################################################################################
-# Tset Sboot_single DStart system in single-user mode
+# Tset Sboot_single DBoot into the single user mode
 
 	set boot_single
 
-	Prevents the kernel from initiating a multi-user startup; instead,
-	a single-user mode will be entered when the kernel has finished
-	device probes.
+	Boots only to init level 's'.
 
 ################################################################################
-# Tset Sboot_verbose DVerbose boot messages
+# Tset Sboot_verbose DBoot with verbose messages enabled
 
 	set boot_verbose
 
-	Setting this variable causes extra debugging information to be printed
-	by the kernel during the boot phase.
+	Without this setting, the messages are only logged in the system log.
 
 ################################################################################
 # Tset Sconsole DSet the current console
 
-	set console[=<value>]
+	set console[=<value>[,<value>]]
 
 	Sets the current console.  If <value> is omitted, a list of valid
 	consoles will be displayed.
@@ -278,15 +257,6 @@
 	Selects the default device.  See lsdev for available devices.
 
 ################################################################################
-# Tset Sinit_path DSet the list of init candidates
-
-	set init_path=<path>[:<path>...]
-
-	Sets the list of binaries which the kernel will try to run as initial
-	process.
-
-
-################################################################################
 # Tset Smodule_path DSet the module search path
 
 	set module_path=<path>[;<path>...]
@@ -302,12 +272,18 @@
 	set prompt=<value>
 
 	The command prompt is displayed when the loader is waiting for input.
-	Variable substitution is performed on the prompt.  The default 
+	Variable substitution is performed on the prompt.  The default
 	prompt can be set with:
 
 		set prompt=\${interpret}
 
 ################################################################################
+# Tset Sscreen-font DSet the framebuffer font
+
+	Without the value, will list the currently available list
+	of the fonts.
+
+################################################################################
 # Tset Srootdev DSet the root filesystem
 
 	set rootdev=<path>
@@ -317,75 +293,6 @@
 	$rootdev explicitly.
 
 ################################################################################
-# Tset Stunables DSet kernel tunable values
-
-	Various kernel tunable parameters can be overridden by specifying new 
-	values in the environment.
-
-	set kern.ipc.nmbclusters=<value>
-
-		Set the number of mbuf clusters to be allocated.  The value
-		cannot be set below the default determined when the kernel
-		was compiled.
-
-	set kern.ipc.nsfbufs=<value>		NSFBUFS
-
-		Set the number of sendfile buffers to be allocated.  This
-		overrides the value determined when the kernel was compiled.
-
-	set vm.kmem_size=<value>		VM_KMEM_SIZE
-
-		Sets the size of kernel memory (bytes).  This overrides
-		the value determined when the kernel was compiled.
-
-	set machdep.disable_mtrrs=1
-
-		Disable the use of i686 MTRRs (i386 only)
-
-	set net.inet.tcp.tcbhashsize=<value>	TCBHASHSIZE
-
-		Overrides the compile-time set value of TCBHASHSIZE or
-		the preset default of 512.  Must be a power of 2.
-
-	hw.syscons.sc_no_suspend_vtswitch=<value>
-
-		Disable VT switching on suspend.
-
-		value is 0 (default) or non-zero to enable.
-
-	set hw.physmem=<value>			MAXMEM (i386 only)
-
-		Limits the amount of physical memory space available to
-		the system to <value> bytes.  <value> may have a k, M or G
-		suffix to indicate kilobytes, megabytes and gigabytes
-		respectively.  Note that the current i386 architecture
-		limits this value to 4GB.
-
-		On systems where memory cannot be accurately probed,
-		this option provides a hint as to the actual size of
-		system memory (which will be tested before use).
-
-	set hw.{acpi,pci}.host_start_mem=<value>
-
-		Sets the lowest address that the pci code will assign
-		when it doesn't have other information about the address
-		to assign (like from a pci bridge).  This is only useful
-		in older systems without a pci bridge.  Also, it only
-		impacts devices that the BIOS doesn't assign to, typically
-		CardBus bridges.  The default <value> is 0x80000000, but
-		some systems need values like 0xf0000000, 0xfc000000 or
-		0xfe000000 may be suitable for older systems (the older
-		the system, the higher the number typically should be).
-
-	set hw.pci.enable_io_modes=<value>
-
-		Enable PCI resources which are left off by some BIOSes
-		or are not enabled correctly by the device driver.
-
-		value is 1 (default), but this may cause problems with
-		some peripherals.  Set to 0 to disable.
-
-################################################################################
 # Tshow DShow the values of variables
 
 	show [<variable>]
@@ -405,12 +312,12 @@
 
 	read [-t <value>] [-p <prompt>] [<variable name>]
 
-	The read command reads a line of input from the terminal.  If the 
+	The read command reads a line of input from the terminal.  If the
 	-t argument is specified, it will return nothing if no input has been
-	received after <value> seconds.  (Any keypress will cancel the 
+	received after <value> seconds.  (Any keypress will cancel the
 	timeout).
 
-	If -p is specified, <prompt> is printed before reading input. No 
+	If -p is specified, <prompt> is printed before reading input. No
 	newline is emitted after the prompt.
 
 	If a variable name is supplied, the variable is set to the value read,
@@ -429,6 +336,6 @@
 	unset <variable name>
 
 	If allowed, the named variable's value is discarded and the variable
-	is removed.	
+	is removed.
 
 ################################################################################
diff --git a/usr/src/boot/sys/boot/common/linenoise/linenoise.c b/usr/src/boot/sys/boot/common/linenoise/linenoise.c
index e789a21d3f..871ffb5437 100755
--- a/usr/src/boot/sys/boot/common/linenoise/linenoise.c
+++ b/usr/src/boot/sys/boot/common/linenoise/linenoise.c
@@ -187,7 +187,7 @@ void linenoiseClearScreen(void) {
 static int
 getColumns(void)
 {
-	char *columns = getenv("COLUMNS");
+	char *columns = getenv("screen-#cols");
 	if (columns == NULL)
 		return (80);
 	return (strtol(columns, NULL, 0));
diff --git a/usr/src/boot/sys/boot/common/module.c b/usr/src/boot/sys/boot/common/module.c
index 50afdbef7f..243e8e466a 100644
--- a/usr/src/boot/sys/boot/common/module.c
+++ b/usr/src/boot/sys/boot/common/module.c
@@ -1,4 +1,4 @@
-/*-
+/*
  * Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
  * All rights reserved.
  *
@@ -37,6 +37,8 @@
 #include <sys/module.h>
 #include <sys/queue.h>
 #include <sys/stdint.h>
+#include <sys/tem_impl.h>
+#include <sys/font.h>
 
 #include "bootstrap.h"
 
@@ -103,7 +105,7 @@ command_load(int argc, char *argv[])
 {
     char	*typestr;
     int		dofile, dokld, ch, error;
-    
+
     dokld = dofile = 0;
     optind = 1;
     optreset = 1;
@@ -165,7 +167,7 @@ command_load(int argc, char *argv[])
 		"warning: KLD '%s' already loaded", argv[1]);
 	    return (CMD_WARN);
 	}
-	
+
 	return (error == 0 ? CMD_OK : CMD_CRIT);
     }
     /*
@@ -443,6 +445,7 @@ build_environment_module(void)
 		return;
 	}
 
+	tem_save_state();	/* Ask tem to save it's state in env. */
 	size = env_get_size();
 
 	fp = file_alloc();
@@ -483,6 +486,111 @@ build_environment_module(void)
 	file_insert_tail(fp);
 }
 
+void
+build_font_module(void)
+{
+	bitmap_data_t *bd;
+	struct font *fd;
+	struct preloaded_file *fp;
+	size_t size;
+	uint32_t checksum;
+	int i;
+	char *name = "console-font";
+	vm_offset_t laddr;
+	struct font_info fi;
+	struct fontlist *fl;
+
+	if (STAILQ_EMPTY(&fonts))
+		return;
+
+	/* We can't load first */
+	if ((file_findfile(NULL, NULL)) == NULL) {
+		printf("Can not load font module: %s\n",
+		    "the kernel is not loaded");
+		return;
+	}
+
+	/* helper pointers */
+	bd = NULL;
+	STAILQ_FOREACH(fl, &fonts, font_next) {
+		if (fl->font_data->font != NULL) {
+			bd = fl->font_data;
+			break;
+		}
+	}
+	if (bd == NULL)
+		return;
+	fd = bd->font;
+
+	fi.fi_width = fd->vf_width;
+	checksum = fi.fi_width;
+	fi.fi_height = fd->vf_height;
+	checksum += fi.fi_height;
+	fi.fi_bitmap_size = bd->uncompressed_size;
+	checksum += fi.fi_bitmap_size;
+
+	size = roundup2(sizeof (struct font_info), 8);
+	for (i = 0; i < VFNT_MAPS; i++) {
+		fi.fi_map_count[i] = fd->vf_map_count[i];
+		checksum += fi.fi_map_count[i];
+		size += fd->vf_map_count[i] * sizeof (struct font_map);
+		size += roundup2(size, 8);
+	}
+	size += bd->uncompressed_size;
+
+	fi.fi_checksum = -checksum;
+
+	fp = file_alloc();
+	if (fp != NULL) {
+		fp->f_name = strdup(name);
+		fp->f_type = strdup(name);
+	}
+
+	if (fp == NULL || fp->f_name == NULL || fp->f_type == NULL) {
+		printf("Can not load font module: %s\n",
+		    "out of memory");
+		if (fp != NULL)
+			file_discard(fp);
+		return;
+	}
+
+	if (archsw.arch_loadaddr != NULL)
+		loadaddr = archsw.arch_loadaddr(LOAD_MEM, &size, loadaddr);
+
+	if (loadaddr == 0) {
+		printf("Can not load font module: %s\n",
+		    "out of memory");
+		file_discard(fp);
+		return;
+	}
+
+	laddr = loadaddr;
+	laddr += archsw.arch_copyin(&fi, laddr, sizeof (struct font_info));
+	laddr = roundup2(laddr, 8);
+
+	/* Copy maps. */
+	for (i = 0; i < VFNT_MAPS; i++) {
+		if (fd->vf_map_count[i] != 0) {
+			laddr += archsw.arch_copyin(fd->vf_map[i], laddr,
+			    fd->vf_map_count[i] * sizeof (struct font_map));
+			laddr = roundup2(laddr, 8);
+		}
+	}
+
+	/* Copy the bitmap. */
+	laddr += archsw.arch_copyin(fd->vf_bytes, laddr, fi.fi_bitmap_size);
+
+	/* Looks OK so far; populate control structure */
+	fp->f_loader = -1;
+	fp->f_addr = loadaddr;
+	fp->f_size = laddr - loadaddr;
+
+	/* recognise space consumption */
+	loadaddr = laddr;
+
+	file_insert_tail(fp);
+}
+
 /*
  * We've been asked to load (fname) as (type), so just suck it in,
  * no arguments or anything.
@@ -568,7 +676,7 @@ file_loadraw(const char *fname, char *type, int argc, char **argv, int insert)
 
     /* Add to the list of loaded files */
     if (insert != 0)
-    	file_insert_tail(fp);
+	file_insert_tail(fp);
     close(fd);
     return(fp);
 }
@@ -630,7 +738,7 @@ mod_loadkld(const char *kldname, int argc, char *argv[])
 	    "can't find '%s'", kldname);
 	return (ENOENT);
     }
-    /* 
+    /*
      * Check if KLD already loaded
      */
     fp = file_findfile(filename, NULL);
@@ -640,7 +748,7 @@ mod_loadkld(const char *kldname, int argc, char *argv[])
 	free(filename);
 	return (0);
     }
-    for (last_file = preloaded_files; 
+    for (last_file = preloaded_files;
 	 last_file != NULL && last_file->f_next != NULL;
 	 last_file = last_file->f_next)
 	;
@@ -701,7 +809,7 @@ file_findmodule(struct preloaded_file *fp, char *modname,
     if (fp == NULL) {
 	for (fp = preloaded_files; fp; fp = fp->f_next) {
 	    mp = file_findmodule(fp, modname, verinfo);
-    	    if (mp)
+	    if (mp)
 		return (mp);
 	}
 	return (NULL);
@@ -715,7 +823,7 @@ file_findmodule(struct preloaded_file *fp, char *modname,
 	    mver = mp->m_version;
 	    if (mver == verinfo->md_ver_preferred)
 		return (mp);
-	    if (mver >= verinfo->md_ver_minimum && 
+	    if (mver >= verinfo->md_ver_minimum &&
 		mver <= verinfo->md_ver_maximum &&
 		mver > bestver) {
 		best = mp;
@@ -902,7 +1010,7 @@ mod_search_hints(struct moduledir *mdp, const char *modname,
 		found = 1;
 		break;
 	    }
-	    if (ival >= verinfo->md_ver_minimum && 
+	    if (ival >= verinfo->md_ver_minimum &&
 		ival <= verinfo->md_ver_maximum &&
 		ival > bestver) {
 		bestver = ival;
@@ -1024,7 +1132,7 @@ struct preloaded_file *
 file_alloc(void)
 {
     struct preloaded_file	*fp;
-    
+
     if ((fp = malloc(sizeof(struct preloaded_file))) != NULL) {
 	bzero(fp, sizeof(struct preloaded_file));
     }
@@ -1038,7 +1146,7 @@ static void
 file_insert_tail(struct preloaded_file *fp)
 {
     struct preloaded_file	*cm;
-    
+
     /* Append to list of loaded file */
     fp->f_next = NULL;
     if (preloaded_files == NULL) {
diff --git a/usr/src/boot/sys/boot/common/multiboot2.c b/usr/src/boot/sys/boot/common/multiboot2.c
index c0477ecc1a..5b2cb9d397 100644
--- a/usr/src/boot/sys/boot/common/multiboot2.c
+++ b/usr/src/boot/sys/boot/common/multiboot2.c
@@ -34,6 +34,7 @@
 #include "libzfs.h"
 
 #include "bootstrap.h"
+#include <sys/consplat.h>
 
 #include <machine/metadata.h>
 #include <machine/pc/bios.h>
@@ -42,8 +43,9 @@
 #include <bootp.h>
 
 #if !defined(EFI)
-#include "../i386/libi386/libi386.h"
 #include "../i386/btx/lib/btxv86.h"
+#include "libi386.h"
+#include "vbe.h"
 
 #else
 #include <efi.h>
@@ -195,6 +197,7 @@ multiboot2_loadfile(char *filename, u_int64_t dest,
 	if (header == NULL)
 		goto out;
 
+	have_framebuffer = false;
 	for (tag = header->mb2_tags; tag->mbh_type != MULTIBOOT_TAG_TYPE_END;
 	    tag = (multiboot_header_tag_t *)((uintptr_t)tag +
 	    roundup2(tag->mbh_size, MULTIBOOT_TAG_ALIGN))) {
@@ -731,6 +734,9 @@ static size_t
 mbi_size(struct preloaded_file *fp, char *cmdline)
 {
 	size_t size;
+#if !defined (EFI)
+	extern multiboot_tag_framebuffer_t gfx_fb;
+#endif
 
 	size = sizeof (uint32_t) * 2; /* first 2 fields from MBI header */
 	size += sizeof (multiboot_tag_string_t) + strlen(cmdline) + 1;
@@ -754,9 +760,25 @@ mbi_size(struct preloaded_file *fp, char *cmdline)
 		size = roundup2(size, MULTIBOOT_TAG_ALIGN);
 	}
 #endif
+
 	size += biossmap_size(fp);
 	size = roundup2(size, MULTIBOOT_TAG_ALIGN);
 
+#if !defined (EFI)
+	if (gfx_fb.framebuffer_common.framebuffer_type ==
+	    MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED) {
+		size += sizeof (struct multiboot_tag_framebuffer_common);
+		size += gfx_fb.u.fb1.framebuffer_palette_num_colors *
+		    sizeof (multiboot_color_t);
+	} else {
+		size += sizeof (multiboot_tag_framebuffer_t);
+	}
+	size = roundup2(size, MULTIBOOT_TAG_ALIGN);
+
+	size += sizeof (multiboot_tag_vbe_t);
+	size = roundup2(size, MULTIBOOT_TAG_ALIGN);
+#endif
+
 	if (bootp_response != NULL) {
 		size += sizeof(multiboot_tag_network_t) + bootp_response_size;
 		size = roundup2(size, MULTIBOOT_TAG_ALIGN);
@@ -801,6 +823,11 @@ multiboot2_exec(struct preloaded_file *fp)
 	efi_getdev((void **)(&rootdev), NULL, NULL);
 #else
 	i386_getdev((void **)(&rootdev), NULL, NULL);
+
+	if (have_framebuffer == false) {
+		/* make sure we have text mode */
+		bios_set_text_mode(VGA_TEXT_MODE);
+	}
 #endif
 
 	mbi = NULL;
@@ -831,6 +858,11 @@ multiboot2_exec(struct preloaded_file *fp)
 	/* mb_kernel_cmdline() updates the environment. */
 	build_environment_module();
 
+	if (have_framebuffer == true) {
+		/* Pass the loaded console font for kernel. */
+		build_font_module();
+	}
+
 	size = mbi_size(fp, cmdline);	/* Get the size for MBI. */
 
 	/* Set up the base for mb_malloc. */
@@ -1017,6 +1049,20 @@ multiboot2_exec(struct preloaded_file *fp)
 		memcpy(tag->mb_dhcpack, bootp_response, bootp_response_size);
 	}
 
+#if !defined (EFI)
+	{
+		multiboot_tag_vbe_t *tag;
+		extern multiboot_tag_vbe_t vbestate;
+
+		if (VBE_VALID_MODE(vbestate.vbe_mode)) {
+			tag = (multiboot_tag_vbe_t *)mb_malloc(sizeof(*tag));
+			memcpy(tag, &vbestate, sizeof(*tag));
+			tag->mb_type = MULTIBOOT_TAG_TYPE_VBE;
+			tag->mb_size = sizeof(*tag);
+		}
+	}
+#endif
+
 	if (rsdp != NULL) {
 		multiboot_tag_new_acpi_t *ntag;
 		multiboot_tag_old_acpi_t *otag;
@@ -1059,60 +1105,50 @@ multiboot2_exec(struct preloaded_file *fp)
 		tag->mb_pointer = (uint32_t)ST;
 	}
 #endif /* __LP64__ */
+#endif /* EFI */
 
 	if (have_framebuffer == true) {
 		multiboot_tag_framebuffer_t *tag;
-		int bpp;
-		struct efi_fb fb;
-		extern int efi_find_framebuffer(struct efi_fb *efifb);
-
-		if (efi_find_framebuffer(&fb) == 0) {
-			tag = (multiboot_tag_framebuffer_t *)
-			    mb_malloc(sizeof (*tag));
-
-			/*
-			 * We assume contiguous color bitmap, and use
-			 * the msb for bits per pixel calculation.
-			 */
-			bpp = fls(fb.fb_mask_red | fb.fb_mask_green |
-			    fb.fb_mask_blue | fb.fb_mask_reserved);
-
-			tag->framebuffer_common.mb_type =
-			    MULTIBOOT_TAG_TYPE_FRAMEBUFFER;
-			tag->framebuffer_common.mb_size =
-			    sizeof (multiboot_tag_framebuffer_t);
-			tag->framebuffer_common.framebuffer_addr = fb.fb_addr;
-			tag->framebuffer_common.framebuffer_width = fb.fb_width;
-			tag->framebuffer_common.framebuffer_height =
-			    fb.fb_height;
-			tag->framebuffer_common.framebuffer_bpp = bpp;
-			/*
-			 * Pitch is stride * bytes per pixel.
-			 * Stride is pixels per scanline.
-			 */
-			tag->framebuffer_common.framebuffer_pitch =
-			    fb.fb_stride * (bpp / 8);
-			tag->framebuffer_common.framebuffer_type =
-			    MULTIBOOT_FRAMEBUFFER_TYPE_RGB;
-			tag->framebuffer_common.mb_reserved = 0;
-
-			/*
-			 * The RGB or BGR color ordering.
-			 */
-			if (fb.fb_mask_red & 0x000000ff) {
-				tag->u.fb2.framebuffer_red_field_position = 0;
-				tag->u.fb2.framebuffer_blue_field_position = 16;
-			} else {
-				tag->u.fb2.framebuffer_red_field_position = 16;
-				tag->u.fb2.framebuffer_blue_field_position = 0;
-			}
-			tag->u.fb2.framebuffer_red_mask_size = 8;
-			tag->u.fb2.framebuffer_green_field_position = 8;
-			tag->u.fb2.framebuffer_green_mask_size = 8;
-			tag->u.fb2.framebuffer_blue_mask_size = 8;
+		extern multiboot_tag_framebuffer_t gfx_fb;
+#if defined (EFI)
+
+		tag = (multiboot_tag_framebuffer_t *) mb_malloc(sizeof (*tag));
+		memcpy(tag, &gfx_fb, sizeof (*tag));
+		tag->framebuffer_common.mb_type =
+		    MULTIBOOT_TAG_TYPE_FRAMEBUFFER;
+		tag->framebuffer_common.mb_size = sizeof (*tag);
+#else
+		extern multiboot_color_t *cmap;
+		uint32_t size;
+
+		if (gfx_fb.framebuffer_common.framebuffer_type ==
+		    MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED) {
+			uint16_t nc;
+			nc = gfx_fb.u.fb1.framebuffer_palette_num_colors;
+			size = sizeof (struct multiboot_tag_framebuffer_common)
+			    + sizeof (nc)
+			    + nc * sizeof (multiboot_color_t);
+		} else {
+			size = sizeof (gfx_fb);
+		}
+
+		tag = (multiboot_tag_framebuffer_t *) mb_malloc(size);
+		memcpy(tag, &gfx_fb, sizeof (*tag));
+
+		tag->framebuffer_common.mb_type =
+		    MULTIBOOT_TAG_TYPE_FRAMEBUFFER;
+		tag->framebuffer_common.mb_size = size;
+
+		if (gfx_fb.framebuffer_common.framebuffer_type ==
+		    MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED) {
+			memcpy(tag->u.fb1.framebuffer_palette, cmap,
+			    sizeof (multiboot_color_t) *
+			    gfx_fb.u.fb1.framebuffer_palette_num_colors);
 		}
+#endif /* EFI */
 	}
 
+#if defined (EFI)
 	/* Leave EFI memmap last as we will also switch off the BS. */
 	{
 		multiboot_tag_efi_mmap_t *tag;
@@ -1173,7 +1209,7 @@ multiboot2_exec(struct preloaded_file *fp)
 		last_addr += map_size;
 		last_addr = roundup2(last_addr, MULTIBOOT_TAG_ALIGN);
 	}
-#endif
+#endif /* EFI */
 
 	/*
 	 * MB tag list end marker.
@@ -1251,7 +1287,7 @@ multiboot2_exec(struct preloaded_file *fp)
 	dev_cleanup();
 	__exec((void *)VTOP(multiboot_tramp), MULTIBOOT2_BOOTLOADER_MAGIC,
 	    (void *)entry_addr, (void *)VTOP(mbi));
-#endif
+#endif /* EFI */
 	panic("exec returned");
 
 error:
diff --git a/usr/src/boot/sys/boot/common/tem.c b/usr/src/boot/sys/boot/common/tem.c
new file mode 100644
index 0000000000..8399f835ef
--- /dev/null
+++ b/usr/src/boot/sys/boot/common/tem.c
@@ -0,0 +1,2848 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ * Copyright 2016 Joyent, Inc.
+ */
+
+/*
+ * ANSI terminal emulator module; parse ANSI X3.64 escape sequences and
+ * the like.
+ *
+ * How Virtual Terminal Emulator Works:
+ *
+ * Every virtual terminal is associated with a tem_vt_state structure
+ * and maintains a virtual screen buffer in tvs_screen_buf, which contains
+ * all the characters which should be shown on the physical screen when
+ * the terminal is activated.
+ *
+ * Data written to a virtual terminal is composed of characters which
+ * should be displayed on the screen when this virtual terminal is
+ * activated, fg/bg colors of these characters, and other control
+ * information (escape sequence, etc).
+ *
+ * When data is passed to a virtual terminal it first is parsed for
+ * control information by tem_parse().  Subsequently the character
+ * and color data are written to tvs_screen_buf.
+ * They are saved in buffer in order to refresh the screen when this
+ * terminal is activated.  If the terminal is currently active, the data
+ * (characters and colors) are also written to the physical screen by
+ * invoking a callback function, tem_text_callbacks() or tem_pix_callbacks().
+ *
+ * When rendering data to the framebuffer, if the framebuffer is in
+ * VIS_PIXEL mode, the character data will first be converted to pixel
+ * data using tem_pix_bit2pix(), and then the pixels get displayed
+ * on the physical screen.  We only store the character and color data in
+ * tem_vt_state since the bit2pix conversion only happens when actually
+ * rendering to the physical framebuffer.
+ */
+
+
+#include <stand.h>
+#include <sys/ascii.h>
+#include <sys/errno.h>
+#include <sys/tem_impl.h>
+#ifdef _HAVE_TEM_FIRMWARE
+#include <sys/promif.h>
+#endif /* _HAVE_TEM_FIRMWARE */
+#include <sys/consplat.h>
+#include <sys/kd.h>
+
+extern int lz4_decompress(void *, void *, size_t, size_t, int);
+
+/* Terminal emulator internal helper functions */
+static void	tems_setup_terminal(struct vis_devinit *, size_t, size_t);
+static void	tems_modechange_callback(struct vis_modechg_arg *,
+		    struct vis_devinit *);
+
+static void	tems_reset_colormap(void);
+
+static void	tem_free_buf(struct tem_vt_state *);
+static void	tem_internal_init(struct tem_vt_state *, boolean_t, boolean_t);
+static void	tems_get_initial_color(tem_color_t *pcolor);
+
+static void	tem_control(struct tem_vt_state *, uint8_t);
+static void	tem_setparam(struct tem_vt_state *, int, int);
+static void	tem_selgraph(struct tem_vt_state *);
+static void	tem_chkparam(struct tem_vt_state *, uint8_t);
+static void	tem_getparams(struct tem_vt_state *, uint8_t);
+static void	tem_outch(struct tem_vt_state *, tem_char_t);
+static void	tem_parse(struct tem_vt_state *, tem_char_t);
+
+static void	tem_new_line(struct tem_vt_state *);
+static void	tem_cr(struct tem_vt_state *);
+static void	tem_lf(struct tem_vt_state *);
+static void	tem_send_data(struct tem_vt_state *);
+static void	tem_cls(struct tem_vt_state *);
+static void	tem_tab(struct tem_vt_state *);
+static void	tem_back_tab(struct tem_vt_state *);
+static void	tem_clear_tabs(struct tem_vt_state *, int);
+static void	tem_set_tab(struct tem_vt_state *);
+static void	tem_mv_cursor(struct tem_vt_state *, int, int);
+static void	tem_shift(struct tem_vt_state *, int, int);
+static void	tem_scroll(struct tem_vt_state *, int, int, int, int);
+static void	tem_clear_chars(struct tem_vt_state *tem,
+			int count, screen_pos_t row, screen_pos_t col);
+static void	tem_copy_area(struct tem_vt_state *tem,
+			screen_pos_t s_col, screen_pos_t s_row,
+			screen_pos_t e_col, screen_pos_t e_row,
+			screen_pos_t t_col, screen_pos_t t_row);
+static void	tem_bell(struct tem_vt_state *tem);
+static void	tem_pix_clear_prom_output(struct tem_vt_state *tem);
+
+static void	tem_virtual_cls(struct tem_vt_state *, size_t, screen_pos_t,
+		    screen_pos_t);
+static void	tem_virtual_display(struct tem_vt_state *, term_char_t *,
+		    size_t, screen_pos_t, screen_pos_t);
+static void	tem_align_cursor(struct tem_vt_state *tem);
+
+static void	tem_check_first_time(struct tem_vt_state *tem);
+static void	tem_reset_display(struct tem_vt_state *, boolean_t, boolean_t);
+static void	tem_terminal_emulate(struct tem_vt_state *, uint8_t *, int);
+static void	tem_text_cursor(struct tem_vt_state *, short);
+static void	tem_text_cls(struct tem_vt_state *,
+		    int count, screen_pos_t row, screen_pos_t col);
+static void	tem_pix_display(struct tem_vt_state *, term_char_t *,
+		    int, screen_pos_t, screen_pos_t);
+static void	tem_pix_copy(struct tem_vt_state *,
+		    screen_pos_t, screen_pos_t,
+		    screen_pos_t, screen_pos_t,
+		    screen_pos_t, screen_pos_t);
+static void	tem_pix_cursor(struct tem_vt_state *, short);
+static void	tem_get_attr(struct tem_vt_state *, text_color_t *,
+		    text_color_t *, text_attr_t *, uint8_t);
+static void	tem_get_color(text_color_t *, text_color_t *, term_char_t);
+static void	tem_pix_align(struct tem_vt_state *);
+static void	tem_text_display(struct tem_vt_state *, term_char_t *, int,
+		    screen_pos_t, screen_pos_t);
+static void	tem_text_copy(struct tem_vt_state *,
+		    screen_pos_t, screen_pos_t, screen_pos_t, screen_pos_t,
+		    screen_pos_t, screen_pos_t);
+static void	tem_pix_bit2pix(struct tem_vt_state *, term_char_t);
+static void	tem_pix_cls_range(struct tem_vt_state *, screen_pos_t, int,
+		    int, screen_pos_t, int, int, boolean_t);
+static void	tem_pix_cls(struct tem_vt_state *, int,
+		    screen_pos_t, screen_pos_t);
+
+static void	bit_to_pix4(struct tem_vt_state *tem, tem_char_t c,
+		    text_color_t fg_color, text_color_t bg_color);
+static void	bit_to_pix8(struct tem_vt_state *tem, tem_char_t c,
+		    text_color_t fg_color, text_color_t bg_color);
+static void	bit_to_pix16(struct tem_vt_state *tem, tem_char_t c,
+		    text_color_t fg_color, text_color_t bg_color);
+static void	bit_to_pix24(struct tem_vt_state *tem, tem_char_t c,
+		    text_color_t fg_color, text_color_t bg_color);
+static void	bit_to_pix32(struct tem_vt_state *tem, tem_char_t c,
+		    text_color_t fg_color, text_color_t bg_color);
+
+/*
+ * Globals
+ */
+tem_state_t	tems;	/* common term info */
+
+tem_callbacks_t tem_text_callbacks = {
+	.tsc_display = &tem_text_display,
+	.tsc_copy = &tem_text_copy,
+	.tsc_cursor = &tem_text_cursor,
+	.tsc_bit2pix = NULL,
+	.tsc_cls = &tem_text_cls
+};
+tem_callbacks_t tem_pix_callbacks = {
+	.tsc_display = &tem_pix_display,
+	.tsc_copy = &tem_pix_copy,
+	.tsc_cursor = &tem_pix_cursor,
+	.tsc_bit2pix = &tem_pix_bit2pix,
+	.tsc_cls = &tem_pix_cls
+};
+
+#define	tem_callback_display	(*tems.ts_callbacks->tsc_display)
+#define	tem_callback_copy	(*tems.ts_callbacks->tsc_copy)
+#define	tem_callback_cursor	(*tems.ts_callbacks->tsc_cursor)
+#define	tem_callback_cls	(*tems.ts_callbacks->tsc_cls)
+#define	tem_callback_bit2pix	(*tems.ts_callbacks->tsc_bit2pix)
+
+static void
+tem_add(struct tem_vt_state *tem)
+{
+	list_insert_head(&tems.ts_list, tem);
+}
+
+/*
+ * This is the main entry point to the module.  It handles output requests
+ * during normal system operation, when (e.g.) mutexes are available.
+ */
+void
+tem_write(tem_vt_state_t tem_arg, uint8_t *buf, ssize_t len)
+{
+	struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg;
+
+	if (!tem->tvs_initialized) {
+		return;
+	}
+
+	tem_check_first_time(tem);
+	tem_terminal_emulate(tem, buf, len);
+}
+
+static void
+tem_internal_init(struct tem_vt_state *ptem,
+    boolean_t init_color, boolean_t clear_screen)
+{
+	size_t size, width, height;
+
+	if (tems.ts_display_mode == VIS_PIXEL) {
+		ptem->tvs_pix_data_size = tems.ts_pix_data_size;
+		ptem->tvs_pix_data = malloc(ptem->tvs_pix_data_size);
+	}
+
+	width = tems.ts_c_dimension.width;
+	height = tems.ts_c_dimension.height;
+
+	size = width * sizeof (tem_char_t);
+	ptem->tvs_outbuf = malloc(size);
+	if (ptem->tvs_outbuf == NULL)
+		panic("out of memory in tem_internal_init()\n");
+
+	tem_reset_display(ptem, clear_screen, init_color);
+
+	ptem->tvs_utf8_left = 0;
+	ptem->tvs_utf8_partial = 0;
+
+	ptem->tvs_initialized  = true;
+
+	/*
+	 * Out of memory is not fatal there, without the screen history,
+	 * we can not optimize the screen copy.
+	 */
+	size = width * height * sizeof (term_char_t);
+	ptem->tvs_screen_buf = malloc(size);
+	tem_virtual_cls(ptem, width * height, 0, 0);
+}
+
+int
+tem_initialized(tem_vt_state_t tem_arg)
+{
+	struct tem_vt_state *ptem = (struct tem_vt_state *)tem_arg;
+
+	return (ptem->tvs_initialized);
+}
+
+tem_vt_state_t
+tem_init(void)
+{
+	struct tem_vt_state *ptem;
+
+	ptem = malloc(sizeof (struct tem_vt_state));
+	if (ptem == NULL)
+		return ((tem_vt_state_t)ptem);
+	bzero(ptem, sizeof (*ptem));
+
+	ptem->tvs_isactive = false;
+	ptem->tvs_fbmode = KD_TEXT;
+
+	/*
+	 * A tem is regarded as initialized only after tem_internal_init(),
+	 * will be set at the end of tem_internal_init().
+	 */
+	ptem->tvs_initialized = 0;
+
+	if (!tems.ts_initialized) {
+		/*
+		 * Only happens during early console configuration.
+		 */
+		tem_add(ptem);
+		return ((tem_vt_state_t)ptem);
+	}
+
+	tem_internal_init(ptem, B_TRUE, B_FALSE);
+	tem_add(ptem);
+
+	return ((tem_vt_state_t)ptem);
+}
+
+/*
+ * re-init the tem after video mode has changed and tems_info has
+ * been re-inited.
+ */
+static void
+tem_reinit(struct tem_vt_state *tem, boolean_t reset_display)
+{
+	tem_free_buf(tem); /* only free virtual buffers */
+
+	/* reserve color */
+	tem_internal_init(tem, B_FALSE, reset_display);
+}
+
+static void
+tem_free_buf(struct tem_vt_state *tem)
+{
+	free(tem->tvs_outbuf);
+	tem->tvs_outbuf = NULL;
+
+	free(tem->tvs_pix_data);
+	tem->tvs_pix_data = NULL;
+
+	free(tem->tvs_screen_buf);
+	tem->tvs_screen_buf = NULL;
+}
+
+static int
+tems_failed(boolean_t finish_ioctl)
+{
+	if (finish_ioctl && tems.ts_hdl != NULL)
+		(void) tems.ts_hdl->c_ioctl(tems.ts_hdl, VIS_DEVFINI, NULL);
+
+	tems.ts_hdl = NULL;
+	return (ENXIO);
+}
+
+/*
+ * Only called once during boot
+ */
+int
+tem_info_init(struct console *cp)
+{
+	int			ret;
+	struct vis_devinit	temargs;
+	size_t height = 0;
+	size_t width = 0;
+	struct tem_vt_state *p;
+
+	if (tems.ts_initialized) {
+		return (0);
+	}
+
+	list_create(&tems.ts_list, sizeof (struct tem_vt_state),
+	    __offsetof(struct tem_vt_state, tvs_list_node));
+	tems.ts_active = NULL;
+
+	tems.ts_hdl = cp;
+	bzero(&temargs, sizeof (temargs));
+	temargs.modechg_cb  = (vis_modechg_cb_t)tems_modechange_callback;
+	temargs.modechg_arg = NULL;
+
+	/*
+	 * Initialize the console and get the device parameters
+	 */
+	if (cp->c_ioctl(cp, VIS_DEVINIT, &temargs) != 0) {
+		printf("terminal emulator: Compatible fb not found\n");
+		ret = tems_failed(B_FALSE);
+		return (ret);
+	}
+
+	/* Make sure the fb driver and terminal emulator versions match */
+	if (temargs.version != VIS_CONS_REV) {
+		printf(
+		    "terminal emulator: VIS_CONS_REV %d (see sys/visual_io.h) "
+		    "of console fb driver not supported\n", temargs.version);
+		ret = tems_failed(B_TRUE);
+		return (ret);
+	}
+
+	/* other sanity checks */
+	if (!((temargs.depth == 4) || (temargs.depth == 8) ||
+	    (temargs.depth == 15) || (temargs.depth == 16) ||
+	    (temargs.depth == 24) || (temargs.depth == 32))) {
+		printf("terminal emulator: unsupported depth\n");
+		ret = tems_failed(B_TRUE);
+		return (ret);
+	}
+
+	if ((temargs.mode != VIS_TEXT) && (temargs.mode != VIS_PIXEL)) {
+		printf("terminal emulator: unsupported mode\n");
+		ret = tems_failed(B_TRUE);
+		return (ret);
+	}
+
+	plat_tem_get_prom_size(&height, &width);
+
+	/*
+	 * Initialize the common terminal emulator info
+	 */
+	tems_setup_terminal(&temargs, height, width);
+
+	tems_reset_colormap();
+	tems_get_initial_color(&tems.ts_init_color);
+
+	tems.ts_initialized = 1; /* initialization flag */
+
+	for (p = list_head(&tems.ts_list); p != NULL;
+	    p = list_next(&tems.ts_list, p)) {
+		tem_internal_init(p, B_TRUE, B_FALSE);
+		if (temargs.mode == VIS_PIXEL)
+			tem_pix_align(p);
+	}
+
+	return (0);
+}
+
+#define	TEMS_DEPTH_DIFF		0x01
+#define	TEMS_DIMENSION_DIFF	0x02
+
+static uint8_t
+tems_check_videomode(struct vis_devinit *tp)
+{
+	uint8_t result = 0;
+
+	if (tems.ts_pdepth != tp->depth)
+		result |= TEMS_DEPTH_DIFF;
+
+	if (tp->mode == VIS_TEXT) {
+		if (tems.ts_c_dimension.width != tp->width ||
+		    tems.ts_c_dimension.height != tp->height)
+			result |= TEMS_DIMENSION_DIFF;
+	} else {
+		if (tems.ts_p_dimension.width != tp->width ||
+		    tems.ts_p_dimension.height != tp->height)
+			result |= TEMS_DIMENSION_DIFF;
+	}
+	if (tems.update_font == true)
+		result |= TEMS_DIMENSION_DIFF;
+
+	return (result);
+}
+
+static int
+env_screen_nounset(struct env_var *ev __unused)
+{
+	if (tems.ts_p_dimension.width == 0 &&
+	    tems.ts_p_dimension.height == 0)
+		return (0);
+	return(EPERM);
+}
+
+static void
+tems_setup_terminal(struct vis_devinit *tp, size_t height, size_t width)
+{
+	bitmap_data_t *font_data;
+	int i;
+	char env[8];
+
+	tems.ts_pdepth = tp->depth;
+	tems.ts_linebytes = tp->linebytes;
+	tems.ts_display_mode = tp->mode;
+	tems.ts_color_map = tp->color_map;
+
+	switch (tp->mode) {
+	case VIS_TEXT:
+		tems.ts_p_dimension.width = 0;
+		tems.ts_p_dimension.height = 0;
+		tems.ts_c_dimension.width = tp->width;
+		tems.ts_c_dimension.height = tp->height;
+		tems.ts_callbacks = &tem_text_callbacks;
+
+		snprintf(env, sizeof (env), "%d", tems.ts_c_dimension.height);
+		env_setenv("screen-#rows", EV_VOLATILE | EV_NOHOOK, env,
+		    env_noset, env_nounset);
+		snprintf(env, sizeof (env), "%d", tems.ts_c_dimension.width);
+		env_setenv("screen-#cols", EV_VOLATILE | EV_NOHOOK, env,
+		    env_noset, env_nounset);
+
+		/* ensure the following are not set for text mode */
+		unsetenv("screen-height");
+		unsetenv("screen-width");
+		break;
+
+	case VIS_PIXEL:
+		/*
+		 * First check to see if the user has specified a screen size.
+		 * If so, use those values.  Else use 34x80 as the default.
+		 */
+		if (width == 0) {
+			width = TEM_DEFAULT_COLS;
+			height = TEM_DEFAULT_ROWS;
+		}
+		tems.ts_c_dimension.height = (screen_size_t)height;
+		tems.ts_c_dimension.width = (screen_size_t)width;
+
+		tems.ts_p_dimension.height = tp->height;
+		tems.ts_p_dimension.width = tp->width;
+
+		tems.ts_callbacks = &tem_pix_callbacks;
+
+		/*
+		 * set_font() will select a appropriate sized font for
+		 * the number of rows and columns selected.  If we don't
+		 * have a font that will fit, then it will use the
+		 * default builtin font and adjust the rows and columns
+		 * to fit on the screen.
+		 */
+		font_data = set_font(&tems.ts_c_dimension.height,
+		    &tems.ts_c_dimension.width,
+		    tems.ts_p_dimension.height,
+		    tems.ts_p_dimension.width);
+
+		/*
+		 * The built in font is compressed, to use it, we
+		 * uncompress it into the allocated buffer.
+		 * To use loaded font, we assign the loaded buffer.
+		 * In case of next load, the previously loaded data
+		 * is freed by the process of loading the new font.
+		 */
+		tems.update_font = false;
+
+		if (tems.ts_font.vf_bytes == NULL) {
+			for (i = 0; i < VFNT_MAPS; i++) {
+				tems.ts_font.vf_map[i] =
+				    font_data->font->vf_map[i];
+			}
+
+			if (font_data->compressed_size != 0) {
+				/*
+				 * We only expect this allocation to
+				 * happen at startup, and therefore not to fail.
+				 */
+				tems.ts_font.vf_bytes =
+				    malloc(font_data->uncompressed_size);
+				if (tems.ts_font.vf_bytes == NULL)
+					panic("out of memory\n");
+				(void)lz4_decompress(font_data->compressed_data,
+				    tems.ts_font.vf_bytes,
+				    font_data->compressed_size,
+				    font_data->uncompressed_size, 0);
+			} else {
+				tems.ts_font.vf_bytes =
+				    font_data->font->vf_bytes;
+			}
+			tems.ts_font.vf_width = font_data->font->vf_width;
+			tems.ts_font.vf_height = font_data->font->vf_height;
+			for (i = 0; i < VFNT_MAPS; i++) {
+				tems.ts_font.vf_map_count[i] =
+				    font_data->font->vf_map_count[i];
+			}
+		}
+
+		snprintf(env, sizeof (env), "%d", tems.ts_c_dimension.height);
+		env_setenv("screen-#rows", EV_VOLATILE | EV_NOHOOK, env,
+		    env_noset, env_nounset);
+		snprintf(env, sizeof (env), "%d", tems.ts_c_dimension.width);
+		env_setenv("screen-#cols", EV_VOLATILE | EV_NOHOOK, env,
+		    env_noset, env_nounset);
+
+		snprintf(env, sizeof (env), "%d", tems.ts_p_dimension.height);
+		env_setenv("screen-height", EV_VOLATILE | EV_NOHOOK, env,
+		    env_noset, env_screen_nounset);
+		snprintf(env, sizeof (env), "%d", tems.ts_p_dimension.width);
+		env_setenv("screen-width", EV_VOLATILE | EV_NOHOOK, env,
+		    env_noset, env_screen_nounset);
+
+		snprintf(env, sizeof (env), "%dx%d", tems.ts_font.vf_width,
+		    tems.ts_font.vf_height);
+		env_setenv("screen-font", EV_VOLATILE | EV_NOHOOK, env, NULL,
+		    NULL);
+
+		tems.ts_p_offset.y = (tems.ts_p_dimension.height -
+		    (tems.ts_c_dimension.height * tems.ts_font.vf_height)) / 2;
+		tems.ts_p_offset.x = (tems.ts_p_dimension.width -
+		    (tems.ts_c_dimension.width * tems.ts_font.vf_width)) / 2;
+
+		tems.ts_pix_data_size =
+		    tems.ts_font.vf_width * tems.ts_font.vf_height;
+
+		tems.ts_pix_data_size *= 4;
+
+		tems.ts_pdepth = tp->depth;
+
+		break;
+	}
+}
+
+/*
+ * This is a callback function that we register with the frame
+ * buffer driver layered underneath.  It gets invoked from
+ * the underlying frame buffer driver to reconfigure the terminal
+ * emulator to a new screen size and depth in conjunction with
+ * framebuffer videomode changes.
+ * Here we keep the foreground/background color and attributes,
+ * which may be different with the initial settings, so that
+ * the color won't change while the framebuffer videomode changes.
+ * And we also reset the kernel terminal emulator and clear the
+ * whole screen.
+ */
+/* ARGSUSED */
+void
+tems_modechange_callback(struct vis_modechg_arg *arg __unused,
+    struct vis_devinit *devinit)
+{
+	uint8_t diff;
+	struct tem_vt_state *p;
+	tem_modechg_cb_t cb;
+	tem_modechg_cb_arg_t cb_arg;
+	size_t height = 0;
+	size_t width = 0;
+
+	diff = tems_check_videomode(devinit);
+	if (diff == 0) {
+		/*
+		 * This is color related change, reset color and redraw the
+		 * screen. Only need to reinit the active tem.
+		 */
+		struct tem_vt_state *active = tems.ts_active;
+		tems_get_initial_color(&tems.ts_init_color);
+		active->tvs_fg_color = tems.ts_init_color.fg_color;
+		active->tvs_bg_color = tems.ts_init_color.bg_color;
+		active->tvs_flags = tems.ts_init_color.a_flags;
+		tem_reinit(active, B_TRUE);
+		return;
+	}
+
+	diff = diff & TEMS_DIMENSION_DIFF;
+
+	if (diff == 0) {
+		/*
+		 * Only need to reinit the active tem.
+		 */
+		struct tem_vt_state *active = tems.ts_active;
+		tems.ts_pdepth = devinit->depth;
+		/* color depth did change, reset colors */
+		tems_reset_colormap();
+		tems_get_initial_color(&tems.ts_init_color);
+		tem_reinit(active, B_TRUE);
+
+		return;
+	}
+
+	plat_tem_get_prom_size(&height, &width);
+
+	tems_setup_terminal(devinit, height, width);
+
+	tems_reset_colormap();
+	tems_get_initial_color(&tems.ts_init_color);
+
+	for (p = list_head(&tems.ts_list); p != NULL;
+	    p = list_next(&tems.ts_list, p)) {
+		tem_reinit(p, p->tvs_isactive);
+	}
+
+
+	if (tems.ts_modechg_cb == NULL) {
+		return;
+	}
+
+	cb = tems.ts_modechg_cb;
+	cb_arg = tems.ts_modechg_arg;
+
+	cb(cb_arg);
+}
+
+/*
+ * This function is used to clear entire screen via the underlying framebuffer
+ * driver.
+ */
+int
+tems_cls(struct vis_consclear *pda)
+{
+	if (tems.ts_hdl == NULL)
+		return (1);
+	return (tems.ts_hdl->c_ioctl(tems.ts_hdl, VIS_CONSCLEAR, pda));
+}
+
+/*
+ * This function is used to display a rectangular blit of data
+ * of a given size and location via the underlying framebuffer driver.
+ * The blit can be as small as a pixel or as large as the screen.
+ */
+void
+tems_display(struct vis_consdisplay *pda)
+{
+	if (tems.ts_hdl != NULL)
+		(void) tems.ts_hdl->c_ioctl(tems.ts_hdl, VIS_CONSDISPLAY, pda);
+}
+
+/*
+ * This function is used to invoke a block copy operation in the
+ * underlying framebuffer driver.  Rectangle copies are how scrolling
+ * is implemented, as well as horizontal text shifting escape seqs.
+ * such as from vi when deleting characters and words.
+ */
+void
+tems_copy(struct vis_conscopy *pma)
+{
+	if (tems.ts_hdl != NULL)
+		(void) tems.ts_hdl->c_ioctl(tems.ts_hdl, VIS_CONSCOPY, pma);
+}
+
+/*
+ * This function is used to show or hide a rectangluar monochrom
+ * pixel inverting, text block cursor via the underlying framebuffer.
+ */
+void
+tems_cursor(struct vis_conscursor *pca)
+{
+	if (tems.ts_hdl != NULL)
+		(void) tems.ts_hdl->c_ioctl(tems.ts_hdl, VIS_CONSCURSOR, pca);
+}
+
+static void
+tem_kdsetmode(int mode)
+{
+	if (tems.ts_hdl != NULL)
+		(void) tems.ts_hdl->c_ioctl(tems.ts_hdl, KDSETMODE,
+	     (void *)(intptr_t)mode);
+}
+
+static void
+tems_reset_colormap(void)
+{
+	struct vis_cmap cm;
+
+	switch (tems.ts_pdepth) {
+	case 8:
+		cm.index = 0;
+		cm.count = 16;
+		/* 8-bits (1/3 of TrueColor 24) */
+		cm.red   = (uint8_t *)cmap4_to_24.red;
+		/* 8-bits (1/3 of TrueColor 24) */
+		cm.blue  = (uint8_t *)cmap4_to_24.blue;
+		/* 8-bits (1/3 of TrueColor 24) */
+		cm.green = (uint8_t *)cmap4_to_24.green;
+		if (tems.ts_hdl != NULL)
+			(void) tems.ts_hdl->c_ioctl(tems.ts_hdl,
+			    VIS_PUTCMAP, &cm);
+		break;
+	}
+}
+
+void
+tem_get_size(uint16_t *r, uint16_t *c, uint16_t *x, uint16_t *y)
+{
+	*r = (uint16_t)tems.ts_c_dimension.height;
+	*c = (uint16_t)tems.ts_c_dimension.width;
+	*x = (uint16_t)tems.ts_p_dimension.width;
+	*y = (uint16_t)tems.ts_p_dimension.height;
+}
+
+/*
+ * Loader extension. Store important data in environment. Intended to be used
+ * just before booting the OS to make the data available in kernel
+ * environment module.
+ */
+void
+tem_save_state(void)
+{
+	struct tem_vt_state *active = tems.ts_active;
+	char buf[80];
+
+	/*
+	 * We already have in environment:
+	 * tem.inverse, tem.inverse_screen
+	 * tem.fg_color, tem.bg_color.
+	 * So we only need to add the position of the cursor.
+	 */
+
+	if (active != NULL) {
+		snprintf(buf, sizeof (buf), "%d", active->tvs_c_cursor.col);
+		setenv("tem.cursor.col", buf, 1);
+		snprintf(buf, sizeof (buf), "%d", active->tvs_c_cursor.row);
+		setenv("tem.cursor.row", buf, 1);
+	}
+}
+
+void
+tem_register_modechg_cb(tem_modechg_cb_t func, tem_modechg_cb_arg_t arg)
+{
+	tems.ts_modechg_cb = func;
+	tems.ts_modechg_arg = arg;
+}
+
+/*
+ * This function is to scroll up the OBP output, which has
+ * different screen height and width with our kernel console.
+ */
+static void
+tem_prom_scroll_up(struct tem_vt_state *tem, int nrows)
+{
+	struct vis_conscopy	ma;
+	int	ncols, width;
+
+	/* copy */
+	ma.s_row = nrows * tems.ts_font.vf_height;
+	ma.e_row = tems.ts_p_dimension.height - 1;
+	ma.t_row = 0;
+
+	ma.s_col = 0;
+	ma.e_col = tems.ts_p_dimension.width - 1;
+	ma.t_col = 0;
+
+	tems_copy(&ma);
+
+	/* clear */
+	width = tems.ts_font.vf_width;
+	ncols = (tems.ts_p_dimension.width + (width - 1))/ width;
+
+	tem_pix_cls_range(tem, 0, nrows, tems.ts_p_offset.y,
+	    0, ncols, 0, B_TRUE);
+}
+
+/*
+ * This function is to compute the starting row of the console, according to
+ * PROM cursor's position. Here we have to take different fonts into account.
+ */
+static int
+tem_adjust_row(struct tem_vt_state *tem, int prom_row)
+{
+	int	tem_row;
+	int	tem_y;
+	int	prom_charheight = 0;
+	int	prom_window_top = 0;
+	int	scroll_up_lines;
+
+	plat_tem_get_prom_font_size(&prom_charheight, &prom_window_top);
+	if (prom_charheight == 0)
+		prom_charheight = tems.ts_font.vf_height;
+
+	tem_y = (prom_row + 1) * prom_charheight + prom_window_top -
+	    tems.ts_p_offset.y;
+	tem_row = (tem_y + tems.ts_font.vf_height - 1) /
+	    tems.ts_font.vf_height - 1;
+
+	if (tem_row < 0) {
+		tem_row = 0;
+	} else if (tem_row >= (tems.ts_c_dimension.height - 1)) {
+		/*
+		 * Scroll up the prom outputs if the PROM cursor's position is
+		 * below our tem's lower boundary.
+		 */
+		scroll_up_lines = tem_row -
+		    (tems.ts_c_dimension.height - 1);
+		tem_prom_scroll_up(tem, scroll_up_lines);
+		tem_row = tems.ts_c_dimension.height - 1;
+	}
+
+	return (tem_row);
+}
+
+static void
+tem_pix_align(struct tem_vt_state *tem)
+{
+	uint32_t row = 0;
+	uint32_t col = 0;
+
+	if (plat_stdout_is_framebuffer()) {
+		plat_tem_hide_prom_cursor();
+
+		/*
+		 * We are getting the current cursor position in pixel
+		 * mode so that we don't over-write the console output
+		 * during boot.
+		 */
+		plat_tem_get_prom_pos(&row, &col);
+
+		/*
+		 * Adjust the row if necessary when the font of our
+		 * kernel console tem is different with that of prom
+		 * tem.
+		 */
+		row = tem_adjust_row(tem, row);
+
+		/* first line of our kernel console output */
+		tem->tvs_first_line = row + 1;
+
+		/* re-set and align cursor position */
+		tem->tvs_s_cursor.row = tem->tvs_c_cursor.row =
+		    (screen_pos_t)row;
+		tem->tvs_s_cursor.col = tem->tvs_c_cursor.col = 0;
+	} else {
+		tem_reset_display(tem, B_TRUE, B_TRUE);
+	}
+}
+
+static void
+tems_get_inverses(boolean_t *p_inverse, boolean_t *p_inverse_screen)
+{
+	int i_inverse = 0;
+	int i_inverse_screen = 0;
+
+	plat_tem_get_inverses(&i_inverse, &i_inverse_screen);
+
+	*p_inverse = (i_inverse == 0) ? B_FALSE : B_TRUE;
+	*p_inverse_screen = (i_inverse_screen == 0) ? B_FALSE : B_TRUE;
+}
+
+/*
+ * Get the foreground/background color and attributes from environment.
+ */
+static void
+tems_get_initial_color(tem_color_t *pcolor)
+{
+	boolean_t inverse, inverse_screen;
+	unsigned short  flags = 0;
+
+	pcolor->fg_color = DEFAULT_ANSI_FOREGROUND;
+	pcolor->bg_color = DEFAULT_ANSI_BACKGROUND;
+	plat_tem_get_colors(&pcolor->fg_color, &pcolor->bg_color);
+
+	tems_get_inverses(&inverse, &inverse_screen);
+	if (inverse)
+		flags |= TEM_ATTR_REVERSE;
+	if (inverse_screen)
+		flags |= TEM_ATTR_SCREEN_REVERSE;
+
+	/*
+	 * In case of black on white we want bright white for BG.
+	 * In case if white on black, to improve readability,
+	 * we want bold white.
+	 */
+	if (flags != 0) {
+		/*
+		 * If either reverse flag is set, the screen is in
+		 * white-on-black mode.  We set the bold flag to
+		 * improve readability.
+		 */
+		flags |= TEM_ATTR_BOLD;
+	} else {
+		/*
+		 * Otherwise, the screen is in black-on-white mode.
+		 * The SPARC PROM console, which starts in this mode,
+		 * uses the bright white background colour so we
+		 * match it here.
+		 */
+		if (pcolor->bg_color == ANSI_COLOR_WHITE)
+			flags |= TEM_ATTR_BRIGHT_BG;
+	}
+
+	pcolor->a_flags = flags;
+}
+
+void
+tem_activate(tem_vt_state_t tem_arg, boolean_t unblank)
+{
+	struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg;
+
+	tems.ts_active = tem;
+	tem->tvs_isactive = true;
+
+	tem_kdsetmode(tem->tvs_fbmode);
+
+	if (unblank)
+		tem_cls(tem);
+}
+
+static void
+tem_check_first_time(struct tem_vt_state *tem)
+{
+	static int first_time = 1;
+
+	/*
+	 * Realign the console cursor. We did this in tem_init().
+	 * However, drivers in the console stream may emit additional
+	 * messages before we are ready. This causes text overwrite
+	 * on the screen. This is a workaround.
+	 */
+	if (!first_time)
+		return;
+
+	first_time = 0;
+	if (tems.ts_display_mode == VIS_TEXT)
+		tem_text_cursor(tem, VIS_GET_CURSOR);
+	else
+		tem_pix_cursor(tem, VIS_GET_CURSOR);
+	tem_align_cursor(tem);
+}
+
+/* Process partial UTF-8 sequence. */
+static void
+tem_input_partial(struct tem_vt_state *tem)
+{
+	unsigned i;
+	tem_char_t c;
+
+	if (tem->tvs_utf8_left == 0)
+		return;
+
+	for (i = 0; i < sizeof (tem->tvs_utf8_partial); i++) {
+		c = (tem->tvs_utf8_partial >> (24 - (i << 3))) & 0xff;
+		if (c != 0) {
+			tem_parse(tem, c);
+		}
+	}
+	tem->tvs_utf8_left = 0;
+	tem->tvs_utf8_partial = 0;
+}
+
+/*
+ * Handle UTF-8 sequences.
+ */
+static void
+tem_input_byte(struct tem_vt_state *tem, uint8_t c)
+{
+	/*
+	 * Check for UTF-8 code points. In case of error fall back to
+	 * 8-bit code. As we only have 8859-1 fonts for console, this will set
+	 * the limits on what chars we actually can display, therefore we
+	 * have to return to this code once we have solved the font issue.
+	 */
+	if ((c & 0x80) == 0x00) {
+		/* One-byte sequence. */
+		tem_input_partial(tem);
+		tem_parse(tem, c);
+		return;
+	}
+	if ((c & 0xe0) == 0xc0) {
+		/* Two-byte sequence. */
+		tem_input_partial(tem);
+		tem->tvs_utf8_left = 1;
+		tem->tvs_utf8_partial = c;
+		return;
+	}
+	if ((c & 0xf0) == 0xe0) {
+		/* Three-byte sequence. */
+		tem_input_partial(tem);
+		tem->tvs_utf8_left = 2;
+		tem->tvs_utf8_partial = c;
+		return;
+	}
+	if ((c & 0xf8) == 0xf0) {
+		/* Four-byte sequence. */
+		tem_input_partial(tem);
+		tem->tvs_utf8_left = 3;
+		tem->tvs_utf8_partial = c;
+		return;
+	}
+	if ((c & 0xc0) == 0x80) {
+		/* Invalid state? */
+		if (tem->tvs_utf8_left == 0) {
+			tem_parse(tem, c);
+			return;
+		}
+		tem->tvs_utf8_left--;
+		tem->tvs_utf8_partial = (tem->tvs_utf8_partial << 8) | c;
+		if (tem->tvs_utf8_left == 0) {
+			tem_char_t v, u;
+			uint8_t b;
+
+			/*
+			 * Transform the sequence of 2 to 4 bytes to
+			 * unicode number.
+			 */
+			v = 0;
+			u = tem->tvs_utf8_partial;
+			b = (u >> 24) & 0xff;
+			if (b != 0) {		/* Four-byte sequence */
+				v = b & 0x07;
+				b = (u >> 16) & 0xff;
+				v = (v << 6) | (b & 0x3f);
+				b = (u >> 8) & 0xff;
+				v = (v << 6) | (b & 0x3f);
+				b = u & 0xff;
+				v = (v << 6) | (b & 0x3f);
+			} else if ((b = (u >> 16) & 0xff) != 0) {
+				v = b & 0x0f;	/* Three-byte sequence */
+				b = (u >> 8) & 0xff;
+				v = (v << 6) | (b & 0x3f);
+				b = u & 0xff;
+				v = (v << 6) | (b & 0x3f);
+			} else if ((b = (u >> 8) & 0xff) != 0) {
+				v = b & 0x1f;	/* Two-byte sequence */
+				b = u & 0xff;
+				v = (v << 6) | (b & 0x3f);
+			}
+
+			tem_parse(tem, v);
+			tem->tvs_utf8_partial = 0;
+		}
+		return;
+	}
+	/* Anything left is illegal in UTF-8 sequence. */
+	tem_input_partial(tem);
+	tem_parse(tem, c);
+}
+
+/*
+ * This is the main entry point into the terminal emulator.
+ *
+ * For each data message coming downstream, ANSI assumes that it is composed
+ * of ASCII characters, which are treated as a byte-stream input to the
+ * parsing state machine. All data is parsed immediately -- there is
+ * no enqueing.
+ */
+static void
+tem_terminal_emulate(struct tem_vt_state *tem, uint8_t *buf, int len)
+{
+	if (tem->tvs_isactive)
+		tem_callback_cursor(tem, VIS_HIDE_CURSOR);
+
+	for (; len > 0; len--, buf++)
+		tem_input_byte(tem, *buf);
+
+	/*
+	 * Send the data we just got to the framebuffer.
+	 */
+	tem_send_data(tem);
+
+	if (tem->tvs_isactive)
+		tem_callback_cursor(tem, VIS_DISPLAY_CURSOR);
+}
+
+/*
+ * send the appropriate control message or set state based on the
+ * value of the control character ch
+ */
+
+static void
+tem_control(struct tem_vt_state *tem, uint8_t ch)
+{
+	tem->tvs_state = A_STATE_START;
+	switch (ch) {
+	case A_BEL:
+		tem_bell(tem);
+		break;
+
+	case A_BS:
+		tem_mv_cursor(tem,
+		    tem->tvs_c_cursor.row,
+		    tem->tvs_c_cursor.col - 1);
+		break;
+
+	case A_HT:
+		tem_tab(tem);
+		break;
+
+	case A_NL:
+		/*
+		 * tem_send_data(tem, credp, called_from);
+		 * tem_new_line(tem, credp, called_from);
+		 * break;
+		 */
+
+	case A_VT:
+		tem_send_data(tem);
+		tem_lf(tem);
+		break;
+
+	case A_FF:
+		tem_send_data(tem);
+		tem_cls(tem);
+		break;
+
+	case A_CR:
+		tem_send_data(tem);
+		tem_cr(tem);
+		break;
+
+	case A_ESC:
+		tem->tvs_state = A_STATE_ESC;
+		break;
+
+	case A_CSI:
+		{
+			int i;
+			tem->tvs_curparam = 0;
+			tem->tvs_paramval = 0;
+			tem->tvs_gotparam = B_FALSE;
+			/* clear the parameters */
+			for (i = 0; i < TEM_MAXPARAMS; i++)
+				tem->tvs_params[i] = -1;
+			tem->tvs_state = A_STATE_CSI;
+		}
+		break;
+
+	case A_GS:
+		tem_back_tab(tem);
+		break;
+
+	default:
+		break;
+	}
+}
+
+
+/*
+ * if parameters [0..count - 1] are not set, set them to the value
+ * of newparam.
+ */
+
+static void
+tem_setparam(struct tem_vt_state *tem, int count, int newparam)
+{
+	int i;
+
+	for (i = 0; i < count; i++) {
+		if (tem->tvs_params[i] == -1)
+			tem->tvs_params[i] = newparam;
+	}
+}
+
+
+/*
+ * select graphics mode based on the param vals stored in a_params
+ */
+static void
+tem_selgraph(struct tem_vt_state *tem)
+{
+	int curparam;
+	int count = 0;
+	int param;
+
+	tem->tvs_state = A_STATE_START;
+
+	curparam = tem->tvs_curparam;
+	do {
+		param = tem->tvs_params[count];
+
+		switch (param) {
+		case -1:
+		case 0:
+			/* reset to initial normal settings */
+			tem->tvs_fg_color = tems.ts_init_color.fg_color;
+			tem->tvs_bg_color = tems.ts_init_color.bg_color;
+			tem->tvs_flags = tems.ts_init_color.a_flags;
+			break;
+
+		case 1: /* Bold Intense */
+			tem->tvs_flags |= TEM_ATTR_BOLD;
+			break;
+
+		case 2: /* Faint Intense */
+			tem->tvs_flags &= ~TEM_ATTR_BOLD;
+			break;
+
+		case 4: /* Underline */
+			tem->tvs_flags |= TEM_ATTR_UNDERLINE;
+			break;
+
+		case 5: /* Blink */
+			tem->tvs_flags |= TEM_ATTR_BLINK;
+			break;
+
+		case 7: /* Reverse video */
+			if (tem->tvs_flags & TEM_ATTR_SCREEN_REVERSE) {
+				tem->tvs_flags &= ~TEM_ATTR_REVERSE;
+			} else {
+				tem->tvs_flags |= TEM_ATTR_REVERSE;
+			}
+			break;
+
+		case 22: /* Remove Bold */
+			tem->tvs_flags &= ~TEM_ATTR_BOLD;
+			break;
+
+		case 24: /* Remove Underline */
+			tem->tvs_flags &= ~TEM_ATTR_UNDERLINE;
+			break;
+
+		case 25: /* Remove Blink */
+			tem->tvs_flags &= ~TEM_ATTR_BLINK;
+			break;
+
+		case 27: /* Remove Reverse */
+			if (tem->tvs_flags & TEM_ATTR_SCREEN_REVERSE) {
+				tem->tvs_flags |= TEM_ATTR_REVERSE;
+			} else {
+				tem->tvs_flags &= ~TEM_ATTR_REVERSE;
+			}
+			break;
+
+		case 30: /* black	(grey)		foreground */
+		case 31: /* red		(light red)	foreground */
+		case 32: /* green	(light green)	foreground */
+		case 33: /* brown	(yellow)	foreground */
+		case 34: /* blue	(light blue)	foreground */
+		case 35: /* magenta	(light magenta)	foreground */
+		case 36: /* cyan	(light cyan)	foreground */
+		case 37: /* white	(bright white)	foreground */
+			tem->tvs_fg_color = param - 30;
+			tem->tvs_flags &= ~TEM_ATTR_BRIGHT_FG;
+			break;
+
+		case 39:
+			/*
+			 * Reset the foreground colour and brightness.
+			 */
+			tem->tvs_fg_color = tems.ts_init_color.fg_color;
+			if (tems.ts_init_color.a_flags & TEM_ATTR_BRIGHT_FG)
+				tem->tvs_flags |= TEM_ATTR_BRIGHT_FG;
+			else
+				tem->tvs_flags &= ~TEM_ATTR_BRIGHT_FG;
+			break;
+
+		case 40: /* black	(grey)		background */
+		case 41: /* red		(light red)	background */
+		case 42: /* green	(light green)	background */
+		case 43: /* brown	(yellow)	background */
+		case 44: /* blue	(light blue)	background */
+		case 45: /* magenta	(light magenta)	background */
+		case 46: /* cyan	(light cyan)	background */
+		case 47: /* white	(bright white)	background */
+			tem->tvs_bg_color = param - 40;
+			tem->tvs_flags &= ~TEM_ATTR_BRIGHT_BG;
+			break;
+
+		case 49:
+			/*
+			 * Reset the background colour and brightness.
+			 */
+			tem->tvs_bg_color = tems.ts_init_color.bg_color;
+			if (tems.ts_init_color.a_flags & TEM_ATTR_BRIGHT_BG)
+				tem->tvs_flags |= TEM_ATTR_BRIGHT_BG;
+			else
+				tem->tvs_flags &= ~TEM_ATTR_BRIGHT_BG;
+			break;
+
+		case 90: /* black	(grey)		foreground */
+		case 91: /* red		(light red)	foreground */
+		case 92: /* green	(light green)	foreground */
+		case 93: /* brown	(yellow)	foreground */
+		case 94: /* blue	(light blue)	foreground */
+		case 95: /* magenta	(light magenta)	foreground */
+		case 96: /* cyan	(light cyan)	foreground */
+		case 97: /* white	(bright white)	foreground */
+			tem->tvs_fg_color = param - 90;
+			tem->tvs_flags |= TEM_ATTR_BRIGHT_FG;
+			break;
+
+		case 100: /* black	(grey)		background */
+		case 101: /* red	(light red)	background */
+		case 102: /* green	(light green)	background */
+		case 103: /* brown	(yellow)	background */
+		case 104: /* blue	(light blue)	background */
+		case 105: /* magenta	(light magenta)	background */
+		case 106: /* cyan	(light cyan)	background */
+		case 107: /* white	(bright white)	background */
+			tem->tvs_bg_color = param - 100;
+			tem->tvs_flags |= TEM_ATTR_BRIGHT_BG;
+			break;
+
+		default:
+			break;
+		}
+		count++;
+		curparam--;
+
+	} while (curparam > 0);
+}
+
+/*
+ * perform the appropriate action for the escape sequence
+ *
+ * General rule:  This code does not validate the arguments passed.
+ *                It assumes that the next lower level will do so.
+ */
+static void
+tem_chkparam(struct tem_vt_state *tem, uint8_t ch)
+{
+	int	i;
+	int	row;
+	int	col;
+
+	row = tem->tvs_c_cursor.row;
+	col = tem->tvs_c_cursor.col;
+
+	switch (ch) {
+
+	case 'm': /* select terminal graphics mode */
+		tem_send_data(tem);
+		tem_selgraph(tem);
+		break;
+
+	case '@':		/* insert char */
+		tem_setparam(tem, 1, 1);
+		tem_shift(tem, tem->tvs_params[0], TEM_SHIFT_RIGHT);
+		break;
+
+	case 'A':		/* cursor up */
+		tem_setparam(tem, 1, 1);
+		tem_mv_cursor(tem, row - tem->tvs_params[0], col);
+		break;
+
+	case 'd':		/* VPA - vertical position absolute */
+		tem_setparam(tem, 1, 1);
+		tem_mv_cursor(tem, tem->tvs_params[0] - 1, col);
+		break;
+
+	case 'e':		/* VPR - vertical position relative */
+	case 'B':		/* cursor down */
+		tem_setparam(tem, 1, 1);
+		tem_mv_cursor(tem, row + tem->tvs_params[0], col);
+		break;
+
+	case 'a':		/* HPR - horizontal position relative */
+	case 'C':		/* cursor right */
+		tem_setparam(tem, 1, 1);
+		tem_mv_cursor(tem, row, col + tem->tvs_params[0]);
+		break;
+
+	case '`':		/* HPA - horizontal position absolute */
+		tem_setparam(tem, 1, 1);
+		tem_mv_cursor(tem, row, tem->tvs_params[0] - 1);
+		break;
+
+	case 'D':		/* cursor left */
+		tem_setparam(tem, 1, 1);
+		tem_mv_cursor(tem, row, col - tem->tvs_params[0]);
+		break;
+
+	case 'E':		/* CNL cursor next line */
+		tem_setparam(tem, 1, 1);
+		tem_mv_cursor(tem, row + tem->tvs_params[0], 0);
+		break;
+
+	case 'F':		/* CPL cursor previous line */
+		tem_setparam(tem, 1, 1);
+		tem_mv_cursor(tem, row - tem->tvs_params[0], 0);
+		break;
+
+	case 'G':		/* cursor horizontal position */
+		tem_setparam(tem, 1, 1);
+		tem_mv_cursor(tem, row, tem->tvs_params[0] - 1);
+		break;
+
+	case 'g':		/* clear tabs */
+		tem_setparam(tem, 1, 0);
+		tem_clear_tabs(tem, tem->tvs_params[0]);
+		break;
+
+	case 'f':		/* HVP Horizontal and Vertical Position */
+	case 'H':		/* CUP position cursor */
+		tem_setparam(tem, 2, 1);
+		tem_mv_cursor(tem,
+		    tem->tvs_params[0] - 1, tem->tvs_params[1] - 1);
+		break;
+
+	case 'I':		/* CHT - Cursor Horizontal Tab */
+		/* Not implemented */
+		break;
+
+	case 'J':		/* ED - Erase in Display */
+		tem_send_data(tem);
+		tem_setparam(tem, 1, 0);
+		switch (tem->tvs_params[0]) {
+		case 0:
+			/* erase cursor to end of screen */
+			/* FIRST erase cursor to end of line */
+			tem_clear_chars(tem,
+			    tems.ts_c_dimension.width -
+			    tem->tvs_c_cursor.col,
+			    tem->tvs_c_cursor.row,
+			    tem->tvs_c_cursor.col);
+
+			/* THEN erase lines below the cursor */
+			for (row = tem->tvs_c_cursor.row + 1;
+			    row < tems.ts_c_dimension.height;
+			    row++) {
+				tem_clear_chars(tem,
+				    tems.ts_c_dimension.width, row, 0);
+			}
+			break;
+
+		case 1:
+			/* erase beginning of screen to cursor */
+			/* FIRST erase lines above the cursor */
+			for (row = 0;
+			    row < tem->tvs_c_cursor.row;
+			    row++) {
+				tem_clear_chars(tem,
+				    tems.ts_c_dimension.width, row, 0);
+			}
+			/* THEN erase beginning of line to cursor */
+			tem_clear_chars(tem,
+			    tem->tvs_c_cursor.col + 1,
+			    tem->tvs_c_cursor.row, 0);
+			break;
+
+		case 2:
+			/* erase whole screen */
+			for (row = 0;
+			    row < tems.ts_c_dimension.height;
+			    row++) {
+				tem_clear_chars(tem,
+				    tems.ts_c_dimension.width, row, 0);
+			}
+			break;
+		}
+		break;
+
+	case 'K':		/* EL - Erase in Line */
+		tem_send_data(tem);
+		tem_setparam(tem, 1, 0);
+		switch (tem->tvs_params[0]) {
+		case 0:
+			/* erase cursor to end of line */
+			tem_clear_chars(tem,
+			    (tems.ts_c_dimension.width -
+			    tem->tvs_c_cursor.col),
+			    tem->tvs_c_cursor.row,
+			    tem->tvs_c_cursor.col);
+			break;
+
+		case 1:
+			/* erase beginning of line to cursor */
+			tem_clear_chars(tem,
+			    tem->tvs_c_cursor.col + 1,
+			    tem->tvs_c_cursor.row, 0);
+			break;
+
+		case 2:
+			/* erase whole line */
+			tem_clear_chars(tem,
+			    tems.ts_c_dimension.width,
+			    tem->tvs_c_cursor.row, 0);
+			break;
+		}
+		break;
+
+	case 'L':		/* insert line */
+		tem_send_data(tem);
+		tem_setparam(tem, 1, 1);
+		tem_scroll(tem,
+		    tem->tvs_c_cursor.row,
+		    tems.ts_c_dimension.height - 1,
+		    tem->tvs_params[0], TEM_SCROLL_DOWN);
+		break;
+
+	case 'M':		/* delete line */
+		tem_send_data(tem);
+		tem_setparam(tem, 1, 1);
+		tem_scroll(tem,
+		    tem->tvs_c_cursor.row,
+		    tems.ts_c_dimension.height - 1,
+		    tem->tvs_params[0], TEM_SCROLL_UP);
+		break;
+
+	case 'P':		/* DCH - delete char */
+		tem_setparam(tem, 1, 1);
+		tem_shift(tem, tem->tvs_params[0], TEM_SHIFT_LEFT);
+		break;
+
+	case 'S':		/* scroll up */
+		tem_send_data(tem);
+		tem_setparam(tem, 1, 1);
+		tem_scroll(tem, 0,
+		    tems.ts_c_dimension.height - 1,
+		    tem->tvs_params[0], TEM_SCROLL_UP);
+		break;
+
+	case 'T':		/* scroll down */
+		tem_send_data(tem);
+		tem_setparam(tem, 1, 1);
+		tem_scroll(tem, 0,
+		    tems.ts_c_dimension.height - 1,
+		    tem->tvs_params[0], TEM_SCROLL_DOWN);
+		break;
+
+	case 'X':		/* erase char */
+		tem_setparam(tem, 1, 1);
+		tem_clear_chars(tem,
+		    tem->tvs_params[0],
+		    tem->tvs_c_cursor.row,
+		    tem->tvs_c_cursor.col);
+		break;
+
+	case 'Z':		/* cursor backward tabulation */
+		tem_setparam(tem, 1, 1);
+
+		/*
+		 * Rule exception - We do sanity checking here.
+		 *
+		 * Restrict the count to a sane value to keep from
+		 * looping for a long time.  There can't be more than one
+		 * tab stop per column, so use that as a limit.
+		 */
+		if (tem->tvs_params[0] > tems.ts_c_dimension.width)
+			tem->tvs_params[0] = tems.ts_c_dimension.width;
+
+		for (i = 0; i < tem->tvs_params[0]; i++)
+			tem_back_tab(tem);
+		break;
+	}
+	tem->tvs_state = A_STATE_START;
+}
+
+
+/*
+ * Gather the parameters of an ANSI escape sequence
+ */
+static void
+tem_getparams(struct tem_vt_state *tem, uint8_t ch)
+{
+	if (ch >= '0' && ch <= '9') {
+		tem->tvs_paramval = ((tem->tvs_paramval * 10) + (ch - '0'));
+		tem->tvs_gotparam = B_TRUE;  /* Remember got parameter */
+		return; /* Return immediately */
+	} else if (tem->tvs_state == A_STATE_CSI_EQUAL ||
+	    tem->tvs_state == A_STATE_CSI_QMARK) {
+		tem->tvs_state = A_STATE_START;
+	} else {
+		if (tem->tvs_curparam < TEM_MAXPARAMS) {
+			if (tem->tvs_gotparam) {
+				/* get the parameter value */
+				tem->tvs_params[tem->tvs_curparam] =
+				    tem->tvs_paramval;
+			}
+			tem->tvs_curparam++;
+		}
+
+		if (ch == ';') {
+			/* Restart parameter search */
+			tem->tvs_gotparam = B_FALSE;
+			tem->tvs_paramval = 0; /* No parame value yet */
+		} else {
+			/* Handle escape sequence */
+			tem_chkparam(tem, ch);
+		}
+	}
+}
+
+/*
+ * Add character to internal buffer.
+ * When its full, send it to the next layer.
+ */
+static void
+tem_outch(struct tem_vt_state *tem, tem_char_t ch)
+{
+	text_color_t fg;
+	text_color_t bg;
+	text_attr_t attr;
+
+	/* buffer up the character until later */
+	tem_get_attr(tem, &fg, &bg, &attr, TEM_ATTR_REVERSE);
+	tem->tvs_outbuf[tem->tvs_outindex].tc_char = ch | TEM_ATTR(attr);
+	tem->tvs_outbuf[tem->tvs_outindex].tc_fg_color = fg;
+	tem->tvs_outbuf[tem->tvs_outindex].tc_bg_color = bg;
+	tem->tvs_outindex++;
+	tem->tvs_c_cursor.col++;
+	if (tem->tvs_c_cursor.col >= tems.ts_c_dimension.width) {
+		tem_send_data(tem);
+		tem_new_line(tem);
+	}
+}
+
+static void
+tem_new_line(struct tem_vt_state *tem)
+{
+	tem_cr(tem);
+	tem_lf(tem);
+}
+
+static void
+tem_cr(struct tem_vt_state *tem)
+{
+	tem->tvs_c_cursor.col = 0;
+	tem_align_cursor(tem);
+}
+
+static void
+tem_lf(struct tem_vt_state *tem)
+{
+	int row;
+
+	/*
+	 * Sanity checking notes:
+	 * . a_nscroll was validated when it was set.
+	 * . Regardless of that, tem_scroll and tem_mv_cursor
+	 *   will prevent anything bad from happening.
+	 */
+	row = tem->tvs_c_cursor.row + 1;
+
+	if (row >= tems.ts_c_dimension.height) {
+		if (tem->tvs_nscroll != 0) {
+			tem_scroll(tem, 0,
+			    tems.ts_c_dimension.height - 1,
+			    tem->tvs_nscroll, TEM_SCROLL_UP);
+			row = tems.ts_c_dimension.height -
+			    tem->tvs_nscroll;
+		} else {	/* no scroll */
+			/*
+			 * implement Esc[#r when # is zero.  This means no
+			 * scroll but just return cursor to top of screen,
+			 * do not clear screen.
+			 */
+			row = 0;
+		}
+	}
+
+	tem_mv_cursor(tem, row, tem->tvs_c_cursor.col);
+
+	if (tem->tvs_nscroll == 0) {
+		/* erase rest of cursor line */
+		tem_clear_chars(tem,
+		    tems.ts_c_dimension.width -
+		    tem->tvs_c_cursor.col,
+		    tem->tvs_c_cursor.row,
+		    tem->tvs_c_cursor.col);
+
+	}
+
+	tem_align_cursor(tem);
+}
+
+static void
+tem_send_data(struct tem_vt_state *tem)
+{
+	if (tem->tvs_outindex == 0) {
+		tem_align_cursor(tem);
+		return;
+	}
+
+	tem_virtual_display(tem, tem->tvs_outbuf, tem->tvs_outindex,
+	    tem->tvs_s_cursor.row, tem->tvs_s_cursor.col);
+
+	if (tem->tvs_isactive) {
+		/*
+		 * Call the primitive to render this data.
+		 */
+		tem_callback_display(tem,
+		    tem->tvs_outbuf, tem->tvs_outindex,
+		    tem->tvs_s_cursor.row, tem->tvs_s_cursor.col);
+	}
+
+	tem->tvs_outindex = 0;
+
+	tem_align_cursor(tem);
+}
+
+
+/*
+ * We have just done something to the current output point.  Reset the start
+ * point for the buffered data in a_outbuf.  There shouldn't be any data
+ * buffered yet.
+ */
+static void
+tem_align_cursor(struct tem_vt_state *tem)
+{
+	tem->tvs_s_cursor.row = tem->tvs_c_cursor.row;
+	tem->tvs_s_cursor.col = tem->tvs_c_cursor.col;
+}
+
+/*
+ * State machine parser based on the current state and character input
+ * major terminations are to control character or normal character
+ */
+
+static void
+tem_parse(struct tem_vt_state *tem, tem_char_t ch)
+{
+	int	i;
+
+	if (tem->tvs_state == A_STATE_START) {	/* Normal state? */
+		if (ch == A_CSI || ch == A_ESC || ch < ' ') {
+			/* Control */
+			tem_control(tem, ch);
+		} else {
+			/* Display */
+			tem_outch(tem, ch);
+		}
+		return;
+	}
+
+	/* In <ESC> sequence */
+	if (tem->tvs_state != A_STATE_ESC) {	/* Need to get parameters? */
+		if (tem->tvs_state != A_STATE_CSI) {
+			tem_getparams(tem, ch);
+			return;
+		}
+
+		switch (ch) {
+		case '?':
+			tem->tvs_state = A_STATE_CSI_QMARK;
+			return;
+		case '=':
+			tem->tvs_state = A_STATE_CSI_EQUAL;
+			return;
+		case 's':
+			/*
+			 * As defined below, this sequence
+			 * saves the cursor.  However, Sun
+			 * defines ESC[s as reset.  We resolved
+			 * the conflict by selecting reset as it
+			 * is exported in the termcap file for
+			 * sun-mon, while the "save cursor"
+			 * definition does not exist anywhere in
+			 * /etc/termcap.
+			 * However, having no coherent
+			 * definition of reset, we have not
+			 * implemented it.
+			 */
+
+			/*
+			 * Original code
+			 * tem->tvs_r_cursor.row = tem->tvs_c_cursor.row;
+			 * tem->tvs_r_cursor.col = tem->tvs_c_cursor.col;
+			 * tem->tvs_state = A_STATE_START;
+			 */
+
+			tem->tvs_state = A_STATE_START;
+			return;
+		case 'u':
+			tem_mv_cursor(tem, tem->tvs_r_cursor.row,
+			    tem->tvs_r_cursor.col);
+			tem->tvs_state = A_STATE_START;
+			return;
+		case 'p':	/* sunbow */
+			tem_send_data(tem);
+			/*
+			 * Don't set anything if we are
+			 * already as we want to be.
+			 */
+			if (tem->tvs_flags & TEM_ATTR_SCREEN_REVERSE) {
+				tem->tvs_flags &= ~TEM_ATTR_SCREEN_REVERSE;
+				/*
+				 * If we have switched the characters to be the
+				 * inverse from the screen, then switch them as
+				 * well to keep them the inverse of the screen.
+				 */
+				if (tem->tvs_flags & TEM_ATTR_REVERSE)
+					tem->tvs_flags &= ~TEM_ATTR_REVERSE;
+				else
+					tem->tvs_flags |= TEM_ATTR_REVERSE;
+			}
+			tem_cls(tem);
+			tem->tvs_state = A_STATE_START;
+			return;
+		case 'q':	/* sunwob */
+			tem_send_data(tem);
+			/*
+			 * Don't set anything if we are
+			 * already where as we want to be.
+			 */
+			if (!(tem->tvs_flags & TEM_ATTR_SCREEN_REVERSE)) {
+				tem->tvs_flags |= TEM_ATTR_SCREEN_REVERSE;
+				/*
+				 * If we have switched the characters to be the
+				 * inverse from the screen, then switch them as
+				 * well to keep them the inverse of the screen.
+				 */
+				if (!(tem->tvs_flags & TEM_ATTR_REVERSE))
+					tem->tvs_flags |= TEM_ATTR_REVERSE;
+				else
+					tem->tvs_flags &= ~TEM_ATTR_REVERSE;
+			}
+
+			tem_cls(tem);
+			tem->tvs_state = A_STATE_START;
+			return;
+		case 'r':	/* sunscrl */
+			/*
+			 * Rule exception:  check for validity here.
+			 */
+			tem->tvs_nscroll = tem->tvs_paramval;
+			if (tem->tvs_nscroll > tems.ts_c_dimension.height)
+				tem->tvs_nscroll = tems.ts_c_dimension.height;
+			if (tem->tvs_nscroll < 0)
+				tem->tvs_nscroll = 1;
+			tem->tvs_state = A_STATE_START;
+			return;
+		default:
+			tem_getparams(tem, ch);
+			return;
+		}
+	}
+
+	/* Previous char was <ESC> */
+	if (ch == '[') {
+		tem->tvs_curparam = 0;
+		tem->tvs_paramval = 0;
+		tem->tvs_gotparam = B_FALSE;
+		/* clear the parameters */
+		for (i = 0; i < TEM_MAXPARAMS; i++)
+			tem->tvs_params[i] = -1;
+		tem->tvs_state = A_STATE_CSI;
+	} else if (ch == 'Q') {	/* <ESC>Q ? */
+		tem->tvs_state = A_STATE_START;
+	} else if (ch == 'C') {	/* <ESC>C ? */
+		tem->tvs_state = A_STATE_START;
+	} else {
+		tem->tvs_state = A_STATE_START;
+		if (ch == 'c') {
+			/* ESC c resets display */
+			tem_reset_display(tem, B_TRUE, B_TRUE);
+		} else if (ch == 'H') {
+			/* ESC H sets a tab */
+			tem_set_tab(tem);
+		} else if (ch == '7') {
+			/* ESC 7 Save Cursor position */
+			tem->tvs_r_cursor.row = tem->tvs_c_cursor.row;
+			tem->tvs_r_cursor.col = tem->tvs_c_cursor.col;
+		} else if (ch == '8') {
+			/* ESC 8 Restore Cursor position */
+			tem_mv_cursor(tem, tem->tvs_r_cursor.row,
+			    tem->tvs_r_cursor.col);
+		/* check for control chars */
+		} else if (ch < ' ') {
+			tem_control(tem, ch);
+		} else {
+			tem_outch(tem, ch);
+		}
+	}
+}
+
+/* ARGSUSED */
+static void
+tem_bell(struct tem_vt_state *tem __unused)
+{
+		/* (void) beep(BEEP_CONSOLE); */
+}
+
+
+static void
+tem_scroll(struct tem_vt_state *tem, int start, int end, int count,
+    int direction)
+{
+	int	row;
+	int	lines_affected;
+
+	lines_affected = end - start + 1;
+	if (count > lines_affected)
+		count = lines_affected;
+	if (count <= 0)
+		return;
+
+	switch (direction) {
+	case TEM_SCROLL_UP:
+		if (count < lines_affected) {
+			tem_copy_area(tem, 0, start + count,
+			    tems.ts_c_dimension.width - 1, end, 0, start);
+		}
+		for (row = (end - count) + 1; row <= end; row++) {
+			tem_clear_chars(tem, tems.ts_c_dimension.width, row, 0);
+		}
+		break;
+
+	case TEM_SCROLL_DOWN:
+		if (count < lines_affected) {
+			tem_copy_area(tem, 0, start,
+			    tems.ts_c_dimension.width - 1,
+			    end - count, 0, start + count);
+		}
+		for (row = start; row < start + count; row++) {
+			tem_clear_chars(tem, tems.ts_c_dimension.width, row, 0);
+		}
+		break;
+	}
+}
+
+static int
+tem_copy_width(term_char_t *src, term_char_t *dst, int cols)
+{
+	int width = cols - 1;
+
+	while (width >= 0) {
+		/* We do not have image bits to compare, stop there. */
+		if (TEM_CHAR_ATTR(src[width].tc_char) == TEM_ATTR_IMAGE ||
+		    TEM_CHAR_ATTR(dst[width].tc_char) == TEM_ATTR_IMAGE)
+			break;
+
+		/*
+		 * Find difference on line, compare char with its attributes
+		 * and colors.
+		 */
+		if (src[width].tc_char != dst[width].tc_char ||
+		    src[width].tc_fg_color != dst[width].tc_fg_color ||
+		    src[width].tc_bg_color != dst[width].tc_bg_color) {
+			break;
+		}
+		width--;
+	}
+	return (width + 1);
+}
+
+static void
+tem_copy_area(struct tem_vt_state *tem,
+    screen_pos_t s_col, screen_pos_t s_row,
+    screen_pos_t e_col, screen_pos_t e_row,
+    screen_pos_t t_col, screen_pos_t t_row)
+{
+	size_t soffset, toffset;
+	term_char_t *src, *dst;
+	int rows;
+	int cols;
+
+	if (s_col < 0 || s_row < 0 ||
+	    e_col < 0 || e_row < 0 ||
+	    t_col < 0 || t_row < 0 ||
+	    s_col >= tems.ts_c_dimension.width ||
+	    e_col >= tems.ts_c_dimension.width ||
+	    t_col >= tems.ts_c_dimension.width ||
+	    s_row >= tems.ts_c_dimension.height ||
+	    e_row >= tems.ts_c_dimension.height ||
+	    t_row >= tems.ts_c_dimension.height)
+		return;
+
+	if (s_row > e_row || s_col > e_col)
+		return;
+
+	rows = e_row - s_row + 1;
+	cols = e_col - s_col + 1;
+	if (t_row + rows > tems.ts_c_dimension.height ||
+	    t_col + cols > tems.ts_c_dimension.width)
+		return;
+
+	if (tem->tvs_screen_buf == NULL) {
+		if (tem->tvs_isactive) {
+			tem_callback_copy(tem, s_col, s_row,
+			    e_col, e_row, t_col, t_row);
+		}
+		return;
+	}
+
+	soffset = s_col + s_row * tems.ts_c_dimension.width;
+	toffset = t_col + t_row * tems.ts_c_dimension.width;
+	src = tem->tvs_screen_buf + soffset;
+	dst = tem->tvs_screen_buf + toffset;
+
+	/*
+	 * Copy line by line. We determine the length by comparing the
+	 * screen content from cached text in tvs_screen_buf.
+	 */
+	if (toffset <= soffset) {
+		for (int i = 0; i < rows; i++) {
+			int increment = i * tems.ts_c_dimension.width;
+			int width;
+
+			width = tem_copy_width(src + increment,
+			    dst + increment, cols);
+			memmove(dst + increment, src + increment,
+			    width * sizeof (term_char_t));
+			if (tem->tvs_isactive) {
+				tem_callback_copy(tem, s_col, s_row + i,
+				    e_col - cols + width, s_row + i,
+				    t_col, t_row + i);
+			}
+		}
+	} else {
+		for (int i = rows - 1; i >= 0; i--) {
+			int increment = i * tems.ts_c_dimension.width;
+			int width;
+
+			width = tem_copy_width(src + increment,
+			    dst + increment, cols);
+			memmove(dst + increment, src + increment,
+			    width * sizeof (term_char_t));
+			if (tem->tvs_isactive) {
+				tem_callback_copy(tem, s_col, s_row + i,
+				    e_col - cols + width, s_row + i,
+				    t_col, t_row + i);
+			}
+		}
+	}
+}
+
+static void
+tem_clear_chars(struct tem_vt_state *tem, int count, screen_pos_t row,
+    screen_pos_t col)
+{
+	if (row < 0 || row >= tems.ts_c_dimension.height ||
+	    col < 0 || col >= tems.ts_c_dimension.width ||
+	    count < 0)
+		return;
+
+	/*
+	 * Note that very large values of "count" could cause col+count
+	 * to overflow, so we check "count" independently.
+	 */
+	if (count > tems.ts_c_dimension.width ||
+	    col + count > tems.ts_c_dimension.width)
+		count = tems.ts_c_dimension.width - col;
+
+	tem_virtual_cls(tem, count, row, col);
+
+	if (!tem->tvs_isactive)
+		return;
+
+	tem_callback_cls(tem, count, row, col);
+}
+
+static void
+tem_text_display(struct tem_vt_state *tem __unused, term_char_t *string,
+    int count, screen_pos_t row, screen_pos_t col)
+{
+	struct vis_consdisplay da;
+	int i;
+	tem_char_t c;
+
+	if (count == 0)
+		return;
+
+	da.data = (unsigned char *)&c;
+	da.width = 1;
+	da.row = row;
+	da.col = col;
+
+	for (i = 0; i < count; i++) {
+		tem_get_color(&da.fg_color, &da.bg_color, string[i]);
+		c = TEM_CHAR(string[i].tc_char);
+		tems_display(&da);
+		da.col++;
+	}
+}
+
+/*
+ * This function is used to mark a rectangular image area so the scrolling
+ * will know we need to copy the data from there.
+ */
+void
+tem_image_display(struct tem_vt_state *tem, screen_pos_t s_row,
+    screen_pos_t s_col, screen_pos_t e_row, screen_pos_t e_col)
+{
+	screen_pos_t i, j;
+	term_char_t c;
+
+	c.tc_char = TEM_ATTR(TEM_ATTR_IMAGE);
+
+	for (i = s_row; i <= e_row; i++) {
+		for (j = s_col; j <= e_col; j++) {
+			tem_virtual_display(tem, &c, 1, i, j);
+		}
+	}
+}
+
+/*ARGSUSED*/
+static void
+tem_text_copy(struct tem_vt_state *tem __unused,
+    screen_pos_t s_col, screen_pos_t s_row,
+    screen_pos_t e_col, screen_pos_t e_row,
+    screen_pos_t t_col, screen_pos_t t_row)
+{
+	struct vis_conscopy da;
+
+	da.s_row = s_row;
+	da.s_col = s_col;
+	da.e_row = e_row;
+	da.e_col = e_col;
+	da.t_row = t_row;
+	da.t_col = t_col;
+	tems_copy(&da);
+}
+
+static void
+tem_text_cls(struct tem_vt_state *tem,
+    int count, screen_pos_t row, screen_pos_t col)
+{
+	text_attr_t attr;
+	term_char_t c;
+	int i;
+
+	tem_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
+	    TEM_ATTR_SCREEN_REVERSE);
+	c.tc_char = TEM_ATTR(attr & ~TEM_ATTR_UNDERLINE) | ' ';
+
+	if (count > tems.ts_c_dimension.width ||
+	    col + count > tems.ts_c_dimension.width)
+		count = tems.ts_c_dimension.width - col;
+
+	for (i = 0; i < count; i++)
+		tem_text_display(tem, &c, 1, row, col++);
+
+}
+
+static void
+tem_pix_display(struct tem_vt_state *tem,
+    term_char_t *string, int count,
+    screen_pos_t row, screen_pos_t col)
+{
+	struct vis_consdisplay da;
+	int	i;
+
+	da.data = (uint8_t *)tem->tvs_pix_data;
+	da.width = tems.ts_font.vf_width;
+	da.height = tems.ts_font.vf_height;
+	da.row = (row * da.height) + tems.ts_p_offset.y;
+	da.col = (col * da.width) + tems.ts_p_offset.x;
+
+	for (i = 0; i < count; i++) {
+		tem_callback_bit2pix(tem, string[i]);
+		tems_display(&da);
+		da.col += da.width;
+	}
+}
+
+static void
+tem_pix_copy(struct tem_vt_state *tem,
+    screen_pos_t s_col, screen_pos_t s_row,
+    screen_pos_t e_col, screen_pos_t e_row,
+    screen_pos_t t_col, screen_pos_t t_row)
+{
+	struct vis_conscopy ma;
+	static boolean_t need_clear = B_TRUE;
+
+	if (need_clear && tem->tvs_first_line > 0) {
+		/*
+		 * Clear OBP output above our kernel console term
+		 * when our kernel console term begins to scroll up,
+		 * we hope it is user friendly.
+		 * (Also see comments on tem_pix_clear_prom_output)
+		 *
+		 * This is only one time call.
+		 */
+		tem_pix_clear_prom_output(tem);
+	}
+	need_clear = B_FALSE;
+
+	ma.s_row = s_row * tems.ts_font.vf_height + tems.ts_p_offset.y;
+	ma.e_row = (e_row + 1) * tems.ts_font.vf_height +
+	    tems.ts_p_offset.y - 1;
+	ma.t_row = t_row * tems.ts_font.vf_height + tems.ts_p_offset.y;
+
+	/*
+	 * Check if we're in process of clearing OBP's columns area,
+	 * which only happens when term scrolls up a whole line.
+	 */
+	if (tem->tvs_first_line > 0 && t_row < s_row && t_col == 0 &&
+	    e_col == tems.ts_c_dimension.width - 1) {
+		/*
+		 * We need to clear OBP's columns area outside our kernel
+		 * console term. So that we set ma.e_col to entire row here.
+		 */
+		ma.s_col = s_col * tems.ts_font.vf_width;
+		ma.e_col = tems.ts_p_dimension.width - 1;
+
+		ma.t_col = t_col * tems.ts_font.vf_width;
+	} else {
+		ma.s_col = s_col * tems.ts_font.vf_width + tems.ts_p_offset.x;
+		ma.e_col = (e_col + 1) * tems.ts_font.vf_width +
+		    tems.ts_p_offset.x - 1;
+		ma.t_col = t_col * tems.ts_font.vf_width + tems.ts_p_offset.x;
+	}
+
+	tems_copy(&ma);
+
+	if (tem->tvs_first_line > 0 && t_row < s_row) {
+		/* We have scrolled up (s_row - t_row) rows. */
+		tem->tvs_first_line -= (s_row - t_row);
+		if (tem->tvs_first_line <= 0) {
+			/* All OBP rows have been cleared. */
+			tem->tvs_first_line = 0;
+		}
+	}
+}
+
+static void
+tem_pix_bit2pix(struct tem_vt_state *tem, term_char_t c)
+{
+	text_color_t fg, bg;
+	void (*fp)(struct tem_vt_state *, tem_char_t,
+	    unsigned char, unsigned char);
+
+	tem_get_color(&fg, &bg, c);
+	switch (tems.ts_pdepth) {
+	case 4:
+		fp = bit_to_pix4;
+		break;
+	case 8:
+		fp = bit_to_pix8;
+		break;
+	case 15:
+	case 16:
+		fp = bit_to_pix16;
+		break;
+	case 24:
+		fp = bit_to_pix24;
+		break;
+	case 32:
+		fp = bit_to_pix32;
+		break;
+	default:
+		return;
+	}
+
+	fp(tem, c.tc_char, fg, bg);
+}
+
+
+/*
+ * This function only clears count of columns in one row
+ */
+static void
+tem_pix_cls(struct tem_vt_state *tem, int count,
+    screen_pos_t row, screen_pos_t col)
+{
+	tem_pix_cls_range(tem, row, 1, tems.ts_p_offset.y,
+	    col, count, tems.ts_p_offset.x, B_FALSE);
+}
+
+/*
+ * This function clears OBP output above our kernel console term area
+ * because OBP's term may have a bigger terminal window than that of
+ * our kernel console term. So we need to clear OBP output garbage outside
+ * of our kernel console term at a proper time, which is when the first
+ * row output of our kernel console term scrolls at the first screen line.
+ *
+ *	_________________________________
+ *	|   _____________________	|  ---> OBP's bigger term window
+ *	|   |			|	|
+ *	|___|			|	|
+ *	| | |			|	|
+ *	| | |			|	|
+ *	|_|_|___________________|_______|
+ *	  | |			|	   ---> first line
+ *	  | |___________________|---> our kernel console term window
+ *	  |
+ *	  |---> columns area to be cleared
+ *
+ * This function only takes care of the output above our kernel console term,
+ * and tem_prom_scroll_up takes care of columns area outside of our kernel
+ * console term.
+ */
+static void
+tem_pix_clear_prom_output(struct tem_vt_state *tem)
+{
+	int	nrows, ncols, width, height, offset;
+
+	width = tems.ts_font.vf_width;
+	height = tems.ts_font.vf_height;
+	offset = tems.ts_p_offset.y % height;
+
+	nrows = tems.ts_p_offset.y / height;
+	ncols = (tems.ts_p_dimension.width + (width - 1))/ width;
+
+	if (nrows > 0)
+		tem_pix_cls_range(tem, 0, nrows, offset, 0, ncols, 0,
+		    B_FALSE);
+}
+
+/*
+ * Clear the whole screen and reset the cursor to start point.
+ */
+static void
+tem_cls(struct tem_vt_state *tem)
+{
+	struct vis_consclear cl;
+	text_color_t fg_color;
+	text_color_t bg_color;
+	text_attr_t attr;
+	term_char_t c;
+	int row;
+
+	for (row = 0; row < tems.ts_c_dimension.height; row++) {
+		tem_virtual_cls(tem, tems.ts_c_dimension.width, row, 0);
+	}
+
+	if (!tem->tvs_isactive)
+		return;
+
+	tem_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
+	    TEM_ATTR_SCREEN_REVERSE);
+	c.tc_char = TEM_ATTR(attr);
+
+	tem_get_color(&fg_color, &bg_color, c);
+	cl.bg_color = bg_color;
+	(void)tems_cls(&cl);
+
+	tem->tvs_c_cursor.row = 0;
+	tem->tvs_c_cursor.col = 0;
+	tem_align_cursor(tem);
+}
+
+static void
+tem_back_tab(struct tem_vt_state *tem)
+{
+	int	i;
+	screen_pos_t	tabstop;
+
+	tabstop = 0;
+
+	for (i = tem->tvs_ntabs - 1; i >= 0; i--) {
+		if (tem->tvs_tabs[i] < tem->tvs_c_cursor.col) {
+			tabstop = tem->tvs_tabs[i];
+			break;
+		}
+	}
+
+	tem_mv_cursor(tem, tem->tvs_c_cursor.row, tabstop);
+}
+
+static void
+tem_tab(struct tem_vt_state *tem)
+{
+	int	i;
+	screen_pos_t	tabstop;
+
+	tabstop = tems.ts_c_dimension.width - 1;
+
+	for (i = 0; i < tem->tvs_ntabs; i++) {
+		if (tem->tvs_tabs[i] > tem->tvs_c_cursor.col) {
+			tabstop = tem->tvs_tabs[i];
+			break;
+		}
+	}
+
+	tem_mv_cursor(tem, tem->tvs_c_cursor.row, tabstop);
+}
+
+static void
+tem_set_tab(struct tem_vt_state *tem)
+{
+	int	i;
+	int	j;
+
+	if (tem->tvs_ntabs == TEM_MAXTAB)
+		return;
+	if (tem->tvs_ntabs == 0 ||
+	    tem->tvs_tabs[tem->tvs_ntabs] < tem->tvs_c_cursor.col) {
+			tem->tvs_tabs[tem->tvs_ntabs++] = tem->tvs_c_cursor.col;
+			return;
+	}
+	for (i = 0; i < tem->tvs_ntabs; i++) {
+		if (tem->tvs_tabs[i] == tem->tvs_c_cursor.col)
+			return;
+		if (tem->tvs_tabs[i] > tem->tvs_c_cursor.col) {
+			for (j = tem->tvs_ntabs - 1; j >= i; j--)
+				tem->tvs_tabs[j+ 1] = tem->tvs_tabs[j];
+			tem->tvs_tabs[i] = tem->tvs_c_cursor.col;
+			tem->tvs_ntabs++;
+			return;
+		}
+	}
+}
+
+static void
+tem_clear_tabs(struct tem_vt_state *tem, int action)
+{
+	int	i;
+	int	j;
+
+	switch (action) {
+	case 3: /* clear all tabs */
+		tem->tvs_ntabs = 0;
+		break;
+	case 0: /* clr tab at cursor */
+
+		for (i = 0; i < tem->tvs_ntabs; i++) {
+			if (tem->tvs_tabs[i] == tem->tvs_c_cursor.col) {
+				tem->tvs_ntabs--;
+				for (j = i; j < tem->tvs_ntabs; j++)
+					tem->tvs_tabs[j] = tem->tvs_tabs[j + 1];
+				return;
+			}
+		}
+		break;
+	}
+}
+
+static void
+tem_mv_cursor(struct tem_vt_state *tem, int row, int col)
+{
+	/*
+	 * Sanity check and bounds enforcement.  Out of bounds requests are
+	 * clipped to the screen boundaries.  This seems to be what SPARC
+	 * does.
+	 */
+	if (row < 0)
+		row = 0;
+	if (row >= tems.ts_c_dimension.height)
+		row = tems.ts_c_dimension.height - 1;
+	if (col < 0)
+		col = 0;
+	if (col >= tems.ts_c_dimension.width)
+		col = tems.ts_c_dimension.width - 1;
+
+	tem_send_data(tem);
+	tem->tvs_c_cursor.row = (screen_pos_t)row;
+	tem->tvs_c_cursor.col = (screen_pos_t)col;
+	tem_align_cursor(tem);
+}
+
+/* ARGSUSED */
+static void
+tem_reset_emulator(struct tem_vt_state *tem, boolean_t init_color)
+{
+	int j;
+
+	tem->tvs_c_cursor.row = 0;
+	tem->tvs_c_cursor.col = 0;
+	tem->tvs_r_cursor.row = 0;
+	tem->tvs_r_cursor.col = 0;
+	tem->tvs_s_cursor.row = 0;
+	tem->tvs_s_cursor.col = 0;
+	tem->tvs_outindex = 0;
+	tem->tvs_state = A_STATE_START;
+	tem->tvs_gotparam = B_FALSE;
+	tem->tvs_curparam = 0;
+	tem->tvs_paramval = 0;
+	tem->tvs_nscroll = 1;
+
+	if (init_color) {
+		/* use initial settings */
+		tem->tvs_fg_color = tems.ts_init_color.fg_color;
+		tem->tvs_bg_color = tems.ts_init_color.bg_color;
+		tem->tvs_flags = tems.ts_init_color.a_flags;
+	}
+
+	/*
+	 * set up the initial tab stops
+	 */
+	tem->tvs_ntabs = 0;
+	for (j = 8; j < tems.ts_c_dimension.width; j += 8)
+		tem->tvs_tabs[tem->tvs_ntabs++] = (screen_pos_t)j;
+
+	for (j = 0; j < TEM_MAXPARAMS; j++)
+		tem->tvs_params[j] = 0;
+}
+
+static void
+tem_reset_display(struct tem_vt_state *tem,
+    boolean_t clear_txt, boolean_t init_color)
+{
+	tem_reset_emulator(tem, init_color);
+
+	if (clear_txt) {
+		if (tem->tvs_isactive)
+			tem_callback_cursor(tem, VIS_HIDE_CURSOR);
+
+		tem_cls(tem);
+
+		if (tem->tvs_isactive)
+			tem_callback_cursor(tem, VIS_DISPLAY_CURSOR);
+	}
+}
+
+static void
+tem_shift(struct tem_vt_state *tem, int count, int direction)
+{
+	int rest_of_line;
+
+	rest_of_line = tems.ts_c_dimension.width - tem->tvs_c_cursor.col;
+	if (count > rest_of_line)
+		count = rest_of_line;
+
+	if (count <= 0)
+		return;
+
+	switch (direction) {
+	case TEM_SHIFT_LEFT:
+		if (count < rest_of_line) {
+			tem_copy_area(tem,
+			    tem->tvs_c_cursor.col + count,
+			    tem->tvs_c_cursor.row,
+			    tems.ts_c_dimension.width - 1,
+			    tem->tvs_c_cursor.row,
+			    tem->tvs_c_cursor.col,
+			    tem->tvs_c_cursor.row);
+		}
+
+		tem_clear_chars(tem, count, tem->tvs_c_cursor.row,
+		    (tems.ts_c_dimension.width - count));
+		break;
+	case TEM_SHIFT_RIGHT:
+		if (count < rest_of_line) {
+			tem_copy_area(tem,
+			    tem->tvs_c_cursor.col,
+			    tem->tvs_c_cursor.row,
+			    tems.ts_c_dimension.width - count - 1,
+			    tem->tvs_c_cursor.row,
+			    tem->tvs_c_cursor.col + count,
+			    tem->tvs_c_cursor.row);
+		}
+
+		tem_clear_chars(tem, count, tem->tvs_c_cursor.row,
+		    tem->tvs_c_cursor.col);
+		break;
+	}
+}
+
+static void
+tem_text_cursor(struct tem_vt_state *tem, short action)
+{
+	struct vis_conscursor	ca;
+
+	ca.row = tem->tvs_c_cursor.row;
+	ca.col = tem->tvs_c_cursor.col;
+	ca.action = action;
+
+	tems_cursor(&ca);
+
+	if (action == VIS_GET_CURSOR) {
+		tem->tvs_c_cursor.row = ca.row;
+		tem->tvs_c_cursor.col = ca.col;
+	}
+}
+
+static void
+tem_pix_cursor(struct tem_vt_state *tem, short action)
+{
+	struct vis_conscursor	ca;
+	uint32_t color;
+	text_color_t fg, bg;
+	term_char_t c;
+	text_attr_t attr;
+
+	ca.row = tem->tvs_c_cursor.row * tems.ts_font.vf_height +
+	    tems.ts_p_offset.y;
+	ca.col = tem->tvs_c_cursor.col * tems.ts_font.vf_width +
+	    tems.ts_p_offset.x;
+	ca.width = tems.ts_font.vf_width;
+	ca.height = tems.ts_font.vf_height;
+
+	tem_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
+	    TEM_ATTR_REVERSE);
+	c.tc_char = TEM_ATTR(attr);
+
+	tem_get_color(&fg, &bg, c);
+
+	switch (tems.ts_pdepth) {
+	case 4:
+		ca.fg_color.mono = fg;
+		ca.bg_color.mono = bg;
+		break;
+	case 8:
+		ca.fg_color.mono = tems.ts_color_map(fg);
+		ca.bg_color.mono = tems.ts_color_map(bg);
+		break;
+	case 15:
+	case 16:
+		color = tems.ts_color_map(fg);
+		ca.fg_color.sixteen[0] = (color >> 8) & 0xFF;
+		ca.fg_color.sixteen[1] = color & 0xFF;
+		color = tems.ts_color_map(bg);
+		ca.bg_color.sixteen[0] = (color >> 8) & 0xFF;
+		ca.bg_color.sixteen[1] = color & 0xFF;
+		break;
+	case 24:
+	case 32:
+		color = tems.ts_color_map(fg);
+		ca.fg_color.twentyfour[0] = (color >> 16) & 0xFF;
+		ca.fg_color.twentyfour[1] = (color >> 8) & 0xFF;
+		ca.fg_color.twentyfour[2] = color & 0xFF;
+		color = tems.ts_color_map(bg);
+		ca.bg_color.twentyfour[0] = (color >> 16) & 0xFF;
+		ca.bg_color.twentyfour[1] = (color >> 8) & 0xFF;
+		ca.bg_color.twentyfour[2] = color & 0xFF;
+		break;
+	}
+
+	ca.action = action;
+
+	tems_cursor(&ca);
+
+	if (action == VIS_GET_CURSOR) {
+		tem->tvs_c_cursor.row = 0;
+		tem->tvs_c_cursor.col = 0;
+
+		if (ca.row != 0) {
+			tem->tvs_c_cursor.row = (ca.row - tems.ts_p_offset.y) /
+			    tems.ts_font.vf_height;
+		}
+		if (ca.col != 0) {
+			tem->tvs_c_cursor.col = (ca.col - tems.ts_p_offset.x) /
+			    tems.ts_font.vf_width;
+		}
+	}
+}
+
+static void
+bit_to_pix4(struct tem_vt_state *tem,
+    tem_char_t c,
+    text_color_t fg_color,
+    text_color_t bg_color)
+{
+	uint8_t *dest = (uint8_t *)tem->tvs_pix_data;
+	font_bit_to_pix4(&tems.ts_font, dest, c, fg_color, bg_color);
+}
+
+static void
+bit_to_pix8(struct tem_vt_state *tem,
+    tem_char_t c,
+    text_color_t fg_color,
+    text_color_t bg_color)
+{
+	uint8_t *dest = (uint8_t *)tem->tvs_pix_data;
+
+	fg_color = (text_color_t)tems.ts_color_map(fg_color);
+	bg_color = (text_color_t)tems.ts_color_map(bg_color);
+	font_bit_to_pix8(&tems.ts_font, dest, c, fg_color, bg_color);
+}
+
+static void
+bit_to_pix16(struct tem_vt_state *tem,
+    tem_char_t c,
+    text_color_t fg_color4,
+    text_color_t bg_color4)
+{
+	uint16_t fg_color16, bg_color16;
+	uint16_t *dest;
+
+	fg_color16 = (uint16_t)tems.ts_color_map(fg_color4);
+	bg_color16 = (uint16_t)tems.ts_color_map(bg_color4);
+
+	dest = (uint16_t *)tem->tvs_pix_data;
+	font_bit_to_pix16(&tems.ts_font, dest, c, fg_color16, bg_color16);
+}
+
+static void
+bit_to_pix24(struct tem_vt_state *tem,
+    tem_char_t c,
+    text_color_t fg_color4,
+    text_color_t bg_color4)
+{
+	uint32_t fg_color32, bg_color32;
+	uint8_t *dest;
+
+	fg_color32 = tems.ts_color_map(fg_color4);
+	bg_color32 = tems.ts_color_map(bg_color4);
+
+	dest = (uint8_t *)tem->tvs_pix_data;
+	font_bit_to_pix24(&tems.ts_font, dest, c, fg_color32, bg_color32);
+}
+
+static void
+bit_to_pix32(struct tem_vt_state *tem,
+    tem_char_t c,
+    text_color_t fg_color4,
+    text_color_t bg_color4)
+{
+	uint32_t fg_color32, bg_color32, *dest;
+
+	fg_color32 = (0xFF << 24) | tems.ts_color_map(fg_color4);
+	bg_color32 = (0xFF << 24) | tems.ts_color_map(bg_color4);
+
+	dest = (uint32_t *)tem->tvs_pix_data;
+	font_bit_to_pix32(&tems.ts_font, dest, c, fg_color32, bg_color32);
+}
+
+/*
+ * flag: TEM_ATTR_SCREEN_REVERSE or TEM_ATTR_REVERSE
+ */
+static void
+tem_get_attr(struct tem_vt_state *tem, text_color_t *fg,
+    text_color_t *bg, text_attr_t *attr, uint8_t flag)
+{
+	if (tem->tvs_flags & flag) {
+		*fg = tem->tvs_bg_color;
+		*bg = tem->tvs_fg_color;
+	} else {
+		*fg = tem->tvs_fg_color;
+		*bg = tem->tvs_bg_color;
+	}
+
+	if (attr == NULL)
+		return;
+
+	*attr = tem->tvs_flags;
+}
+
+static void
+tem_get_color(text_color_t *fg, text_color_t *bg, term_char_t c)
+{
+	if (TEM_CHAR_ATTR(c.tc_char) & (TEM_ATTR_BRIGHT_FG | TEM_ATTR_BOLD))
+		*fg = brt_xlate[c.tc_fg_color];
+	else
+		*fg = dim_xlate[c.tc_fg_color];
+
+	if (TEM_CHAR_ATTR(c.tc_char) & TEM_ATTR_BRIGHT_BG)
+		*bg = brt_xlate[c.tc_bg_color];
+	else
+		*bg = dim_xlate[c.tc_bg_color];
+}
+
+void
+tem_get_colors(tem_vt_state_t tem_arg, text_color_t *fg, text_color_t *bg)
+{
+	struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg;
+	text_attr_t attr;
+	term_char_t c;
+
+	tem_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
+	    TEM_ATTR_REVERSE);
+	c.tc_char = TEM_ATTR(attr);
+	tem_get_color(fg, bg, c);
+}
+
+/*
+ * Clear a rectangle of screen for pixel mode.
+ *
+ * arguments:
+ *    row:	start row#
+ *    nrows:	the number of rows to clear
+ *    offset_y:	the offset of height in pixels to begin clear
+ *    col:	start col#
+ *    ncols:	the number of cols to clear
+ *    offset_x:	the offset of width in pixels to begin clear
+ *    scroll_up: whether this function is called during sroll up,
+ *		 which is called only once.
+ */
+static void
+tem_pix_cls_range(struct tem_vt_state *tem,
+    screen_pos_t row, int nrows, int offset_y,
+    screen_pos_t col, int ncols, int offset_x,
+    boolean_t sroll_up)
+{
+	struct vis_consdisplay da;
+	int	i, j;
+	int	row_add = 0;
+	term_char_t c;
+	text_attr_t attr;
+
+	if (sroll_up)
+		row_add = tems.ts_c_dimension.height - 1;
+
+	da.width = tems.ts_font.vf_width;
+	da.height = tems.ts_font.vf_height;
+
+	tem_get_attr(tem, &c.tc_fg_color, &c.tc_bg_color, &attr,
+	    TEM_ATTR_SCREEN_REVERSE);
+	/* Make sure we will not draw underlines */
+	c.tc_char = TEM_ATTR(attr & ~TEM_ATTR_UNDERLINE) | ' ';
+
+	tem_callback_bit2pix(tem, c);
+	da.data = (uint8_t *)tem->tvs_pix_data;
+
+	for (i = 0; i < nrows; i++, row++) {
+		da.row = (row + row_add) * da.height + offset_y;
+		da.col = col * da.width + offset_x;
+		for (j = 0; j < ncols; j++) {
+			tems_display(&da);
+			da.col += da.width;
+		}
+	}
+}
+
+/*
+ * virtual screen operations
+ */
+static void
+tem_virtual_display(struct tem_vt_state *tem, term_char_t *string,
+    size_t count, screen_pos_t row, screen_pos_t col)
+{
+	size_t i, width;
+	term_char_t *addr;
+
+	if (tem->tvs_screen_buf == NULL)
+		return;
+
+	if (row < 0 || row >= tems.ts_c_dimension.height ||
+	    col < 0 || col >= tems.ts_c_dimension.width ||
+	    col + count > (size_t)tems.ts_c_dimension.width)
+		return;
+
+	width = tems.ts_c_dimension.width;
+	addr = tem->tvs_screen_buf +  (row * width + col);
+	for (i = 0; i < count; i++) {
+		*addr++ = string[i];
+	}
+}
+
+static void
+tem_virtual_cls(struct tem_vt_state *tem, size_t count,
+    screen_pos_t row, screen_pos_t col)
+{
+	term_char_t c;
+
+	c.tc_char = ' ';
+	tem_get_colors((tem_vt_state_t)tem, &c.tc_fg_color, &c.tc_bg_color);
+
+	while (count > 0) {
+		tem_virtual_display(tem, &c, 1, row, col);
+		col++;
+		count--;
+	}
+}
diff --git a/usr/src/boot/sys/boot/efi/Makefile.inc b/usr/src/boot/sys/boot/efi/Makefile.inc
index d25885fd01..7fbe2a3393 100644
--- a/usr/src/boot/sys/boot/efi/Makefile.inc
+++ b/usr/src/boot/sys/boot/efi/Makefile.inc
@@ -14,6 +14,7 @@
 #
 
 BINDIR=	/boot
+PNGLITE=$(SRC)/common/pnglite
 
 # Options used when building app-specific efi components
 # See conf/kern.mk for the correct set of these
diff --git a/usr/src/boot/sys/boot/efi/include/eficon.h b/usr/src/boot/sys/boot/efi/include/eficon.h
index 1d0c869f47..b5a387cb08 100644
--- a/usr/src/boot/sys/boot/efi/include/eficon.h
+++ b/usr/src/boot/sys/boot/efi/include/eficon.h
@@ -263,28 +263,56 @@ typedef struct {
 // Scan codes for base line keys
 //
 
-#define SCAN_NULL                       0x0000
-#define SCAN_UP                         0x0001
-#define SCAN_DOWN                       0x0002
-#define SCAN_RIGHT                      0x0003
-#define SCAN_LEFT                       0x0004
-#define SCAN_HOME                       0x0005
-#define SCAN_END                        0x0006
-#define SCAN_INSERT                     0x0007
-#define SCAN_DELETE                     0x0008
-#define SCAN_PAGE_UP                    0x0009
-#define SCAN_PAGE_DOWN                  0x000A
-#define SCAN_F1                         0x000B
-#define SCAN_F2                         0x000C
-#define SCAN_F3                         0x000D
-#define SCAN_F4                         0x000E
-#define SCAN_F5                         0x000F
-#define SCAN_F6                         0x0010
-#define SCAN_F7                         0x0011
-#define SCAN_F8                         0x0012
-#define SCAN_F9                         0x0013
-#define SCAN_F10                        0x0014
-#define SCAN_ESC                        0x0017
+#define SCAN_NULL		0x0000
+#define SCAN_UP			0x0001
+#define SCAN_DOWN		0x0002
+#define SCAN_RIGHT		0x0003
+#define SCAN_LEFT		0x0004
+#define SCAN_HOME		0x0005
+#define SCAN_END		0x0006
+#define SCAN_INSERT		0x0007
+#define SCAN_DELETE		0x0008
+#define SCAN_PAGE_UP		0x0009
+#define SCAN_PAGE_DOWN		0x000A
+#define SCAN_F1			0x000B
+#define SCAN_F2			0x000C
+#define SCAN_F3			0x000D
+#define SCAN_F4			0x000E
+#define SCAN_F5			0x000F
+#define SCAN_F6			0x0010
+#define SCAN_F7			0x0011
+#define SCAN_F8			0x0012
+#define SCAN_F9			0x0013
+#define SCAN_F10		0x0014
+#define SCAN_ESC		0x0017
+
+//
+// EFI Scan code Ex
+//
+#define SCAN_F11		0x0015
+#define SCAN_F12		0x0016
+#define SCAN_F13		0x0068
+#define SCAN_F14		0x0069
+#define SCAN_F15		0x006A
+#define SCAN_F16		0x006B
+#define SCAN_F17		0x006C
+#define SCAN_F18		0x006D
+#define SCAN_F19		0x006E
+#define SCAN_F20		0x006F
+#define SCAN_F21		0x0070
+#define SCAN_F22		0x0071
+#define SCAN_F23		0x0072
+#define SCAN_F24		0x0073
+#define SCAN_MUTE		0x007F
+#define SCAN_VOLUME_UP		0x0080
+#define SCAN_VOLUME_DOWN	0x0081
+#define SCAN_BRIGHTNESS_UP	0x0100
+#define SCAN_BRIGHTNESS_DOWN	0x0101
+#define SCAN_SUSPEND		0x0102
+#define SCAN_HIBERNATE		0x0103
+#define SCAN_TOGGLE_DISPLAY	0x0104
+#define SCAN_RECOVERY		0x0105
+#define SCAN_EJECT		0x0106
 
 typedef
 EFI_STATUS
@@ -310,4 +338,190 @@ typedef struct _SIMPLE_INPUT_INTERFACE {
   {0xdd9e7534, 0x7762, 0x4698, {0x8c, 0x14, 0xf5, 0x85, \
   0x17, 0xa6, 0x25, 0xaa} }
 
+INTERFACE_DECL(_EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL);
+
+typedef UINT8          EFI_KEY_TOGGLE_STATE;
+//
+// Any Shift or Toggle State that is valid should have
+// high order bit set.
+//
+typedef struct EFI_KEY_STATE {
+  UINT32               KeyShiftState;
+  EFI_KEY_TOGGLE_STATE KeyToggleState;
+} EFI_KEY_STATE;
+
+typedef struct {
+  EFI_INPUT_KEY        Key;
+  EFI_KEY_STATE        KeyState;
+} EFI_KEY_DATA;
+
+//
+// Shift state
+//
+#define EFI_SHIFT_STATE_VALID     0x80000000
+#define EFI_RIGHT_SHIFT_PRESSED   0x00000001
+#define EFI_LEFT_SHIFT_PRESSED    0x00000002
+#define EFI_RIGHT_CONTROL_PRESSED 0x00000004
+#define EFI_LEFT_CONTROL_PRESSED  0x00000008
+#define EFI_RIGHT_ALT_PRESSED     0x00000010
+#define EFI_LEFT_ALT_PRESSED      0x00000020
+#define EFI_RIGHT_LOGO_PRESSED    0x00000040
+#define EFI_LEFT_LOGO_PRESSED     0x00000080
+#define EFI_MENU_KEY_PRESSED      0x00000100
+#define EFI_SYS_REQ_PRESSED       0x00000200
+
+//
+// Toggle state
+//
+#define EFI_TOGGLE_STATE_VALID    0x80
+#define	EFI_KEY_STATE_EXPOSED     0x40
+#define EFI_SCROLL_LOCK_ACTIVE    0x01
+#define EFI_NUM_LOCK_ACTIVE       0x02
+#define EFI_CAPS_LOCK_ACTIVE      0x04
+
+//
+// EFI Key Notfication Function
+//
+typedef
+EFI_STATUS
+(EFIAPI *EFI_KEY_NOTIFY_FUNCTION) (
+  IN  EFI_KEY_DATA                      *KeyData
+  );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_RESET_EX) (
+  IN struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
+  IN BOOLEAN                            ExtendedVerification
+  )
+/*++
+
+  Routine Description:
+    Reset the input device and optionaly run diagnostics
+
+  Arguments:
+    This                  - Protocol instance pointer.
+    ExtendedVerification  - Driver may perform diagnostics on reset.
+
+  Returns:
+    EFI_SUCCESS           - The device was reset.
+    EFI_DEVICE_ERROR      - The device is not functioning properly and could
+                            not be reset.
+
+--*/
+;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_READ_KEY_EX) (
+  IN  struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *This,
+  OUT EFI_KEY_DATA                      *KeyData
+  )
+/*++
+
+  Routine Description:
+    Reads the next keystroke from the input device. The WaitForKey Event can
+    be used to test for existance of a keystroke via WaitForEvent () call.
+
+  Arguments:
+    This       - Protocol instance pointer.
+    KeyData    - A pointer to a buffer that is filled in with the keystroke
+                 state data for the key that was pressed.
+
+  Returns:
+    EFI_SUCCESS           - The keystroke information was returned.
+    EFI_NOT_READY         - There was no keystroke data availiable.
+    EFI_DEVICE_ERROR      - The keystroke information was not returned due to
+                            hardware errors.
+    EFI_INVALID_PARAMETER - KeyData is NULL.
+--*/
+;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_STATE) (
+  IN struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
+  IN EFI_KEY_TOGGLE_STATE               *KeyToggleState
+  )
+/*++
+
+  Routine Description:
+    Set certain state for the input device.
+
+  Arguments:
+    This              - Protocol instance pointer.
+    KeyToggleState    - A pointer to the EFI_KEY_TOGGLE_STATE to set the
+                        state for the input device.
+
+  Returns:
+    EFI_SUCCESS           - The device state was set successfully.
+    EFI_DEVICE_ERROR      - The device is not functioning correctly and could
+                            not have the setting adjusted.
+    EFI_UNSUPPORTED       - The device does not have the ability to set its state.
+    EFI_INVALID_PARAMETER - KeyToggleState is NULL.
+
+--*/
+;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_KEYSTROKE_NOTIFY) (
+  IN struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
+  IN EFI_KEY_DATA                       *KeyData,
+  IN EFI_KEY_NOTIFY_FUNCTION            KeyNotificationFunction,
+  OUT EFI_HANDLE                        *NotifyHandle
+  )
+/*++
+
+  Routine Description:
+    Register a notification function for a particular keystroke for the input device.
+
+  Arguments:
+    This                    - Protocol instance pointer.
+    KeyData                 - A pointer to a buffer that is filled in with the keystroke
+                              information data for the key that was pressed.
+    KeyNotificationFunction - Points to the function to be called when the key
+                              sequence is typed specified by KeyData.
+    NotifyHandle            - Points to the unique handle assigned to the registered notification.
+
+  Returns:
+    EFI_SUCCESS             - The notification function was registered successfully.
+    EFI_OUT_OF_RESOURCES    - Unable to allocate resources for necesssary data structures.
+    EFI_INVALID_PARAMETER   - KeyData or NotifyHandle is NULL.
+
+--*/
+;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UNREGISTER_KEYSTROKE_NOTIFY) (
+  IN struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL  *This,
+  IN EFI_HANDLE                         NotificationHandle
+  )
+/*++
+
+  Routine Description:
+    Remove a registered notification function from a particular keystroke.
+
+  Arguments:
+    This                    - Protocol instance pointer.
+    NotificationHandle      - The handle of the notification function being unregistered.
+
+  Returns:
+    EFI_SUCCESS             - The notification function was unregistered successfully.
+    EFI_INVALID_PARAMETER   - The NotificationHandle is invalid.
+    EFI_NOT_FOUND           - Can not find the matching entry in database.
+
+--*/
+;
+
+typedef struct _EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL {
+  EFI_INPUT_RESET_EX                    Reset;
+  EFI_INPUT_READ_KEY_EX                 ReadKeyStrokeEx;
+  EFI_EVENT                             WaitForKeyEx;
+  EFI_SET_STATE                         SetState;
+  EFI_REGISTER_KEYSTROKE_NOTIFY         RegisterKeyNotify;
+  EFI_UNREGISTER_KEYSTROKE_NOTIFY       UnregisterKeyNotify;
+} EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL;
+
 #endif
diff --git a/usr/src/boot/sys/boot/efi/libefi/Makefile.com b/usr/src/boot/sys/boot/efi/libefi/Makefile.com
index 1c5a91b664..4ba5dbf537 100644
--- a/usr/src/boot/sys/boot/efi/libefi/Makefile.com
+++ b/usr/src/boot/sys/boot/efi/libefi/Makefile.com
@@ -31,13 +31,17 @@ SRCS +=	delay.c \
 	efizfs.c \
 	env.c \
 	errno.c \
+	gfx_fb.c \
 	handles.c \
 	libefi.c \
+	pnglite.c \
 	wchar.c
 
 OBJS=	$(SRCS:%.c=%.o)
 
-CPPFLAGS= -D_STANDALONE
+PNGLITE=$(SRC)/common/pnglite
+
+CPPFLAGS= -D_STANDALONE -DEFI
 CFLAGS  = -Os
 
 CPPFLAGS += -nostdinc -I. -I../../../../../include -I../../../..
@@ -47,13 +51,17 @@ CPPFLAGS += -I../../include/$(MACHINE)
 CPPFLAGS += -I../../../../../lib/libstand
 CPPFLAGS += -I../../../zfs
 CPPFLAGS += -I../../../../cddl/boot/zfs
+CPPFLAGS += -I../../../../../lib/libz
+CPPFLAGS += -I$(PNGLITE)
 
 # Pick up the bootstrap header for some interface items
 CPPFLAGS += -I../../../common
-CPPFLAGS += -DTERM_EMU
 
 include ../../Makefile.inc
 
+# For multiboot2.h, must be last, to avoid conflicts
+CPPFLAGS +=	-I$(SRC)/uts/common
+
 libefi.a: $(OBJS)
 	$(AR) $(ARFLAGS) $@ $(OBJS)
 
@@ -71,3 +79,9 @@ x86:
 
 %.o:	../%.c
 	$(COMPILE.c) $<
+
+%.o:	../../../common/%.c
+	$(COMPILE.c) $<
+
+%.o:	$(PNGLITE)/%.c
+	$(COMPILE.c) $<
diff --git a/usr/src/boot/sys/boot/efi/libefi/efi_console.c b/usr/src/boot/sys/boot/efi/libefi/efi_console.c
index 2f504431f3..d17ee134a6 100644
--- a/usr/src/boot/sys/boot/efi/libefi/efi_console.c
+++ b/usr/src/boot/sys/boot/efi/libefi/efi_console.c
@@ -28,469 +28,535 @@
 
 #include <efi.h>
 #include <efilib.h>
+#include <sys/tem_impl.h>
+#include <sys/multiboot2.h>
+#include <machine/metadata.h>
+#include <gfx_fb.h>
 
 #include "bootstrap.h"
 
+struct efi_fb		efifb;
+EFI_GRAPHICS_OUTPUT	*gop;
+EFI_UGA_DRAW_PROTOCOL	*uga;
+
+static EFI_GUID ccontrol_protocol_guid = EFI_CONSOLE_CONTROL_PROTOCOL_GUID;
+static EFI_CONSOLE_CONTROL_PROTOCOL	*console_control;
+static EFI_GUID simple_input_ex_guid = EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID;
+static EFI_CONSOLE_CONTROL_SCREEN_MODE	console_mode;
 static SIMPLE_TEXT_OUTPUT_INTERFACE	*conout;
-static SIMPLE_INPUT_INTERFACE		*conin;
 
-#ifdef TERM_EMU
-#define	DEFAULT_FGCOLOR	EFI_LIGHTGRAY
-#define	DEFAULT_BGCOLOR	EFI_BLACK
+/* mode change callback and argument from tem */
+static vis_modechg_cb_t modechg_cb;
+static struct vis_modechg_arg *modechg_arg;
+static tem_vt_state_t tem;
+
+struct efi_console_data {
+	struct visual_ops			*ecd_visual_ops;
+	SIMPLE_INPUT_INTERFACE			*ecd_conin;
+	EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL	*ecd_coninex;
+};
 
-#define	MAXARGS	8
 #define	KEYBUFSZ 10
 static unsigned keybuf[KEYBUFSZ];      /* keybuf for extended codes */
+
 static int key_pending;
 
-static int args[MAXARGS], argc;
-static int fg_c, bg_c;
-static UINTN curx, cury;
-static int esc;
+static const unsigned char solaris_color_to_efi_color[16] = {
+	EFI_WHITE,
+	EFI_BLACK,
+	EFI_BLUE,
+	EFI_GREEN,
+	EFI_CYAN,
+	EFI_RED,
+	EFI_MAGENTA,
+	EFI_BROWN,
+	EFI_LIGHTGRAY,
+	EFI_DARKGRAY,
+	EFI_LIGHTBLUE,
+	EFI_LIGHTGREEN,
+	EFI_LIGHTCYAN,
+	EFI_LIGHTRED,
+	EFI_LIGHTMAGENTA,
+	EFI_YELLOW
+};
 
-void get_pos(UINTN *x, UINTN *y);
-void curs_move(UINTN *_x, UINTN *_y, UINTN x, UINTN y);
-static void CL(int);
-void HO(void);
-void end_term(void);
-#endif
+#define	DEFAULT_FGCOLOR	EFI_LIGHTGRAY
+#define	DEFAULT_BGCOLOR	EFI_BLACK
+
+extern int efi_find_framebuffer(struct efi_fb *efifb);
 
+static void efi_framebuffer_setup(void);
 static void efi_cons_probe(struct console *);
 static int efi_cons_init(struct console *, int);
-void efi_cons_putchar(struct console *, int);
-int efi_cons_getchar(struct console *);
-void efi_cons_efiputchar(int);
-int efi_cons_poll(struct console *);
+static void efi_cons_putchar(struct console *, int);
+static void efi_cons_efiputchar(int);
+static int efi_cons_getchar(struct console *);
+static int efi_cons_poll(struct console *);
+static int efi_cons_ioctl(struct console *cp, int cmd, void *data);
+
+static int efi_fb_devinit(struct vis_devinit *);
+static void efi_cons_cursor(struct vis_conscursor *);
+
+static int efi_text_devinit(struct vis_devinit *);
+static int efi_text_cons_clear(struct vis_consclear *);
+static void efi_text_cons_copy(struct vis_conscopy *);
+static void efi_text_cons_display(struct vis_consdisplay *);
 
 struct console efi_console = {
-	"text",
-	"EFI console",
-	C_WIDEOUT,
-	efi_cons_probe,
-	efi_cons_init,
-	efi_cons_putchar,
-	efi_cons_getchar,
-	efi_cons_poll,
-	0
+	.c_name = "text",
+	.c_desc = "EFI console",
+	.c_flags = C_WIDEOUT,
+	.c_probe = efi_cons_probe,
+	.c_init = efi_cons_init,
+	.c_out = efi_cons_putchar,
+	.c_in = efi_cons_getchar,
+	.c_ready = efi_cons_poll,
+	.c_ioctl = efi_cons_ioctl,
+	.c_private = NULL
 };
 
-#ifdef	TERM_EMU
+static struct vis_identifier fb_ident = { "efi_fb" };
+static struct vis_identifier text_ident = { "efi_text" };
+
+struct visual_ops fb_ops = {
+	.ident = &fb_ident,
+	.kdsetmode = NULL,
+	.devinit = efi_fb_devinit,
+	.cons_copy = NULL,
+	.cons_display = NULL,
+	.cons_cursor = efi_cons_cursor,
+	.cons_clear = NULL,
+	.cons_put_cmap = NULL
+};
 
-/* Get cursor position. */
-void
-get_pos(UINTN *x, UINTN *y)
+struct visual_ops text_ops = {
+	.ident = &text_ident,
+	.kdsetmode = NULL,
+	.devinit = efi_text_devinit,
+	.cons_copy = efi_text_cons_copy,
+	.cons_display = efi_text_cons_display,
+	.cons_cursor = efi_cons_cursor,
+	.cons_clear = efi_text_cons_clear,
+	.cons_put_cmap = NULL
+};
+
+/*
+ * platform specific functions for tem
+ */
+int
+plat_stdout_is_framebuffer(void)
 {
-	*x = conout->Mode->CursorColumn;
-	*y = conout->Mode->CursorRow;
+	return (console_mode == EfiConsoleControlScreenGraphics);
 }
 
-/* Move cursor to x rows and y cols (0-based). */
 void
-curs_move(UINTN *_x, UINTN *_y, UINTN x, UINTN y)
+plat_tem_hide_prom_cursor(void)
 {
-	conout->SetCursorPosition(conout, x, y);
-	if (_x != NULL)
-		*_x = conout->Mode->CursorColumn;
-	if (_y != NULL)
-		*_y = conout->Mode->CursorRow;
+	conout->EnableCursor(conout, FALSE);
+}
+
+static void
+plat_tem_display_prom_cursor(screen_pos_t row, screen_pos_t col)
+{
+
+	conout->SetCursorPosition(conout, col, row);
+	conout->EnableCursor(conout, TRUE);
 }
 
-/* Clear internal state of the terminal emulation code. */
 void
-end_term(void)
+plat_tem_get_prom_pos(uint32_t *row, uint32_t *col)
 {
-	esc = 0;
-	argc = -1;
+	if (console_mode == EfiConsoleControlScreenText) {
+		*col = (uint32_t)conout->Mode->CursorColumn;
+		*row = (uint32_t)conout->Mode->CursorRow;
+	} else {
+		*col = 0;
+		*row = 0;
+	}
 }
 
-#endif
+/*
+ * plat_tem_get_prom_size() is supposed to return screen size
+ * in chars. Return real data for text mode and TEM defaults for graphical
+ * mode, so the tem can compute values based on default and font.
+ */
+void
+plat_tem_get_prom_size(size_t *height, size_t *width)
+{
+	UINTN cols, rows;
+	if (console_mode == EfiConsoleControlScreenText) {
+		(void) conout->QueryMode(conout, conout->Mode->Mode,
+		    &cols, &rows);
+		*height = (size_t)rows;
+		*width = (size_t)cols;
+	} else {
+		*height = TEM_DEFAULT_ROWS;
+		*width = TEM_DEFAULT_COLS;
+	}
+}
 
-static void
-efi_cons_probe(struct console *cp)
+/*
+ * Callback to notify about console mode change.
+ * mode is value from enum EFI_CONSOLE_CONTROL_SCREEN_MODE.
+ */
+void
+plat_cons_update_mode(int mode)
 {
-	conout = ST->ConOut;
-	conin = ST->ConIn;
-	cp->c_flags |= C_PRESENTIN | C_PRESENTOUT;
+	UINTN cols, rows;
+	struct vis_devinit devinit;
+	struct efi_console_data *ecd = efi_console.c_private;
+
+	/* Make sure we have usable console. */
+	if (efi_find_framebuffer(&efifb)) {
+		console_mode = EfiConsoleControlScreenText;
+	} else {
+		efi_framebuffer_setup();
+		if (mode != -1 && console_mode != mode)
+			console_mode = mode;
+	}
+
+	if (console_control != NULL)
+		(void)console_control->SetMode(console_control, console_mode);
+
+	/* some firmware enables the cursor when switching modes */
+	conout->EnableCursor(conout, FALSE);
+	if (console_mode == EfiConsoleControlScreenText) {
+		(void)conout->QueryMode(conout, conout->Mode->Mode,
+		    &cols, &rows);
+		devinit.version = VIS_CONS_REV;
+		devinit.width = cols;
+		devinit.height = rows;
+		devinit.depth = 4;
+		devinit.linebytes = cols;
+		devinit.color_map = NULL;
+		devinit.mode = VIS_TEXT;
+		ecd->ecd_visual_ops = &text_ops;
+	} else {
+		devinit.version = VIS_CONS_REV;
+		devinit.width = gfx_fb.framebuffer_common.framebuffer_width;
+		devinit.height = gfx_fb.framebuffer_common.framebuffer_height;
+		devinit.depth = gfx_fb.framebuffer_common.framebuffer_bpp;
+		devinit.linebytes = gfx_fb.framebuffer_common.framebuffer_pitch;
+		devinit.color_map = gfx_fb_color_map;
+		devinit.mode = VIS_PIXEL;
+		ecd->ecd_visual_ops = &fb_ops;
+	}
+
+	modechg_cb(modechg_arg, &devinit);
 }
 
 static int
-efi_cons_init(struct console *cp __attribute((unused)),
-    int arg __attribute((unused)))
+efi_fb_devinit(struct vis_devinit *data)
 {
-	conout->SetAttribute(conout, EFI_TEXT_ATTR(DEFAULT_FGCOLOR,
-	    DEFAULT_BGCOLOR));
-#ifdef TERM_EMU
-	end_term();
-	get_pos(&curx, &cury);
-	curs_move(&curx, &cury, curx, cury);
-	fg_c = DEFAULT_FGCOLOR;
-	bg_c = DEFAULT_BGCOLOR;
-	memset(keybuf, 0, KEYBUFSZ);
-#endif
-	conout->EnableCursor(conout, TRUE);
-	return 0;
+	if (console_mode != EfiConsoleControlScreenGraphics)
+		return (1);
+
+	data->version = VIS_CONS_REV;
+	data->width = gfx_fb.framebuffer_common.framebuffer_width;
+	data->height = gfx_fb.framebuffer_common.framebuffer_height;
+	data->depth = gfx_fb.framebuffer_common.framebuffer_bpp;
+	data->linebytes = gfx_fb.framebuffer_common.framebuffer_pitch;
+	data->color_map = gfx_fb_color_map;
+	data->mode = VIS_PIXEL;
+
+	modechg_cb = data->modechg_cb;
+	modechg_arg = data->modechg_arg;
+
+	return (0);
 }
 
-static void
-efi_cons_rawputchar(int c)
+static int
+efi_text_devinit(struct vis_devinit *data)
 {
-	int i;
-	UINTN x, y;
-	conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
-	static int ignorenl = 0;
-
-	if (c == '\t')
-		/* XXX lame tab expansion */
-		for (i = 0; i < 8; i++)
-			efi_cons_rawputchar(' ');
-	else {
-#ifndef	TERM_EMU
-		if (c == '\n')
-			efi_cons_efiputchar('\r');
-		else
-			efi_cons_efiputchar(c);
-#else
-		switch (c) {
-		case '\r':
-			curx = 0;
-			break;
-		case '\n':
-			if (ignorenl)
-				ignorenl = 0;
-			else
-				cury++;
-			if ((efi_console.c_flags & C_MODERAW) == 0)
-				curx = 0;
-			if (cury >= y) {
-				efi_cons_efiputchar('\n');
-				cury--;
-			}
-			break;
-		case '\b':
-			if (curx > 0)
-				curx--;
-			break;
-		default:
-			if (curx > x) {
-				curx = 0;
-				cury++;
-				curs_move(&curx, &cury, curx, cury);
-			}
-			if ((efi_console.c_flags & C_MODERAW) == 0) {
-				if (cury > y-1) {
-					curx = 0;
-					efi_cons_efiputchar('\n');
-					cury--;
-					curs_move(&curx, &cury, curx, cury);
-				}
-			}
-			efi_cons_efiputchar(c);
-			curx++;
-			if ((efi_console.c_flags & C_MODERAW) == 0) {
-				if (curx == x) {
-					curx = 0;
-					ignorenl = 1;
-				}
-			} else if (curx == x) {
-				curx = 0;
-				if (cury == y)
-					efi_cons_efiputchar('\n');
-				else
-					cury++;
-			}
-		}
-		curs_move(&curx, &cury, curx, cury);
-#endif
-	}
+	UINTN cols, rows;
+
+	if (console_mode != EfiConsoleControlScreenText)
+		return (1);
+
+	(void)conout->QueryMode(conout, conout->Mode->Mode, &cols, &rows);
+	data->version = VIS_CONS_REV;
+	data->width = cols;
+	data->height = rows;
+	data->depth = 4;
+	data->linebytes = cols;
+	data->color_map = NULL;
+	data->mode = VIS_TEXT;
+
+	modechg_cb = data->modechg_cb;
+	modechg_arg = data->modechg_arg;
+
+	return (0);
 }
 
-/* Gracefully exit ESC-sequence processing in case of misunderstanding. */
-static void
-bail_out(int c)
+static int
+efi_text_cons_clear(struct vis_consclear *ca)
 {
-	char buf[16], *ch;
-	int i;
+	EFI_STATUS st;
+	UINTN attr = conout->Mode->Attribute & 0x0F;
 
-	if (esc) {
-		efi_cons_rawputchar('\033');
-		if (esc != '\033')
-			efi_cons_rawputchar(esc);
-		for (i = 0; i <= argc; ++i) {
-			sprintf(buf, "%d", args[i]);
-			ch = buf;
-			while (*ch)
-				efi_cons_rawputchar(*ch++);
-		}
-	}
-	efi_cons_rawputchar(c);
-	end_term();
+	attr = EFI_TEXT_ATTR(attr,
+	    solaris_color_to_efi_color[ca->bg_color & 0xF]);
+	st = conout->SetAttribute(conout, attr);
+	if (EFI_ERROR(st))
+		return (1);
+	st = conout->ClearScreen(conout);
+	if (EFI_ERROR(st))
+		return (1);
+	return (0);
 }
 
-/* Clear display from current position to end of screen. */
 static void
-CD(void) {
-	UINTN i, x, y;
+efi_text_cons_copy(struct vis_conscopy *ma)
+{
+	UINTN col, row;
 
-	get_pos(&curx, &cury);
-	if (curx == 0 && cury == 0) {
-		conout->ClearScreen(conout);
-		end_term();
-		return;
-	}
+	col = 0;
+	row = ma->e_row;
+	conout->SetCursorPosition(conout, col, row);
 
-	conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
-	CL(0);  /* clear current line from cursor to end */
-	for (i = cury + 1; i < y-1; i++) {
-		curs_move(NULL, NULL, 0, i);
-		CL(0);
-	}
-	curs_move(NULL, NULL, curx, cury);
-	end_term();
+	efi_cons_efiputchar('\n');
 }
 
-/*
- * Absolute cursor move to args[0] rows and args[1] columns
- * (the coordinates are 1-based).
- */
 static void
-CM(void)
+efi_text_cons_display(struct vis_consdisplay *da)
 {
-	if (args[0] > 0)
-		args[0]--;
-	if (args[1] > 0)
-		args[1]--;
-	curs_move(&curx, &cury, args[1], args[0]);
-	end_term();
-}
+	EFI_STATUS st;
+	UINTN attr;
+	UINTN row, col;
+	tem_char_t *data;
+	int i;
 
-/* Home cursor (left top corner), also called from mode command. */
-void
-HO(void)
-{
-	argc = 1;
-	args[0] = args[1] = 1;
-	CM();
+	(void)conout->QueryMode(conout, conout->Mode->Mode, &col, &row);
+
+	/* reduce clear line on bottom row by one to prevent autoscroll */
+	if (row - 1 == da->row && da->col == 0 && da->width == col)
+		da->width--;
+
+	data = (tem_char_t *)da->data;
+	attr = EFI_TEXT_ATTR(solaris_color_to_efi_color[da->fg_color & 0xf],
+	    solaris_color_to_efi_color[da->bg_color & 0xf]);
+	st = conout->SetAttribute(conout, attr);
+	if (EFI_ERROR(st))
+		return;
+	row = da->row;
+	col = da->col;
+	conout->SetCursorPosition(conout, col, row);
+	for (i = 0; i < da->width; i++)
+		efi_cons_efiputchar(data[i]);
 }
 
-/* Clear line from current position to end of line */
-static void
-CL(int direction)
+static void efi_cons_cursor(struct vis_conscursor *cc)
 {
-	int i, len;
-	UINTN x, y;
-	CHAR16 *line;
-
-	conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
-	switch (direction) {
-	case 0:         /* from cursor to end */
-		len = x - curx + 1;
+	switch (cc->action) {
+	case VIS_HIDE_CURSOR:
+		if (plat_stdout_is_framebuffer())
+			gfx_fb_display_cursor(cc);
+		else
+			plat_tem_hide_prom_cursor();
 		break;
-	case 1:         /* from beginning to cursor */
-		len = curx;
+	case VIS_DISPLAY_CURSOR:
+		if (plat_stdout_is_framebuffer())
+			gfx_fb_display_cursor(cc);
+		else
+			plat_tem_display_prom_cursor(cc->row, cc->col);
 		break;
-	case 2:         /* entire line */
-	default:
-		len = x;
+	case VIS_GET_CURSOR: {	/* only used at startup */
+		uint32_t row, col;
+
+		plat_tem_get_prom_pos(&row, &col);
+		cc->row = row;
+		cc->col = col;
+		}
 		break;
 	}
+}
 
-	if (cury == y - 1)
-		len--;
+static int
+efi_cons_ioctl(struct console *cp, int cmd, void *data)
+{
+	struct efi_console_data *ecd = cp->c_private;
+	struct visual_ops *ops = ecd->ecd_visual_ops;
 
-	line = malloc(len * sizeof (CHAR16));
-	if (line == NULL) {
-		printf("out of memory\n");
-		return;
+	switch (cmd) {
+	case VIS_GETIDENTIFIER:
+		memmove(data, ops->ident, sizeof (struct vis_identifier));
+		break;
+	case VIS_DEVINIT:
+		return (ops->devinit(data));
+	case VIS_CONSCLEAR:
+		return (ops->cons_clear(data));
+	case VIS_CONSCOPY:
+		ops->cons_copy(data);
+		break;
+	case VIS_CONSDISPLAY:
+		ops->cons_display(data);
+		break;
+	case VIS_CONSCURSOR:
+		ops->cons_cursor(data);
+		break;
+	default:
+		return (EINVAL);
 	}
-	for (i = 0; i < len; i++)
-		line[i] = ' ';
-	line[len-1] = 0;
-
-	if (direction != 0)
-		curs_move(NULL, NULL, 0, cury);
-
-	conout->OutputString(conout, line);
-	/* restore cursor position */
-	curs_move(NULL, NULL, curx, cury);
-	free(line);
-	end_term();
+	return (0);
 }
 
 static void
-get_arg(int c)
+efi_framebuffer_setup(void)
 {
-	if (argc < 0)
-		argc = 0;
-	args[argc] *= 10;
-	args[argc] += c - '0';
+	int bpp, pos;
+
+	bpp = fls(efifb.fb_mask_red | efifb.fb_mask_green |
+	    efifb.fb_mask_blue | efifb.fb_mask_reserved);
+
+	gfx_fb.framebuffer_common.mb_type = MULTIBOOT_TAG_TYPE_FRAMEBUFFER;
+	gfx_fb.framebuffer_common.mb_size = sizeof (gfx_fb);
+	gfx_fb.framebuffer_common.framebuffer_addr = efifb.fb_addr;
+	gfx_fb.framebuffer_common.framebuffer_width = efifb.fb_width;
+	gfx_fb.framebuffer_common.framebuffer_height = efifb.fb_height;
+	gfx_fb.framebuffer_common.framebuffer_bpp = bpp;
+	gfx_fb.framebuffer_common.framebuffer_pitch =
+	    efifb.fb_stride * (bpp >> 3);
+	gfx_fb.framebuffer_common.framebuffer_type =
+	    MULTIBOOT_FRAMEBUFFER_TYPE_RGB;
+	gfx_fb.framebuffer_common.mb_reserved = 0;
+
+	pos = ffs(efifb.fb_mask_red);
+	if (pos != 0)
+		pos--;
+	gfx_fb.u.fb2.framebuffer_red_mask_size = fls(efifb.fb_mask_red >> pos);
+	gfx_fb.u.fb2.framebuffer_red_field_position = pos;
+	pos = ffs(efifb.fb_mask_green);
+	if (pos != 0)
+		pos--;
+	gfx_fb.u.fb2.framebuffer_green_mask_size =
+	    fls(efifb.fb_mask_green >> pos);
+	gfx_fb.u.fb2.framebuffer_green_field_position = pos;
+	pos = ffs(efifb.fb_mask_blue);
+	if (pos != 0)
+		pos--;
+	gfx_fb.u.fb2.framebuffer_blue_mask_size =
+	    fls(efifb.fb_mask_blue >> pos);
+	gfx_fb.u.fb2.framebuffer_blue_field_position = pos;
 }
 
-/* Emulate basic capabilities of sun-color terminal */
 static void
-efi_term_emu(int c)
+efi_cons_probe(struct console *cp)
 {
-	static int ansi_col[] = {
-		0, 4, 2, 6, 1, 5, 3, 7
-	};
-	int t, i;
-
-	switch (esc) {
-	case 0:
-		switch (c) {
-		case '\033':
-			esc = c;
-			break;
-		default:
-			efi_cons_rawputchar(c);
-			break;
-		}
-		break;
-	case '\033':
-		switch (c) {
-		case '[':
-			esc = c;
-			args[0] = 0;
-			argc = -1;
-			break;
-		default:
-			bail_out(c);
-			break;
-		}
-		break;
-	case '[':
-		switch (c) {
-		case ';':
-			if (argc < 0)
-				argc = 0;
-			else if (argc + 1 >= MAXARGS)
-				bail_out(c);
-			else
-				args[++argc] = 0;
-			break;
-		case 'A':		/* UP = \E[%dA */
-			if (argc == 0) {
-				UINTN x, y;
-				get_pos(&x, &y);
-				args[1] = x + 1;
-				args[0] = y - args[0] + 1;
-				CM();
-			} else
-				bail_out(c);
-			break;
-		case 'B':		/* DO = \E[%dB */
-			if (argc == 0) {
-				UINTN x, y;
-				get_pos(&x, &y);
-				args[1] = x + 1;
-				args[0] = y + args[0] + 1;
-				CM();
-			} else
-				bail_out(c);
-			break;
-		case 'C':		/* RI = \E[%dC */
-			if (argc == 0) {
-				UINTN x, y;
-				get_pos(&x, &y);
-				args[1] = args[0] + 1;
-				args[0] = y + 1;
-				CM();
-			} else
-				bail_out(c);
-			break;
-		case 'H':		/* ho = \E[H */
-			if (argc < 0)
-				HO();
-			else if (argc == 1)
-				CM();
-			else
-				bail_out(c);
-			break;
-		case 'J':               /* cd = \E[J */
-			if (argc < 0)
-				CD();
-			else
-				bail_out(c);
-			break;
-		case 'K':
-			if (argc < 0)
-				CL(0);
-			else if (argc == 0)
-				switch (args[0]) {
-				case 0:
-				case 1:
-				case 2:
-					CL(args[0]);
-				break;
-				default:
-					bail_out(c);
-				}
-			else
-				bail_out(c);
-			break;
-		case 'm':
-			if (argc < 0) {
-				fg_c = DEFAULT_FGCOLOR;
-				bg_c = DEFAULT_BGCOLOR;
-			}
-			for (i = 0; i <= argc; ++i) {
-				switch (args[i]) {
-				case 0:         /* back to normal */
-					fg_c = DEFAULT_FGCOLOR;
-					bg_c = DEFAULT_BGCOLOR;
-					break;
-				case 1:         /* bold */
-					fg_c |= 0x8;
-					break;
-				case 4:         /* underline */
-				case 5:         /* blink */
-					bg_c |= 0x8;
-					break;
-				case 7:         /* reverse */
-					t = fg_c;
-					fg_c = bg_c;
-					bg_c = t;
-					break;
-				case 30: case 31: case 32: case 33:
-				case 34: case 35: case 36: case 37:
-					fg_c = ansi_col[args[i] - 30];
-					break;
-				case 39:        /* normal */
-					fg_c = DEFAULT_FGCOLOR;
-					break;
-				case 40: case 41: case 42: case 43:
-				case 44: case 45: case 46: case 47:
-					bg_c = ansi_col[args[i] - 40];
-					break;
-				case 49:        /* normal */
-					bg_c = DEFAULT_BGCOLOR;
-					break;
-				}
-			}
-			conout->SetAttribute(conout, EFI_TEXT_ATTR(fg_c, bg_c));
-			end_term();
-			break;
-		default:
-			if (isdigit(c))
-				get_arg(c);
-			else
-				bail_out(c);
-			break;
+	struct efi_console_data *ecd;
+	EFI_STATUS status;
+	UINTN i, max_dim, best_mode, cols, rows;
+
+	ecd = calloc(1, sizeof (*ecd));
+	/*
+	 * As console probing is called very early, the only reason for
+	 * out of memory can be that we just do not have enough memory.
+	 */
+	if (ecd == NULL)
+		panic("efi_cons_probe: This system has not enough memory\n");
+	cp->c_private = ecd;
+
+	conout = ST->ConOut;
+	ecd->ecd_conin = ST->ConIn;
+	cp->c_flags |= C_PRESENTIN | C_PRESENTOUT;
+
+	status = BS->LocateProtocol(&ccontrol_protocol_guid, NULL,
+	    (VOID **)&console_control);
+	if (status == EFI_SUCCESS) {
+		BOOLEAN GopUgaExists, StdInLocked;
+		status = console_control->GetMode(console_control,
+		    &console_mode, &GopUgaExists, &StdInLocked);
+	} else {
+		console_mode = EfiConsoleControlScreenText;
+	}
+
+	max_dim = best_mode = 0;
+	for (i = 0; i <= conout->Mode->MaxMode ; i++) {
+		status = conout->QueryMode(conout, i, &cols, &rows);
+		if (EFI_ERROR(status))
+			continue;
+		if (cols * rows > max_dim) {
+			max_dim = cols * rows;
+			best_mode = i;
 		}
-		break;
-	default:
-		bail_out(c);
-		break;
 	}
+	if (max_dim > 0)
+		conout->SetMode(conout, best_mode);
+	status = conout->QueryMode(conout, best_mode, &cols, &rows);
+	if (EFI_ERROR(status)) {
+		setenv("screen-#rows", "24", 1);
+		setenv("screen-#cols", "80", 1);
+	} else {
+		char env[8];
+		snprintf(env, sizeof (env), "%u", (unsigned)rows);
+		setenv("screen-#rows", env, 1);
+		snprintf(env, sizeof (env), "%u", (unsigned)cols);
+		setenv("screen-#cols", env, 1);
+	}
+
+	if (efi_find_framebuffer(&efifb)) {
+		console_mode = EfiConsoleControlScreenText;
+		ecd->ecd_visual_ops = &text_ops;
+	} else {
+		efi_framebuffer_setup();
+		console_mode = EfiConsoleControlScreenGraphics;
+		ecd->ecd_visual_ops = &fb_ops;
+	}
+
+	if (console_control != NULL)
+		(void)console_control->SetMode(console_control, console_mode);
+
+	/* some firmware enables the cursor when switching modes */
+	conout->EnableCursor(conout, FALSE);
 }
 
-void
-efi_cons_putchar(struct console *cp __attribute((unused)), int c)
+static int
+efi_cons_init(struct console *cp, int arg __unused)
 {
-#ifdef TERM_EMU
-	efi_term_emu(c);
-#else
-	efi_cons_rawputchar(c);
-#endif
+	struct efi_console_data *ecd;
+	void *coninex;
+	EFI_STATUS status;
+	int rc;
+
+	conout->SetAttribute(conout, EFI_TEXT_ATTR(DEFAULT_FGCOLOR,
+	    DEFAULT_BGCOLOR));
+	memset(keybuf, 0, KEYBUFSZ);
+
+	ecd = cp->c_private;
+	coninex = NULL;
+	/*
+	 * Try to set up for SimpleTextInputEx protocol. If not available,
+	 * we will use SimpleTextInput protocol.
+	 */
+	status = BS->OpenProtocol(ST->ConsoleInHandle, &simple_input_ex_guid,
+	    &coninex, IH, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	if (status == EFI_SUCCESS)
+		ecd->ecd_coninex = coninex;
+
+	gfx_framework_init(&fb_ops);
+	rc = tem_info_init(cp);
+
+	if (rc == 0 && tem == NULL) {
+		tem = tem_init();
+		if (tem != NULL)
+			tem_activate(tem, B_TRUE);
+	}
+
+	if (tem == NULL)
+		panic("Failed to set up console terminal");
+
+	return (0);
+}
+
+static void
+efi_cons_putchar(struct console *cp __unused, int c)
+{
+	uint8_t buf = c;
+
+	/* make sure we have some console output, support for panic() */
+	if (tem == NULL)
+		efi_cons_efiputchar(c);
+	else
+		tem_write(tem, &buf, sizeof (buf));
 }
 
 static int
@@ -560,7 +626,7 @@ keybuf_inschar(EFI_INPUT_KEY *key)
 }
 
 static bool
-efi_readkey(void)
+efi_readkey(SIMPLE_INPUT_INTERFACE *conin)
 {
 	EFI_STATUS status;
 	EFI_INPUT_KEY key;
@@ -573,37 +639,97 @@ efi_readkey(void)
 	return (false);
 }
 
-int
-efi_cons_getchar(struct console *cp __attribute((unused)))
+static bool
+efi_readkey_ex(EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *coninex)
 {
+	EFI_STATUS status;
+	EFI_INPUT_KEY *kp;
+	EFI_KEY_DATA  key_data;
+	uint32_t kss;
+
+	status = coninex->ReadKeyStrokeEx(coninex, &key_data);
+	if (status == EFI_SUCCESS) {
+		kss = key_data.KeyState.KeyShiftState;
+		kp = &key_data.Key;
+		if (kss & EFI_SHIFT_STATE_VALID) {
+
+			/*
+			 * quick mapping to control chars, replace with
+			 * map lookup later.
+			 */
+			if (kss & EFI_RIGHT_CONTROL_PRESSED ||
+			    kss & EFI_LEFT_CONTROL_PRESSED) {
+				if (kp->UnicodeChar >= 'a' &&
+				    kp->UnicodeChar <= 'z') {
+					kp->UnicodeChar -= 'a';
+					kp->UnicodeChar++;
+				}
+			}
+		}
+
+		keybuf_inschar(kp);
+		return (true);
+	}
+	return (false);
+}
+
+static int
+efi_cons_getchar(struct console *cp)
+{
+	struct efi_console_data *ecd;
 	int c;
 
 	if ((c = keybuf_getchar()) != 0)
 		return (c);
 
+	ecd = cp->c_private;
 	key_pending = 0;
 
-	if (efi_readkey())
-		return (keybuf_getchar());
+	if (ecd->ecd_coninex == NULL) {
+		if (efi_readkey(ecd->ecd_conin))
+			return (keybuf_getchar());
+	} else {
+		if (efi_readkey_ex(ecd->ecd_coninex))
+			return (keybuf_getchar());
+	}
 
 	return (-1);
 }
 
-int
-efi_cons_poll(struct console *cp __attribute((unused)))
+static int
+efi_cons_poll(struct console *cp)
 {
+	struct efi_console_data *ecd;
+	EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *coninex;
+	SIMPLE_INPUT_INTERFACE *conin;
+	EFI_STATUS status;
+
 	if (keybuf_ischar() || key_pending)
 		return (1);
 
+	ecd = cp->c_private;
+	coninex = ecd->ecd_coninex;
+	conin = ecd->ecd_conin;
 	/*
 	 * Some EFI implementation (u-boot for example) do not support
 	 * WaitForKey().
 	 * CheckEvent() can clear the signaled state.
 	 */
-	if (conin->WaitForKey == NULL)
-		key_pending = efi_readkey();
-	else
-		key_pending = BS->CheckEvent(conin->WaitForKey) == EFI_SUCCESS;
+	if (coninex != NULL) {
+		if (coninex->WaitForKeyEx == NULL)
+			key_pending = efi_readkey_ex(coninex);
+		else {
+			status = BS->CheckEvent(coninex->WaitForKeyEx);
+			key_pending = status == EFI_SUCCESS;
+		}
+	} else {
+		if (conin->WaitForKey == NULL)
+			key_pending = efi_readkey(conin);
+		else {
+			status = BS->CheckEvent(conin->WaitForKey);
+			key_pending = status == EFI_SUCCESS;
+		}
+	}
 
 	return (key_pending);
 }
@@ -613,31 +739,13 @@ void
 efi_cons_efiputchar(int c)
 {
 	CHAR16 buf[2];
+	EFI_STATUS status;
 
-	/*
-	 * translate box chars to unicode
-	 */
-	switch (c) {
-	/* single frame */
-	case 0xb3: buf[0] = BOXDRAW_VERTICAL; break;
-	case 0xbf: buf[0] = BOXDRAW_DOWN_LEFT; break;
-	case 0xc0: buf[0] = BOXDRAW_UP_RIGHT; break;
-	case 0xc4: buf[0] = BOXDRAW_HORIZONTAL; break;
-	case 0xda: buf[0] = BOXDRAW_DOWN_RIGHT; break;
-	case 0xd9: buf[0] = BOXDRAW_UP_LEFT; break;
-
-	/* double frame */
-	case 0xba: buf[0] = BOXDRAW_DOUBLE_VERTICAL; break;
-	case 0xbb: buf[0] = BOXDRAW_DOUBLE_DOWN_LEFT; break;
-	case 0xbc: buf[0] = BOXDRAW_DOUBLE_UP_LEFT; break;
-	case 0xc8: buf[0] = BOXDRAW_DOUBLE_UP_RIGHT; break;
-	case 0xc9: buf[0] = BOXDRAW_DOUBLE_DOWN_RIGHT; break;
-	case 0xcd: buf[0] = BOXDRAW_DOUBLE_HORIZONTAL; break;
-
-	default:
-		buf[0] = c;
-	}
+	buf[0] = c;
         buf[1] = 0;     /* terminate string */
 
+	status = conout->TestString(conout, buf);
+	if (EFI_ERROR(status))
+		buf[0] = '?';
 	conout->OutputString(conout, buf);
 }
diff --git a/usr/src/boot/sys/boot/efi/loader/Makefile.com b/usr/src/boot/sys/boot/efi/loader/Makefile.com
index 7674305b5c..74099f45d9 100644
--- a/usr/src/boot/sys/boot/efi/loader/Makefile.com
+++ b/usr/src/boot/sys/boot/efi/loader/Makefile.com
@@ -15,6 +15,7 @@
 
 include $(SRC)/Makefile.master
 include $(SRC)/boot/Makefile.version
+include $(SRC)/boot/sys/boot/Makefile.inc
 
 CC=		$(GNUC_ROOT)/bin/gcc
 LD=		$(GNU_ROOT)/bin/gld
@@ -23,35 +24,47 @@ OBJDUMP=	$(GNU_ROOT)/bin/gobjdump
 
 PROG=		loader.sym
 
+PNGLITE=	$(SRC)/common/pnglite
+
 # architecture-specific loader code
-SRCS=	acpi.c \
+SRCS=	\
+	acpi.c \
 	autoload.c \
 	bootinfo.c \
 	conf.c \
 	copy.c \
 	efi_main.c \
+	font.c \
+	$(FONT).c \
 	framebuffer.c \
+	list.c \
 	main.c \
 	memmap.c \
 	multiboot.S \
 	multiboot2.c \
 	self_reloc.c \
 	smbios.c \
+	tem.c \
 	vers.c
 
-OBJS=	acpi.o \
+OBJS=	\
+	acpi.o \
 	autoload.o \
 	bootinfo.o \
 	conf.o \
 	copy.o \
 	efi_main.o \
+	font.o \
+	$(FONT).o \
 	framebuffer.o \
+	list.o \
 	main.o \
 	memmap.o \
 	multiboot.o \
 	multiboot2.o \
 	self_reloc.o \
 	smbios.o \
+	tem.o \
 	vers.o
 
 CFLAGS=	-Os
@@ -71,8 +84,8 @@ CPPFLAGS +=	-I../../../i386/libi386
 CPPFLAGS +=	-I../../../zfs
 CPPFLAGS +=	-I../../../../cddl/boot/zfs
 CPPFLAGS +=	-I$(SRC)/uts/intel/sys/acpi
-CPPFLAGS +=	-DEFI_ZFS_BOOT
-CPPFLAGS +=	-DNO_PCI -DEFI -DTERM_EMU
+CPPFLAGS +=	-I$(PNGLITE)
+CPPFLAGS +=	-DNO_PCI -DEFI
 
 # Export serial numbers, UUID, and asset tag from loader.
 smbios.o := CPPFLAGS += -DSMBIOS_SERIAL_NUMBERS
@@ -109,7 +122,8 @@ LDFLAGS =	-nostdlib --eh-frame-hdr
 LDFLAGS +=	-shared --hash-style=both --enable-new-dtags
 LDFLAGS +=	-T$(LDSCRIPT) -Bsymbolic
 
-CLEANFILES=	loader.sym loader.bin vers.c
+CLEANFILES=	loader.sym loader.bin
+CLEANFILES +=	$(FONT).c vers.c
 
 NEWVERSWHAT=	"EFI loader" $(MACHINE)
 
@@ -180,8 +194,11 @@ clean clobber:
 %.o: $(SRC)/common/list/%.c
 	$(COMPILE.c) -DNDEBUG $<
 
-%.o: $(SRC)/uts/common/io/font/%.c
+%.o: $(SRC)/common/font/%.c
 	$(COMPILE.c) $<
 
+$(FONT).c: $(FONT_DIR)/$(FONT_SRC)
+	$(VTFONTCVT) -f compressed-source -o $@ $(FONT_DIR)/$(FONT_SRC)
+
 $(ROOT_BOOT)/%: %
 	$(INS.file)
diff --git a/usr/src/boot/sys/boot/efi/loader/comconsole.c b/usr/src/boot/sys/boot/efi/loader/comconsole.c
index 8bcce95e0b..c46971eeda 100644
--- a/usr/src/boot/sys/boot/efi/loader/comconsole.c
+++ b/usr/src/boot/sys/boot/efi/loader/comconsole.c
@@ -58,6 +58,7 @@ static int	comc_init(struct console *, int);
 static void	comc_putchar(struct console *, int);
 static int	comc_getchar(struct console *);
 static int	comc_ischar(struct console *);
+static int	comc_ioctl(struct console *, int, void *);
 static void	comc_setup(struct console *);
 static char	*comc_asprint_mode(struct serial *);
 static int	comc_parse_mode(struct serial *, const char *);
@@ -74,6 +75,7 @@ struct console ttya = {
 	.c_out = comc_putchar,
 	.c_in = comc_getchar,
 	.c_ready = comc_ischar,
+	.c_ioctl = comc_ioctl,
 	.c_private = NULL
 };
 
@@ -86,6 +88,7 @@ struct console ttyb = {
 	.c_out = comc_putchar,
 	.c_in = comc_getchar,
 	.c_ready = comc_ischar,
+	.c_ioctl = comc_ioctl,
 	.c_private = NULL
 };
 
@@ -98,6 +101,7 @@ struct console ttyc = {
 	.c_out = comc_putchar,
 	.c_in = comc_getchar,
 	.c_ready = comc_ischar,
+	.c_ioctl = comc_ioctl,
 	.c_private = NULL
 };
 
@@ -110,6 +114,7 @@ struct console ttyd = {
 	.c_out = comc_putchar,
 	.c_in = comc_getchar,
 	.c_ready = comc_ischar,
+	.c_ioctl = comc_ioctl,
 	.c_private = NULL
 };
 
@@ -307,6 +312,12 @@ comc_ischar(struct console *cp)
 	return (!(control & EFI_SERIAL_INPUT_BUFFER_EMPTY));
 }
 
+static int
+comc_ioctl(struct console *cp __unused, int cmd __unused, void *data __unused)
+{
+	return (ENOTTY);
+}
+
 static char *
 comc_asprint_mode(struct serial *sp)
 {
diff --git a/usr/src/boot/sys/boot/efi/loader/efi_main.c b/usr/src/boot/sys/boot/efi/loader/efi_main.c
index 86917da147..c65be09057 100644
--- a/usr/src/boot/sys/boot/efi/loader/efi_main.c
+++ b/usr/src/boot/sys/boot/efi/loader/efi_main.c
@@ -27,7 +27,6 @@
 #include <sys/cdefs.h>
 
 #include <efi.h>
-#include <eficonsctl.h>
 #include <efilib.h>
 #include <stand.h>
 
@@ -71,14 +70,9 @@ EFI_STATUS
 efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *system_table)
 {
 	static EFI_GUID image_protocol = LOADED_IMAGE_PROTOCOL;
-	static EFI_GUID console_control_protocol =
-	    EFI_CONSOLE_CONTROL_PROTOCOL_GUID;
-	EFI_CONSOLE_CONTROL_PROTOCOL *console_control = NULL;
 	EFI_LOADED_IMAGE *img;
 	CHAR16 *argp, *args, **argv;
 	EFI_STATUS status;
-	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
-	UINTN i, max_dim, best_mode, cols, rows;
 	int argc, addprog;
 
 	IH = image_handle;
@@ -86,26 +80,6 @@ efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *system_table)
 	BS = ST->BootServices;
 	RS = ST->RuntimeServices;
 
-	status = BS->LocateProtocol(&console_control_protocol, NULL,
-	    (VOID **)&console_control);
-	if (status == EFI_SUCCESS)
-		(void)console_control->SetMode(console_control,
-		    EfiConsoleControlScreenText);
-
-	conout = ST->ConOut;
-	max_dim = best_mode = 0;
-	for (i = 0; i <= conout->Mode->MaxMode ; i++) {
-		status = conout->QueryMode(conout, i, &cols, &rows);
-		if (EFI_ERROR(status))
-			continue;
-		if (cols * rows > max_dim) {
-			max_dim = cols * rows;
-			best_mode = i;
-		}
-	}
-	if (max_dim > 0)
-		conout->SetMode(conout, best_mode);
-
 	heapsize = 64 * 1024 * 1024;
 	/* 4GB upper limit, try to leave some space from 1MB */
 	heap = 0x0000000100000000;
@@ -116,18 +90,6 @@ efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *system_table)
 
 	setheap((void *)(uintptr_t)heap, (void *)(uintptr_t)(heap + heapsize));
 
-	status = conout->QueryMode(conout, best_mode, &cols, &rows);
-	if (EFI_ERROR(status)) {
-		setenv("LINES", "24", 1);
-		setenv("COLUMNS", "80", 1);
-	} else {
-		char buf[8];
-		snprintf(buf, sizeof (buf), "%u", (unsigned)rows);
-		setenv("LINES", buf, 1);
-		snprintf(buf, sizeof (buf), "%u", (unsigned)cols);
-		setenv("COLUMNS", buf, 1);
-	}
-
 	/* Use efi_exit() from here on... */
 
 	status = BS->HandleProtocol(IH, &image_protocol, (VOID**)&img);
diff --git a/usr/src/boot/sys/boot/efi/loader/framebuffer.c b/usr/src/boot/sys/boot/efi/loader/framebuffer.c
index 77d01dfb64..9428c8dba9 100644
--- a/usr/src/boot/sys/boot/efi/loader/framebuffer.c
+++ b/usr/src/boot/sys/boot/efi/loader/framebuffer.c
@@ -31,24 +31,36 @@
 #include <stand.h>
 #include <bootstrap.h>
 #include <sys/endian.h>
+#include <sys/consplat.h>
 
 #include <efi.h>
 #include <efilib.h>
 #include <efiuga.h>
 #include <efipciio.h>
+#include <Protocol/EdidActive.h>
+#include <Protocol/EdidDiscovered.h>
 #include <machine/metadata.h>
 
+#include "gfx_fb.h"
 #include "framebuffer.h"
 
 static EFI_GUID gop_guid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
 static EFI_GUID pciio_guid = EFI_PCI_IO_PROTOCOL_GUID;
 static EFI_GUID uga_guid = EFI_UGA_DRAW_PROTOCOL_GUID;
+static EFI_GUID active_edid_guid = EFI_EDID_ACTIVE_PROTOCOL_GUID;
+static EFI_GUID discovered_edid_guid = EFI_EDID_DISCOVERED_PROTOCOL_GUID;
 
-static u_int
+/* Saved initial GOP mode. */
+static uint32_t default_mode = (uint32_t)-1;
+
+static uint32_t gop_default_mode(void);
+static int efifb_set_mode(EFI_GRAPHICS_OUTPUT *, u_int);
+
+static uint_t
 efifb_color_depth(struct efi_fb *efifb)
 {
 	uint32_t mask;
-	u_int depth;
+	uint_t depth;
 
 	mask = efifb->fb_mask_red | efifb->fb_mask_green |
 	    efifb->fb_mask_blue | efifb->fb_mask_reserved;
@@ -105,6 +117,8 @@ efifb_from_gop(struct efi_fb *efifb, EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE *mode,
 	efifb->fb_stride = info->PixelsPerScanLine;
 	result = efifb_mask_from_pixfmt(efifb, info->PixelFormat,
 	    &info->PixelInformation);
+	if (efifb->fb_addr == 0)
+		result = 1;
 	return (result);
 }
 
@@ -421,19 +435,109 @@ efifb_from_uga(struct efi_fb *efifb, EFI_UGA_DRAW_PROTOCOL *uga)
 	 * frame buffer.
 	 */
 	efifb->fb_size = efifb->fb_height * efifb->fb_stride * 4;
+	if (efifb->fb_addr == 0)
+		return (1);
 	return (0);
 }
 
+/*
+ * Fetch EDID info. Caller must free the buffer.
+ */
+static struct vesa_edid_info *
+efifb_gop_get_edid(EFI_HANDLE gop)
+{
+	const uint8_t magic[] = EDID_MAGIC;
+	EFI_EDID_ACTIVE_PROTOCOL *edid;
+	struct vesa_edid_info *edid_info;
+	EFI_GUID *guid;
+	EFI_STATUS status;
+	size_t size;
+
+	edid_info = calloc(1, sizeof (*edid_info));
+	if (edid_info == NULL)
+		return (NULL);
+
+	guid = &active_edid_guid;
+	status = BS->OpenProtocol(gop, guid, (VOID **)&edid, IH, NULL,
+	    EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	if (status != EFI_SUCCESS) {
+		guid = &discovered_edid_guid;
+		status = BS->OpenProtocol(gop, guid, (VOID **)&edid, IH, NULL,
+		    EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	}
+	if (status != EFI_SUCCESS)
+		goto error;
+
+	size = edid->SizeOfEdid;
+	if (size > sizeof (*edid_info))
+		size = sizeof (*edid_info);
+
+	memcpy(edid_info, edid->Edid, size);
+	status = BS->CloseProtocol(gop, guid, IH, NULL);
+
+	/* Validate EDID */
+	if (memcmp(edid_info, magic, sizeof(magic)) != 0)
+		goto error;
+
+	if (edid_info->header.version == 1 &&
+	    (edid_info->display.supported_features
+	    & EDID_FEATURE_PREFERRED_TIMING_MODE) &&
+	    edid_info->detailed_timings[0].pixel_clock) {
+		return (edid_info);
+	}
+
+error:
+	free(edid_info);
+	return (NULL);
+}
+
+static int
+efifb_get_edid(UINT32 *pwidth, UINT32 *pheight)
+{
+	extern EFI_GRAPHICS_OUTPUT *gop;
+	struct vesa_edid_info *edid_info;
+	struct edid_detailed_timings *timings;
+	int rv = 1;
+
+	edid_info = efifb_gop_get_edid(gop);
+	if (edid_info != NULL) {
+		timings = edid_info->detailed_timings;
+		*pwidth = timings[0].horizontal_active_lo |
+		    (((int)(timings[0].horizontal_hi & 0xf0)) << 4);
+
+		*pheight = timings[0].vertical_active_lo |
+		    (((int)(timings[0].vertical_hi & 0xf0)) << 4);
+		rv = 0;
+	}
+	free(edid_info);
+	return (rv);
+}
+
 int
 efi_find_framebuffer(struct efi_fb *efifb)
 {
-	EFI_GRAPHICS_OUTPUT *gop;
-	EFI_UGA_DRAW_PROTOCOL *uga;
+	extern EFI_GRAPHICS_OUTPUT *gop;
+	extern EFI_UGA_DRAW_PROTOCOL *uga;
 	EFI_STATUS status;
+	uint32_t mode;
+
+	if (gop != NULL)
+		return (efifb_from_gop(efifb, gop->Mode, gop->Mode->Info));
 
 	status = BS->LocateProtocol(&gop_guid, NULL, (VOID **)&gop);
-	if (status == EFI_SUCCESS)
+	if (status == EFI_SUCCESS) {
+		/* Save default mode. */
+		if (default_mode == (uint32_t)-1) {
+			default_mode = gop->Mode->Mode;
+		}
+		mode = gop_default_mode();
+		if (mode != gop->Mode->Mode)
+			efifb_set_mode(gop, mode);
 		return (efifb_from_gop(efifb, gop->Mode, gop->Mode->Info));
+	}
+
+	if (uga != NULL)
+		return (efifb_from_uga(efifb, uga));
 
 	status = BS->LocateProtocol(&uga_guid, NULL, (VOID **)&uga);
 	if (status == EFI_SUCCESS)
@@ -445,89 +549,264 @@ efi_find_framebuffer(struct efi_fb *efifb)
 static void
 print_efifb(int mode, struct efi_fb *efifb, int verbose)
 {
-	u_int depth;
+	uint_t depth;
+	UINT32 width, height;
+
+	if (verbose == 1) {
+		printf("Framebuffer mode: %s\n",
+		    plat_stdout_is_framebuffer() ? "on" : "off");
+		if (efifb_get_edid(&width, &height) == 0)
+			printf("EDID mode: %dx%d\n\n", width, height);
+	}
 
-	if (mode >= 0)
+	if (mode >= 0) {
+		if (verbose == 1)
+			printf("GOP ");
 		printf("mode %d: ", mode);
+	}
 	depth = efifb_color_depth(efifb);
-	printf("%ux%ux%u, stride=%u", efifb->fb_width, efifb->fb_height,
-	    depth, efifb->fb_stride);
+	printf("%ux%ux%u", efifb->fb_width, efifb->fb_height, depth);
+	if (verbose)
+		printf(", stride=%u", efifb->fb_stride);
 	if (verbose) {
 		printf("\n    frame buffer: address=%jx, size=%jx",
 		    (uintmax_t)efifb->fb_addr, (uintmax_t)efifb->fb_size);
 		printf("\n    color mask: R=%08x, G=%08x, B=%08x\n",
 		    efifb->fb_mask_red, efifb->fb_mask_green,
 		    efifb->fb_mask_blue);
+		if (efifb->fb_addr == 0) {
+			printf("Warning: this mode is not implementing the "
+			    "linear framebuffer. The illumos\n\tconsole is "
+			    "not available with this mode and will default to "
+			    "ttya\n");
+		}
 	}
 }
 
-COMMAND_SET(gop, "gop", "graphics output protocol", command_gop);
+static int
+efifb_set_mode(EFI_GRAPHICS_OUTPUT *gop, u_int mode)
+{
+	EFI_STATUS status;
+
+	status = gop->SetMode(gop, mode);
+	if (EFI_ERROR(status)) {
+		snprintf(command_errbuf, sizeof (command_errbuf),
+		    "Unable to set mode to %u (error=%lu)",
+		    mode, EFI_ERROR_CODE(status));
+		return (CMD_ERROR);
+	}
+	return (CMD_OK);
+}
+
+/*
+ * Verify existance of mode number or find mode by
+ * dimensions. If depth is not given, walk values 32, 24, 16, 8.
+ * Return MaxMode if mode is not found.
+ */
+static int
+efifb_find_mode_xydm(UINT32 x, UINT32 y, int depth, int m)
+{
+	extern EFI_GRAPHICS_OUTPUT *gop;
+	EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
+	EFI_STATUS status;
+	UINTN infosz;
+	struct efi_fb fb;
+	UINT32 mode;
+        uint_t d, i;
+
+        if (m != -1)
+                i = 8;
+        else if (depth == -1)
+                i = 32;
+        else
+                i = depth;
+
+        while (i > 0) {
+		for (mode = 0; mode < gop->Mode->MaxMode; mode++) {
+			status = gop->QueryMode(gop, mode, &infosz, &info);
+			if (EFI_ERROR(status))
+				continue;
+
+			if (m != -1) {
+				if ((UINT32)m == mode)
+					return (mode);
+				else
+					continue;
+			}
+
+			efifb_from_gop(&fb, gop->Mode, info);
+			d = efifb_color_depth(&fb);
+			if (x == fb.fb_width && y == fb.fb_height && d == i)
+				return (mode);
+		}
+
+		if (depth != -1)
+			break;
+
+		i -= 8;
+	}
+
+	return (gop->Mode->MaxMode);
+}
+
+static int
+efifb_find_mode(char *str)
+{
+	extern EFI_GRAPHICS_OUTPUT *gop;
+	int x, y, depth;
+
+	if (!gfx_parse_mode_str(str, &x, &y, &depth))
+		return (gop->Mode->MaxMode);
+
+	return (efifb_find_mode_xydm(x, y, depth, -1));
+}
+
+/*
+ * gop_default_mode(). Try to set mode based on EDID.
+ */
+static uint32_t
+gop_default_mode(void)
+{
+	extern EFI_GRAPHICS_OUTPUT *gop;
+	UINT32 mode, width = 0, height = 0;
+
+	mode = gop->Mode->MaxMode;
+	if (efifb_get_edid(&width, &height) == 0)
+		mode = efifb_find_mode_xydm(width, height, -1, -1);
+
+	if (mode == gop->Mode->MaxMode)
+		mode = default_mode;
+
+	return (mode);
+}
+
+COMMAND_SET(framebuffer, "framebuffer", "framebuffer mode management",
+    command_gop);
 
 static int
 command_gop(int argc, char *argv[])
 {
-	struct efi_fb efifb;
-	EFI_GRAPHICS_OUTPUT *gop;
+	extern struct efi_fb efifb;
+	extern EFI_GRAPHICS_OUTPUT *gop;
+	struct efi_fb fb;
 	EFI_STATUS status;
+	char *arg, *cp;
 	u_int mode;
 
-	status = BS->LocateProtocol(&gop_guid, NULL, (VOID **)&gop);
-	if (EFI_ERROR(status)) {
+	if (gop == NULL) {
 		snprintf(command_errbuf, sizeof (command_errbuf),
-		    "%s: Graphics Output Protocol not present (error=%lu)",
-		    argv[0], EFI_ERROR_CODE(status));
+		    "%s: Graphics Output Protocol not present", argv[0]);
 		return (CMD_ERROR);
 	}
 
 	if (argc < 2)
 		goto usage;
 
+	/*
+	 * Note we can not turn the GOP itself off, but instead we instruct
+	 * tem to use text mode.
+	 */
+	if (strcmp(argv[1], "off") == 0) {
+		if (argc != 2)
+			goto usage;
+
+		plat_cons_update_mode(EfiConsoleControlScreenText);
+		return (CMD_OK);
+	}
+
+	/*
+	 * Set GOP to use default mode, then notify tem.
+	 */
+	if (strcmp(argv[1], "on") == 0) {
+		if (argc != 2)
+			goto usage;
+
+		mode = gop_default_mode();
+		if (mode != gop->Mode->Mode)
+			efifb_set_mode(gop, mode);
+
+		plat_cons_update_mode(EfiConsoleControlScreenGraphics);
+		return (CMD_OK);
+	}
+
 	if (!strcmp(argv[1], "set")) {
-		char *cp;
+		int rv;
 
 		if (argc != 3)
 			goto usage;
-		mode = strtol(argv[2], &cp, 0);
-		if (cp[0] != '\0') {
-			sprintf(command_errbuf, "mode is an integer");
-			return (CMD_ERROR);
-		}
-		status = gop->SetMode(gop, mode);
-		if (EFI_ERROR(status)) {
-			snprintf(command_errbuf, sizeof (command_errbuf),
-			    "%s: Unable to set mode to %u (error=%lu)",
-			    argv[0], mode, EFI_ERROR_CODE(status));
-			return (CMD_ERROR);
+
+		arg = argv[2];
+		if (strchr(arg, 'x') == NULL) {
+			errno = 0;
+			mode = strtoul(arg, &cp, 0);
+			if (errno != 0 || *arg == '\0' || cp[0] != '\0') {
+				snprintf(command_errbuf,
+				    sizeof (command_errbuf),
+				    "mode should be an integer");
+				return (CMD_ERROR);
+			}
+			mode = efifb_find_mode_xydm(0, 0, 0, mode);
+		} else {
+			mode = efifb_find_mode(arg);
 		}
-	} else if (!strcmp(argv[1], "get")) {
+
+		if (mode == gop->Mode->MaxMode)
+			mode = gop->Mode->Mode;
+
+		rv = efifb_set_mode(gop, mode);
+		plat_cons_update_mode(EfiConsoleControlScreenGraphics);
+		return (rv);
+	}
+
+	if (!strcmp(argv[1], "get")) {
 		if (argc != 2)
 			goto usage;
-		efifb_from_gop(&efifb, gop->Mode, gop->Mode->Info);
+
 		print_efifb(gop->Mode->Mode, &efifb, 1);
 		printf("\n");
-	} else if (!strcmp(argv[1], "list")) {
+		return (CMD_OK);
+	}
+
+	if (!strcmp(argv[1], "list")) {
 		EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info;
 		UINTN infosz;
+		int depth, d = -1;
 
-		if (argc != 2)
+		if (argc != 2 && argc != 3)
 			goto usage;
+
+		if (argc == 3) {
+			arg = argv[2];
+			errno = 0;
+			d = strtoul(arg, &cp, 0);
+			if (errno != 0 || *arg == '\0' || cp[0] != '\0') {
+				snprintf(command_errbuf,
+				    sizeof (command_errbuf),
+				    "depth should be an integer");
+				return (CMD_ERROR);
+			}
+		}
 		pager_open();
 		for (mode = 0; mode < gop->Mode->MaxMode; mode++) {
 			status = gop->QueryMode(gop, mode, &infosz, &info);
 			if (EFI_ERROR(status))
 				continue;
-			efifb_from_gop(&efifb, gop->Mode, info);
-			print_efifb(mode, &efifb, 0);
+			efifb_from_gop(&fb, gop->Mode, info);
+			depth = efifb_color_depth(&fb);
+			if (d != -1 && d != depth)
+				continue;
+			print_efifb(mode, &fb, 0);
 			if (pager_output("\n"))
 				break;
 		}
 		pager_close();
+		return (CMD_OK);
 	}
-	return (CMD_OK);
 
- usage:
+usage:
 	snprintf(command_errbuf, sizeof (command_errbuf),
-	    "usage: %s [list | get | set <mode>]", argv[0]);
+	    "usage: %s on | off | get | list [depth] | "
+	    "set <display or GOP mode number>", argv[0]);
 	return (CMD_ERROR);
 }
 
@@ -536,22 +815,19 @@ COMMAND_SET(uga, "uga", "universal graphics adapter", command_uga);
 static int
 command_uga(int argc, char *argv[])
 {
-	struct efi_fb efifb;
-	EFI_UGA_DRAW_PROTOCOL *uga;
-	EFI_STATUS status;
+	extern struct efi_fb efifb;
+	extern EFI_UGA_DRAW_PROTOCOL *uga;
 
-	status = BS->LocateProtocol(&uga_guid, NULL, (VOID **)&uga);
-	if (EFI_ERROR(status)) {
+	if (uga == NULL) {
 		snprintf(command_errbuf, sizeof (command_errbuf),
-		    "%s: UGA Protocol not present (error=%lu)",
-		    argv[0], EFI_ERROR_CODE(status));
+		    "%s: UGA Protocol not present", argv[0]);
 		return (CMD_ERROR);
 	}
 
 	if (argc != 1)
 		goto usage;
 
-	if (efifb_from_uga(&efifb, uga) != CMD_OK) {
+	if (efifb.fb_addr == 0) {
 		snprintf(command_errbuf, sizeof (command_errbuf),
 		    "%s: Unable to get UGA information", argv[0]);
 		return (CMD_ERROR);
diff --git a/usr/src/boot/sys/boot/efi/loader/main.c b/usr/src/boot/sys/boot/efi/loader/main.c
index dabde127b1..0f5ff21018 100644
--- a/usr/src/boot/sys/boot/efi/loader/main.c
+++ b/usr/src/boot/sys/boot/efi/loader/main.c
@@ -31,6 +31,7 @@
 #include <sys/param.h>
 #include <sys/reboot.h>
 #include <sys/boot.h>
+#include <sys/consplat.h>
 #include <stand.h>
 #include <inttypes.h>
 #include <string.h>
@@ -44,6 +45,7 @@
 #include <uuid.h>
 
 #include <bootstrap.h>
+#include <gfx_fb.h>
 #include <smbios.h>
 
 #include <libzfs.h>
@@ -682,6 +684,7 @@ main(int argc, CHAR16 *argv[])
 		if (!interactive_interrupt("Failed to find bootable partition"))
 			return (EFI_NOT_FOUND);
 
+	autoload_font();		/* Set up the font list for console. */
 	efi_init_environment();
 	setenv("ISADIR", "amd64", 1);	/* we only build 64bit */
 	bi_isadir();			/* set ISADIR */
@@ -846,10 +849,14 @@ command_mode(int argc, char *argv[])
 	unsigned int mode;
 	int i;
 	char *cp;
-	char rowenv[8];
 	EFI_STATUS status;
 	SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
-	extern void HO(void);
+	EFI_CONSOLE_CONTROL_SCREEN_MODE sm;
+
+	if (plat_stdout_is_framebuffer())
+		sm = EfiConsoleControlScreenGraphics;
+	else
+		sm = EfiConsoleControlScreenText;
 
 	conout = ST->ConOut;
 
@@ -869,11 +876,7 @@ command_mode(int argc, char *argv[])
 			printf("couldn't set mode %d\n", mode);
 			return (CMD_ERROR);
 		}
-		sprintf(rowenv, "%u", (unsigned)rows);
-		setenv("LINES", rowenv, 1);
-		sprintf(rowenv, "%u", (unsigned)cols);
-		setenv("COLUMNS", rowenv, 1);
-		HO();		/* set cursor */
+		plat_cons_update_mode(sm);
 		return (CMD_OK);
 	}
 
diff --git a/usr/src/boot/sys/boot/forth/Makefile.inc b/usr/src/boot/sys/boot/forth/Makefile.inc
index 43c109a6da..eb2576bd64 100644
--- a/usr/src/boot/sys/boot/forth/Makefile.inc
+++ b/usr/src/boot/sys/boot/forth/Makefile.inc
@@ -24,3 +24,4 @@ FORTH +=	screen.4th
 FORTH +=	shortcuts.4th
 FORTH +=	support.4th
 FORTH +=	version.4th
+FILES +=	illumos.png
diff --git a/usr/src/boot/sys/boot/forth/frames.4th b/usr/src/boot/sys/boot/forth/frames.4th
index db42f72d0b..a1d170f0e9 100644
--- a/usr/src/boot/sys/boot/forth/frames.4th
+++ b/usr/src/boot/sys/boot/forth/frames.4th
@@ -1,7 +1,7 @@
 \ Copyright (c) 2003 Scott Long <scottl@FreeBSD.org>
 \ Copyright (c) 2012-2015 Devin Teske <dteske@FreeBSD.org>
 \ All rights reserved.
-\ 
+\
 \ Redistribution and use in source and binary forms, with or without
 \ modification, are permitted provided that the following conditions
 \ are met:
@@ -10,7 +10,7 @@
 \ 2. Redistributions in binary form must reproduce the above copyright
 \    notice, this list of conditions and the following disclaimer in the
 \    documentation and/or other materials provided with the distribution.
-\ 
+\
 \ THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 \ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 \ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
@@ -22,7 +22,7 @@
 \ 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.
-\ 
+\
 
 marker task-frames.4th
 
@@ -46,32 +46,32 @@ variable fill
  43 constant ascii_plus
 
 \ Single frames
-196 constant sh_el
-179 constant sv_el
-218 constant slt_el
-192 constant slb_el
-191 constant srt_el
-217 constant srb_el
+$2500 constant sh_el
+$2502 constant sv_el
+$250c constant slt_el
+$2514 constant slb_el
+$2510 constant srt_el
+$2518 constant srb_el
 \ Double frames
-205 constant dh_el
-186 constant dv_el
-201 constant dlt_el
-200 constant dlb_el
-187 constant drt_el
-188 constant drb_el
+$2550 constant dh_el
+$2551 constant dv_el
+$2554 constant dlt_el
+$255a constant dlb_el
+$2557 constant drt_el
+$255d constant drb_el
 \ Fillings
 0 constant fill_none
 32 constant fill_blank
-176 constant fill_dark
-177 constant fill_med
-178 constant fill_bright
+$2591 constant fill_dark
+$2592 constant fill_med
+$2593 constant fill_bright
 
 only forth definitions also frame-drawing
 
 : hline	( len x y -- )	\ Draw horizontal single line
 	at-xy		\ move cursor
 	0 do
-		h_el @ emit
+		h_el @ xemit
 	loop
 ;
 
@@ -112,7 +112,7 @@ only forth definitions also frame-drawing
 	2dup 4 pick
 	0 do
 		at-xy
-		v_el @ emit
+		v_el @ xemit
 		1+
 		2dup
 	loop
@@ -120,6 +120,19 @@ only forth definitions also frame-drawing
 ;
 
 : box	( w h x y -- )	\ Draw a box
+	\ Do we have frame buffer?
+	s" screen-height" getenv
+	dup -1 <> if
+		2drop
+		rot		( w x y h )
+		over + >R	( w x y -- R: y+h )
+		swap rot	( y x w -- R: y+h )
+		over + >R	( y x -- R: y+h x+w )
+		swap R> R> term-drawrect
+		exit
+	else
+		drop
+	then
 	2dup 1+ 4 pick 1- -rot
 	vline		\ Draw left vert line
 	2dup 1+ swap 5 pick + swap 4 pick 1- -rot
@@ -128,10 +141,10 @@ only forth definitions also frame-drawing
 	hline		\ Draw top horiz line
 	2dup swap 1+ swap 4 pick + 5 pick 1- -rot
 	hline		\ Draw bottom horiz line
-	2dup at-xy lt_el @ emit	\ Draw left-top corner
-	2dup 4 pick + at-xy lb_el @ emit	\ Draw left bottom corner
-	2dup swap 5 pick + swap at-xy rt_el @ emit	\ Draw right top corner
-	2 pick + swap 3 pick + swap at-xy rb_el @ emit
+	2dup at-xy lt_el @ xemit	\ Draw left-top corner
+	2dup 4 pick + at-xy lb_el @ xemit	\ Draw left bottom corner
+	2dup swap 5 pick + swap at-xy rt_el @ xemit	\ Draw right top corner
+	2 pick + swap 3 pick + swap at-xy rb_el @ xemit
 	2drop
 ;
 
diff --git a/usr/src/boot/sys/boot/forth/illumos.png b/usr/src/boot/sys/boot/forth/illumos.png
new file mode 100644
index 0000000000..3af7a2f360
--- /dev/null
+++ b/usr/src/boot/sys/boot/forth/illumos.png
diff --git a/usr/src/boot/sys/boot/forth/logo-illumos.4th b/usr/src/boot/sys/boot/forth/logo-illumos.4th
index 77b28a683b..a527198094 100644
--- a/usr/src/boot/sys/boot/forth/logo-illumos.4th
+++ b/usr/src/boot/sys/boot/forth/logo-illumos.4th
@@ -2,7 +2,7 @@
 \ Copyright (c) 2003 Aleksander Fafula <alex@fafula.com>
 \ Copyright (c) 2006-2015 Devin Teske <dteske@FreeBSD.org>
 \ All rights reserved.
-\ 
+\
 \ Redistribution and use in source and binary forms, with or without
 \ modification, are permitted provided that the following conditions
 \ are met:
@@ -11,7 +11,7 @@
 \ 2. Redistributions in binary form must reproduce the above copyright
 \    notice, this list of conditions and the following disclaimer in the
 \    documentation and/or other materials provided with the distribution.
-\ 
+\
 \ THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 \ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 \ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
@@ -23,8 +23,7 @@
 \ 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.
-\ 
-\ $FreeBSD$
+\
 
 46 logoX ! 4 logoY ! \ Initialize logo placement defaults
 
@@ -37,6 +36,8 @@
 
 : logo ( x y -- ) \ color Illumos logo
 
+	s" /boot/illumos.png" fb-putimage if 2drop exit then
+
 	s"     @[33m,                             " logo+
 	s"    @[33m,./% @[31m&                         " logo+
 	s"    @[33m(****@[31m*(                        " logo+
diff --git a/usr/src/boot/sys/boot/i386/gptzfsboot/zfsboot.c b/usr/src/boot/sys/boot/i386/gptzfsboot/zfsboot.c
index 4238afe3e8..5d57d909ce 100644
--- a/usr/src/boot/sys/boot/i386/gptzfsboot/zfsboot.c
+++ b/usr/src/boot/sys/boot/i386/gptzfsboot/zfsboot.c
@@ -196,7 +196,7 @@ main(void)
 	env_nounset);
 
     /* Process configuration file */
-    setenv("LINES", "24", 1);
+    setenv("screen-#rows", "24", 1);
     auto_boot = 1;
 
     fd = open(PATH_CONFIG, O_RDONLY);
diff --git a/usr/src/boot/sys/boot/i386/libi386/Makefile b/usr/src/boot/sys/boot/i386/libi386/Makefile
index b2d8cca9ef..a5c52f2703 100644
--- a/usr/src/boot/sys/boot/i386/libi386/Makefile
+++ b/usr/src/boot/sys/boot/i386/libi386/Makefile
@@ -42,14 +42,21 @@ SRCS=	biosacpi.c biosdisk.c biosmem.c biospnp.c \
 	elf64_freebsd.c multiboot.c multiboot_tramp.S \
 	i386_copy.c i386_module.c nullconsole.c pxe.c pxetramp.s \
 	smbios.c time.c vidconsole.c amd64_tramp.S spinconsole.c linux.c \
-	relocater_tramp.S
+	relocater_tramp.S vgasubr.c vbe.c
 OBJS=	biosacpi.o biosdisk.o biosmem.o biospnp.o \
 	biospci.o biossmap.o bootinfo.o bootinfo32.o bootinfo64.o \
 	comconsole.o cpuid.o devicename.o elf32_freebsd.o \
 	elf64_freebsd.o multiboot.o multiboot_tramp.o \
 	i386_copy.o i386_module.o nullconsole.o pxe.o pxetramp.o \
 	smbios.o time.o vidconsole.o amd64_tramp.o spinconsole.o linux.o \
-	relocater_tramp.o
+	relocater_tramp.o vgasubr.o vbe.o
+
+COMMON=  ../../common
+PNGLITE=$(SRC)/common/pnglite
+VGASUBR=$(SRC)/common/vga
+CPPFLAGS += -I$(PNGLITE)
+SRCS +=	$(COMMON)/gfx_fb.c $(PNGLITE)/pnglite.c
+OBJS +=	gfx_fb.o pnglite.o
 
 LIBZFS=  ../../zfs
 SRCS +=	$(LIBZFS)/devicename_stubs.c
@@ -71,9 +78,6 @@ smbios.o := CFLAGS += -DSMBIOS_LITTLE_ENDIAN_UUID
 # Use network-endian UUID format for backward compatibility.
 #CFLAGS += -DSMBIOS_NETWORK_ENDIAN_UUID
 
-# Include simple terminal emulation (cons25-compatible)
-CFLAGS += -DTERM_EMU
-
 # XXX: make alloca() useable
 CFLAGS += -Dalloca=__builtin_alloca
 
@@ -116,3 +120,12 @@ libi386.a: $(OBJS)
 
 %.o:	$(LIBZFS)/%.c
 	$(COMPILE.c) -o $@ $<
+
+%.o:	$(COMMON)/%.c
+	$(COMPILE.c) -o $@ $<
+
+%.o:	$(PNGLITE)/%.c
+	$(COMPILE.c) -o $@ $<
+
+%.o:	$(VGASUBR)/%.c
+	$(COMPILE.c) -o $@ $<
diff --git a/usr/src/boot/sys/boot/i386/libi386/comconsole.c b/usr/src/boot/sys/boot/i386/libi386/comconsole.c
index a3d3e03f53..29ed725b89 100644
--- a/usr/src/boot/sys/boot/i386/libi386/comconsole.c
+++ b/usr/src/boot/sys/boot/i386/libi386/comconsole.c
@@ -73,6 +73,7 @@ static void	comc_putchar(struct console *, int);
 static int	comc_getchar(struct console *);
 static int	comc_getspeed(struct serial *);
 static int	comc_ischar(struct console *);
+static int	comc_ioctl(struct console *, int, void *);
 static uint32_t comc_parse_pcidev(const char *);
 static int	comc_pcidev_set(struct env_var *, int, const void *);
 static int	comc_pcidev_handle(struct console *, uint32_t);
@@ -92,6 +93,7 @@ struct console ttya = {
 	.c_out = comc_putchar,
 	.c_in = comc_getchar,
 	.c_ready = comc_ischar,
+	.c_ioctl = comc_ioctl,
 	.c_private = NULL
 };
 
@@ -104,6 +106,7 @@ struct console ttyb = {
 	.c_out = comc_putchar,
 	.c_in = comc_getchar,
 	.c_ready = comc_ischar,
+	.c_ioctl = comc_ioctl,
 	.c_private = NULL
 };
 
@@ -116,6 +119,7 @@ struct console ttyc = {
 	.c_out = comc_putchar,
 	.c_in = comc_getchar,
 	.c_ready = comc_ischar,
+	.c_ioctl = comc_ioctl,
 	.c_private = NULL
 };
 
@@ -128,6 +132,7 @@ struct console ttyd = {
 	.c_out = comc_putchar,
 	.c_in = comc_getchar,
 	.c_ready = comc_ischar,
+	.c_ioctl = comc_ioctl,
 	.c_private = NULL
 };
 
@@ -262,6 +267,12 @@ comc_ischar(struct console *cp)
     return (inb(sp->ioaddr + com_lsr) & LSR_RXRDY);
 }
 
+static int
+comc_ioctl(struct console *cp __unused, int cmd __unused, void *data __unused)
+{
+	return (ENOTTY);
+}
+
 static char *
 comc_asprint_mode(struct serial *sp)
 {
diff --git a/usr/src/boot/sys/boot/i386/libi386/linux.c b/usr/src/boot/sys/boot/i386/libi386/linux.c
index d69ac26a4e..685e1a1efc 100644
--- a/usr/src/boot/sys/boot/i386/libi386/linux.c
+++ b/usr/src/boot/sys/boot/i386/libi386/linux.c
@@ -27,6 +27,7 @@
 
 #include "linux.h"
 #include "bootstrap.h"
+#include "vbe.h"
 #include "libi386.h"
 #include "btxv86.h"
 
@@ -395,6 +396,8 @@ linux_exec(struct preloaded_file *fp)
 	relocator_a20_enabled = 1;
 	i386_copyin(relocater, 0x600, relocater_size);
 
+	/* Set VGA text mode */
+	bios_set_text_mode(3);
 	dev_cleanup();
 
 	__exec((void *)0x600);
diff --git a/usr/src/boot/sys/boot/i386/libi386/multiboot.c b/usr/src/boot/sys/boot/i386/libi386/multiboot.c
index 6ee6efc430..836b4907a5 100644
--- a/usr/src/boot/sys/boot/i386/libi386/multiboot.c
+++ b/usr/src/boot/sys/boot/i386/libi386/multiboot.c
@@ -50,6 +50,7 @@
 
 #include "bootstrap.h"
 #include <sys/multiboot.h>
+#include "vbe.h"
 #include "libzfs.h"
 #include "libi386.h"
 #include "../btx/lib/btxv86.h"
@@ -429,6 +430,9 @@ multiboot_exec(struct preloaded_file *fp)
 	free(cmdline);
 	cmdline = NULL;
 
+	/* make sure we have text mode */
+	bios_set_text_mode(VGA_TEXT_MODE);
+
 	dev_cleanup();
 	__exec((void *)VTOP(multiboot_tramp), MULTIBOOT_BOOTLOADER_MAGIC,
 	    (void *)entry, (void *)VTOP(mb_info));
diff --git a/usr/src/boot/sys/boot/i386/libi386/nullconsole.c b/usr/src/boot/sys/boot/i386/libi386/nullconsole.c
index bef9841ffd..8411d7d8d3 100644
--- a/usr/src/boot/sys/boot/i386/libi386/nullconsole.c
+++ b/usr/src/boot/sys/boot/i386/libi386/nullconsole.c
@@ -1,10 +1,10 @@
-/*-
+/*
  * nullconsole.c
  *
  * Author: Doug Ambrisko <ambrisko@whistle.com>
  * Copyright (c) 2000 Whistle Communications, Inc.
  * All rights reserved.
- * 
+ *
  * Subject to the following obligations and disclaimer of warranty, use and
  * redistribution of this software, in source or object code forms, with or
  * without modifications are expressly permitted by Whistle Communications;
@@ -15,7 +15,7 @@
  *    Communications, Inc. trademarks, including the mark "WHISTLE
  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
  *    such appears in the above copyright notice or in the software.
- * 
+ *
  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
@@ -55,6 +55,7 @@ struct console nullconsole = {
 	.c_out = nullc_putchar,
 	.c_in = nullc_getchar,
 	.c_ready = nullc_ischar,
+	.c_ioctl = NULL,
 	.c_private = NULL
 };
 
@@ -65,26 +66,24 @@ nullc_probe(struct console *cp)
 }
 
 static int
-nullc_init(struct console *cp __attribute((unused)),
-    int arg __attribute((unused)))
+nullc_init(struct console *cp __unused, int arg __unused)
 {
 	return(0);
 }
 
 static void
-nullc_putchar(struct console *cp __attribute((unused)),
-    int c __attribute((unused)))
+nullc_putchar(struct console *cp __unused, int c __unused)
 {
 }
 
 static int
-nullc_getchar(struct console *cp __attribute((unused)))
+nullc_getchar(struct console *cp __unused)
 {
 	return(-1);
 }
 
 static int
-nullc_ischar(struct console *cp __attribute((unused)))
+nullc_ischar(struct console *cp __unused)
 {
 	return(0);
 }
diff --git a/usr/src/boot/sys/boot/i386/libi386/spinconsole.c b/usr/src/boot/sys/boot/i386/libi386/spinconsole.c
index 47a85da493..ff59c7e49c 100644
--- a/usr/src/boot/sys/boot/i386/libi386/spinconsole.c
+++ b/usr/src/boot/sys/boot/i386/libi386/spinconsole.c
@@ -1,10 +1,10 @@
-/*-
+/*
  * spinconsole.c
  *
  * Author: Maksym Sobolyev <sobomax@sippysoft.com>
  * Copyright (c) 2009 Sippy Software, Inc.
  * All rights reserved.
- * 
+ *
  * Subject to the following obligations and disclaimer of warranty, use and
  * redistribution of this software, in source or object code forms, with or
  * without modifications are expressly permitted by Whistle Communications;
@@ -15,7 +15,7 @@
  *    Communications, Inc. trademarks, including the mark "WHISTLE
  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
  *    such appears in the above copyright notice or in the software.
- * 
+ *
  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
@@ -40,13 +40,6 @@
 #include <stand.h>
 #include <bootstrap.h>
 
-extern void get_pos(int *x, int *y);
-extern void curs_move(int *_x, int *_y, int x, int y);
-#if defined(EFI)
-extern void efi_cons_efiputchar(int c);
-#else
-extern void vidc_biosputchar(int c);
-#endif
 
 static void	spinc_probe(struct console *cp);
 static int	spinc_init(struct console *cp, int arg);
@@ -63,6 +56,7 @@ struct console spinconsole = {
 	.c_out = spinc_putchar,
 	.c_in = spinc_getchar,
 	.c_ready = spinc_ischar,
+	.c_ioctl = NULL,
 	.c_private = NULL
 };
 
@@ -73,48 +67,42 @@ spinc_probe(struct console *cp)
 }
 
 static int
-spinc_init(struct console *cp __attribute((unused)),
-    int arg __attribute((unused)))
+spinc_init(struct console *cp __unused, int arg __unused)
 {
 	return(0);
 }
 
 static void
-spinc_putchar(struct console *cp __attribute((unused)),
-    int c __attribute((unused)))
+spinc_putchar(struct console *cp __unused, int c __unused)
 {
-#ifdef TERM_EMU
-	static int curx, cury;
-#endif
 	static unsigned tw_chars = 0x5C2D2F7C;    /* "\-/|" */
 	static time_t lasttime;
+	int i;
 	time_t now;
 
 	now = time(NULL);
 	if (now < (lasttime + 1))
 		return;
 	lasttime = now;
-#ifdef TERM_EMU
-	get_pos(&curx, &cury);
-	if (curx > 0)
-		curs_move(&curx, &cury, curx - 1, cury);
-#endif
-#if defined(EFI)
-	efi_cons_efiputchar((char)tw_chars);
-#else
-	vidc_biosputchar((char)tw_chars);
-#endif
+	for (i = 0; consoles[i] != NULL; i++)
+		if (strcmp(consoles[i]->c_name, "text") == 0)
+			break;
+	if (consoles[i] == NULL)
+		return;
+
+	consoles[i]->c_out(consoles[i], (char)tw_chars);
+	consoles[i]->c_out(consoles[i], '\b');
 	tw_chars = (tw_chars >> 8) | ((tw_chars & (unsigned long)0xFF) << 24);
 }
 
 static int
-spinc_getchar(struct console *cp __attribute((unused)))
+spinc_getchar(struct console *cp __unused)
 {
 	return(-1);
 }
 
 static int
-spinc_ischar(struct console *cp __attribute((unused)))
+spinc_ischar(struct console *cp __unused)
 {
 	return(0);
 }
diff --git a/usr/src/boot/sys/boot/i386/libi386/vbe.c b/usr/src/boot/sys/boot/i386/libi386/vbe.c
new file mode 100644
index 0000000000..7b7bad9e57
--- /dev/null
+++ b/usr/src/boot/sys/boot/i386/libi386/vbe.c
@@ -0,0 +1,813 @@
+/*
+ * Copyright (c) 2009 Jared D. McNeill <jmcneill@invisible.ca>
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
+ */
+
+/*
+ * VESA BIOS Extensions routines
+ */
+
+#include <stand.h>
+#include <stdbool.h>
+#include <bootstrap.h>
+#include <machine/bootinfo.h>
+#include <machine/metadata.h>
+#include <sys/multiboot2.h>
+#include <btxv86.h>
+#include "libi386.h"
+#include "gfx_fb.h"	/* for EDID */
+#include "vbe.h"
+#include <sys/vgareg.h>
+#include <sys/vgasubr.h>
+
+multiboot_tag_vbe_t vbestate;
+static struct vbeinfoblock *vbe =
+    (struct vbeinfoblock *) &vbestate.vbe_control_info;
+static struct modeinfoblock *vbe_mode =
+    (struct modeinfoblock *) &vbestate.vbe_mode_info;
+multiboot_color_t cmap[16];
+
+/* Actually assuming mode 3. */
+void
+bios_set_text_mode(int mode)
+{
+	int atr;
+
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x10;
+	v86.eax = mode;				/* set VGA text mode */
+	v86int();
+	atr = vga_get_atr(VGA_REG_ADDR, VGA_ATR_MODE);
+	atr &= ~VGA_ATR_MODE_BLINK;
+	atr &= ~VGA_ATR_MODE_9WIDE;
+	vga_set_atr(VGA_REG_ADDR, VGA_ATR_MODE, atr);
+
+	vbestate.vbe_mode = 0;			/* vbe is disabled */
+	gfx_fb.framebuffer_common.framebuffer_type =
+	    MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT;
+	/* 16 bits per character */
+	gfx_fb.framebuffer_common.framebuffer_bpp = 16;
+	gfx_fb.framebuffer_common.framebuffer_addr =
+	    VGA_MEM_ADDR + VGA_COLOR_BASE;
+	gfx_fb.framebuffer_common.framebuffer_width = TEXT_COLS;
+	gfx_fb.framebuffer_common.framebuffer_height = TEXT_ROWS;
+	gfx_fb.framebuffer_common.framebuffer_pitch = TEXT_COLS * 2;
+}
+
+/* Function 00h - Return VBE Controller Information */
+static int
+biosvbe_info(struct vbeinfoblock *vbe)
+{
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x10;
+	v86.eax = 0x4f00;
+	v86.es = VTOPSEG(vbe);
+	v86.edi = VTOPOFF(vbe);
+	v86int();
+	return (v86.eax & 0xffff);
+}
+
+/* Function 01h - Return VBE Mode Information */
+static int
+biosvbe_get_mode_info(int mode, struct modeinfoblock *mi)
+{
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x10;
+	v86.eax = 0x4f01;
+	v86.ecx = mode;
+	v86.es = VTOPSEG(mi);
+	v86.edi = VTOPOFF(mi);
+	v86int();
+	return (v86.eax & 0xffff);
+}
+
+/* Function 02h - Set VBE Mode */
+static int
+biosvbe_set_mode(int mode, struct crtciinfoblock *ci)
+{
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x10;
+	v86.eax = 0x4f02;
+	v86.ebx = mode | 0x4000;	/* set linear FB bit */
+	v86.es = VTOPSEG(ci);
+	v86.edi = VTOPOFF(ci);
+	v86int();
+	return (v86.eax & 0xffff);
+}
+
+/* Function 03h - Get VBE Mode */
+static int
+biosvbe_get_mode(int *mode)
+{
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x10;
+	v86.eax = 0x4f03;
+	v86int();
+	*mode = v86.ebx & 0xffff;
+	return (v86.eax & 0xffff);
+}
+
+/* Function 08h - Set/Get DAC Palette Format */
+int
+biosvbe_palette_format(int *format)
+{
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x10;
+	v86.eax = 0x4f08;
+	v86.ebx = *format;
+	v86int();
+	*format = v86.ebx & 0xffff;
+	return (v86.eax & 0xffff);
+}
+
+/* Function 09h - Set/Get Palette Data */
+static int
+biosvbe_palette_data(int mode, int reg, struct paletteentry *pe)
+{
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x10;
+	v86.eax = 0x4f09;
+	v86.ebx = mode;
+	v86.edx = reg;
+	v86.ecx = 1;
+	v86.es = VTOPSEG(pe);
+	v86.edi = VTOPOFF(pe);
+	v86int();
+	return (v86.eax & 0xffff);
+}
+
+/*
+ * Function 15h BL=00h - Report VBE/DDC Capabilities
+ *
+ * int biosvbe_ddc_caps(void)
+ * return: VBE/DDC capabilities
+ */
+static int
+biosvbe_ddc_caps(void)
+{
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x10;
+	v86.eax = 0x4f15;	/* display identification extensions */
+	v86.ebx = 0;		/* report DDC capabilities */
+	v86.ecx = 0;		/* controller unit number (00h = primary) */
+	v86.es = 0;
+	v86.edi = 0;
+	v86int();
+	if (VBE_ERROR(v86.eax & 0xffff))
+		return (0);
+	return (v86.ebx & 0xffff);
+}
+
+/* Function 15h BL=01h - Read EDID */
+static int
+biosvbe_ddc_read_edid(int blockno, void *buf)
+{
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x10;
+	v86.eax = 0x4f15;	/* display identification extensions */
+	v86.ebx = 1;		/* read EDID */
+	v86.ecx = 0;		/* controller unit number (00h = primary) */
+	v86.edx = blockno;
+	v86.es = VTOPSEG(buf);
+	v86.edi = VTOPOFF(buf);
+	v86int();
+	return (v86.eax & 0xffff);
+}
+
+static int
+vbe_mode_is_supported(struct modeinfoblock *mi)
+{
+	if ((mi->ModeAttributes & 0x01) == 0)
+		return 0;	/* mode not supported by hardware */
+	if ((mi->ModeAttributes & 0x08) == 0)
+		return 0;	/* linear fb not available */
+	if ((mi->ModeAttributes & 0x10) == 0)
+		return 0;	/* text mode */
+	if (mi->NumberOfPlanes != 1)
+		return 0;	/* planar mode not supported */
+	if (mi->MemoryModel != 0x04 /* Packed pixel */ &&
+	    mi->MemoryModel != 0x06 /* Direct Color */)
+		return 0;	/* unsupported pixel format */
+	return 1;
+}
+
+static int
+vbe_check(void)
+{
+	if (vbestate.mb_type != MULTIBOOT_TAG_TYPE_VBE) {
+		printf("VBE not available\n");
+		return (0);
+	}
+	return (1);
+}
+
+void
+vbe_init(void)
+{
+	/* First set FB for text mode. */
+	gfx_fb.framebuffer_common.mb_type = MULTIBOOT_TAG_TYPE_FRAMEBUFFER;
+	gfx_fb.framebuffer_common.framebuffer_type =
+	    MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT;
+	/* 16 bits per character */
+	gfx_fb.framebuffer_common.framebuffer_bpp = 16;
+	gfx_fb.framebuffer_common.framebuffer_addr =
+	    VGA_MEM_ADDR + VGA_COLOR_BASE;
+	gfx_fb.framebuffer_common.framebuffer_width = TEXT_COLS;
+	gfx_fb.framebuffer_common.framebuffer_height = TEXT_ROWS;
+	gfx_fb.framebuffer_common.framebuffer_pitch = TEXT_COLS * 2;
+
+	/* Now check if we have vesa. */
+	memset(vbe, 0, sizeof(*vbe));
+	memcpy(vbe->VbeSignature, "VBE2", 4);
+	if (biosvbe_info(vbe) != VBE_SUCCESS)
+		return;
+	if (memcmp(vbe->VbeSignature, "VESA", 4) != 0)
+		return;
+
+	vbestate.mb_type = MULTIBOOT_TAG_TYPE_VBE;
+	vbestate.mb_size = sizeof (vbestate);
+	vbestate.vbe_mode = 0;
+	/* vbe_set_mode() will set up the rest. */
+}
+
+int
+vbe_available(void)
+{
+	return vbestate.mb_type;
+}
+
+int
+vbe_set_palette(const struct paletteentry *entry, size_t slot)
+{
+	struct paletteentry pe;
+	int ret;
+
+	if (!vbe_check())
+		return (1);
+
+	if (gfx_fb.framebuffer_common.framebuffer_type !=
+	    MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED) {
+		return (1);
+	}
+
+	pe.Blue = entry->Blue;
+	pe.Green = entry->Green;
+	pe.Red = entry->Red;
+	pe.Alignment = entry->Alignment;
+
+	ret = biosvbe_palette_data(0x00, slot, &pe);
+	if (ret == VBE_SUCCESS && slot < sizeof (cmap)) {
+		cmap[slot].mb_red = entry->Red;
+		cmap[slot].mb_green = entry->Green;
+		cmap[slot].mb_blue = entry->Blue;
+	}
+
+	return (ret == VBE_SUCCESS ? 0 : 1);
+}
+
+int
+vbe_get_mode(void)
+{
+	return vbestate.vbe_mode;
+}
+
+int
+vbe_set_mode(int modenum)
+{
+	struct modeinfoblock mi;
+	int ret;
+
+	if (!vbe_check())
+		return (1);
+
+	ret = biosvbe_get_mode_info(modenum, &mi);
+	if (VBE_ERROR(ret)) {
+		printf("mode 0x%x invalid\n", modenum);
+		return (1);
+	}
+
+	if (!vbe_mode_is_supported(&mi)) {
+		printf("mode 0x%x not supported\n", modenum);
+		return (1);
+	}
+
+	/* calculate bytes per pixel */
+	switch (mi.BitsPerPixel) {
+	case 32:
+	case 24:
+	case 16:
+	case 15:
+	case 8:
+		break;
+	default:
+		printf("BitsPerPixel %d is not supported\n", mi.BitsPerPixel);
+		return (1);
+	}
+
+	ret = biosvbe_set_mode(modenum, NULL);
+	if (VBE_ERROR(ret)) {
+		printf("mode 0x%x could not be set\n", modenum);
+		return (1);
+	}
+
+	/* make sure we have current MI in vbestate */
+	memcpy(vbe_mode, &mi, sizeof (*vbe_mode));
+	vbestate.vbe_mode = modenum;
+
+	gfx_fb.framebuffer_common.framebuffer_addr =
+	    (uint64_t)mi.PhysBasePtr & 0xffffffff;
+	gfx_fb.framebuffer_common.framebuffer_width = mi.XResolution;
+	gfx_fb.framebuffer_common.framebuffer_height = mi.YResolution;
+	gfx_fb.framebuffer_common.framebuffer_bpp = mi.BitsPerPixel;
+
+	/* vbe_mode_is_supported() excludes the rest */
+	switch (mi.MemoryModel) {
+	case 0x4:
+		gfx_fb.framebuffer_common.framebuffer_type =
+		    MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED;
+		if (vbe->VbeVersion >= 0x300) {
+			gfx_fb.framebuffer_common.framebuffer_pitch =
+			    mi.LinBytesPerScanLine;
+		} else {
+			gfx_fb.framebuffer_common.framebuffer_pitch =
+			    mi.BytesPerScanLine;
+		}
+		gfx_fb.u.fb1.framebuffer_palette_num_colors = 16;
+		return (0);	/* done */
+	case 0x6:
+		gfx_fb.framebuffer_common.framebuffer_type =
+		    MULTIBOOT_FRAMEBUFFER_TYPE_RGB;
+		break;
+	}
+
+	if (vbe->VbeVersion >= 0x300) {
+		gfx_fb.framebuffer_common.framebuffer_pitch =
+		    mi.LinBytesPerScanLine;
+		gfx_fb.u.fb2.framebuffer_red_field_position =
+		    mi.LinRedFieldPosition;
+		gfx_fb.u.fb2.framebuffer_red_mask_size = mi.LinRedMaskSize;
+		gfx_fb.u.fb2.framebuffer_green_field_position =
+		    mi.LinGreenFieldPosition;
+		gfx_fb.u.fb2.framebuffer_green_mask_size = mi.LinGreenMaskSize;
+		gfx_fb.u.fb2.framebuffer_blue_field_position =
+		    mi.LinBlueFieldPosition;
+		gfx_fb.u.fb2.framebuffer_blue_mask_size = mi.LinBlueMaskSize;
+	} else {
+		gfx_fb.framebuffer_common.framebuffer_pitch =
+		    mi.BytesPerScanLine;
+		gfx_fb.u.fb2.framebuffer_red_field_position =
+		    mi.RedFieldPosition;
+		gfx_fb.u.fb2.framebuffer_red_mask_size = mi.RedMaskSize;
+		gfx_fb.u.fb2.framebuffer_green_field_position =
+		    mi.GreenFieldPosition;
+		gfx_fb.u.fb2.framebuffer_green_mask_size = mi.GreenMaskSize;
+		gfx_fb.u.fb2.framebuffer_blue_field_position =
+		    mi.BlueFieldPosition;
+		gfx_fb.u.fb2.framebuffer_blue_mask_size = mi.BlueMaskSize;
+	}
+
+	return (0);
+}
+
+static void *
+vbe_farptr(uint32_t farptr)
+{
+	return PTOV((((farptr & 0xffff0000) >> 12) + (farptr & 0xffff)));
+}
+
+/*
+ * Verify existance of mode number or find mode by
+ * dimensions. If depth is not given, walk values 32, 24, 16, 8.
+ */
+static int
+vbe_find_mode_xydm(int x, int y, int depth, int m)
+{
+	struct modeinfoblock mi;
+	uint32_t farptr;
+	uint16_t mode;
+	int safety = 0, i;
+
+	memset(vbe, 0, sizeof(vbe));
+	memcpy(vbe->VbeSignature, "VBE2", 4);
+	if (biosvbe_info(vbe) != VBE_SUCCESS)
+		return (0);
+	if (memcmp(vbe->VbeSignature, "VESA", 4) != 0)
+		return (0);
+	farptr = vbe->VideoModePtr;
+	if (farptr == 0)
+		return (0);
+
+	if (m != -1)
+		i = 8;
+	else if (depth == -1)
+		i = 32;
+	else
+		i = depth;
+
+	while (i > 0) {
+		while ((mode = *(uint16_t *)vbe_farptr(farptr)) != 0xffff) {
+			safety++;
+			farptr += 2;
+			if (safety == 100)
+				return 0;
+			if (biosvbe_get_mode_info(mode, &mi) != VBE_SUCCESS) {
+				continue;
+			}
+			/* we only care about linear modes here */
+			if (vbe_mode_is_supported(&mi) == 0)
+				continue;
+			safety = 0;
+
+			if (m != -1) {
+				if (m == mode)
+					return (mode);
+				else
+					continue;
+			}
+
+			if (mi.XResolution == x &&
+			    mi.YResolution == y &&
+			    mi.BitsPerPixel == i)
+				return mode;
+		}
+		if (depth != -1)
+			break;
+
+		i -= 8;
+	}
+
+	return (0);
+}
+
+static int
+vbe_find_mode(char *str)
+{
+	int x, y, depth;
+
+	if (!gfx_parse_mode_str(str, &x, &y, &depth))
+		return (0);
+
+	return (vbe_find_mode_xydm(x, y, depth, -1));
+}
+
+static void
+vbe_dump_mode(int modenum, struct modeinfoblock *mi)
+{
+	printf("0x%x=%dx%dx%d", modenum,
+	    mi->XResolution, mi->YResolution, mi->BitsPerPixel);
+}
+
+static bool
+vbe_get_edid(uint_t *pwidth, uint_t *pheight)
+{
+	struct vesa_edid_info edid_info;
+	const uint8_t magic[] = EDID_MAGIC;
+	int ddc_caps, ret;
+
+	ddc_caps = biosvbe_ddc_caps();
+	if (ddc_caps == 0) {
+		return (false);
+	}
+
+	ret = biosvbe_ddc_read_edid(0, &edid_info);
+	if (VBE_ERROR(ret))
+		return (false);
+
+	if (memcmp(&edid_info, magic, sizeof (magic)) != 0)
+		return (false);
+
+	if (!(edid_info.header.version == 1 &&
+	    (edid_info.display.supported_features
+	    & EDID_FEATURE_PREFERRED_TIMING_MODE) &&
+	    edid_info.detailed_timings[0].pixel_clock))
+		return (false);
+
+	*pwidth = edid_info.detailed_timings[0].horizontal_active_lo |
+	    (((uint_t)edid_info.detailed_timings[0].horizontal_hi & 0xf0) << 4);
+	*pheight = edid_info.detailed_timings[0].vertical_active_lo |
+	    (((uint_t)edid_info.detailed_timings[0].vertical_hi & 0xf0) << 4);
+
+	return (true);
+}
+
+static void
+vbe_print_vbe_info(struct vbeinfoblock *vbep)
+{
+	char *oemstring = "";
+	char *oemvendor = "", *oemproductname = "", *oemproductrev = "";
+
+	if (vbep->OemStringPtr != 0)
+		oemstring = vbe_farptr(vbep->OemStringPtr);
+
+	if (vbep->OemVendorNamePtr != 0)
+		oemvendor = vbe_farptr(vbep->OemVendorNamePtr);
+
+	if (vbep->OemProductNamePtr != 0)
+		oemproductname = vbe_farptr(vbep->OemProductNamePtr);
+
+	if (vbep->OemProductRevPtr != 0)
+		oemproductrev = vbe_farptr(vbep->OemProductRevPtr);
+
+	printf("VESA VBE Version %d.%d\n%s\n", vbep->VbeVersion >> 8,
+	    vbep->VbeVersion & 0xF, oemstring);
+
+	if (vbep->OemSoftwareRev != 0) {
+		printf("OEM Version %d.%d, %s (%s, %s)\n",
+		    vbep->OemSoftwareRev >> 8, vbep->OemSoftwareRev & 0xF,
+			oemvendor, oemproductname, oemproductrev);
+	}
+}
+
+/* List available modes, filter by depth. If depth is -1, list all. */
+void
+vbe_modelist(int depth)
+{
+	struct modeinfoblock mi;
+	uint32_t farptr;
+	uint16_t mode;
+	int nmodes = 0, safety = 0;
+	int ddc_caps;
+	uint_t edid_width, edid_height;
+
+	if (!vbe_check())
+		return;
+
+	ddc_caps = biosvbe_ddc_caps();
+	if (ddc_caps & 3) {
+		printf("DDC");
+		if (ddc_caps & 1)
+			printf(" [DDC1]");
+		if (ddc_caps & 2)
+			printf(" [DDC2]");
+
+		if (vbe_get_edid(&edid_width, &edid_height))
+			printf(": EDID %dx%d\n", edid_width, edid_height);
+		else
+			printf(": no EDID information\n");
+	}
+
+	memset(vbe, 0, sizeof(vbe));
+	memcpy(vbe->VbeSignature, "VBE2", 4);
+	if (biosvbe_info(vbe) != VBE_SUCCESS)
+		goto done;
+	if (memcmp(vbe->VbeSignature, "VESA", 4) != 0)
+		goto done;
+
+	vbe_print_vbe_info(vbe);
+	printf("Modes: ");
+
+	farptr = vbe->VideoModePtr;
+	if (farptr == 0)
+		goto done;
+
+	while ((mode = *(uint16_t *)vbe_farptr(farptr)) != 0xffff) {
+		safety++;
+		farptr += 2;
+		if (safety == 100) {
+			printf("[?] ");
+			break;
+		}
+		if (biosvbe_get_mode_info(mode, &mi) != VBE_SUCCESS)
+			continue;
+		/* we only care about linear modes here */
+		if (vbe_mode_is_supported(&mi) == 0)
+			continue;
+
+		/* we found some mode so reset safety counter */
+		safety = 0;
+
+		/* apply requested filter */
+		if (depth != -1 && mi.BitsPerPixel != depth)
+			continue;
+
+		if (nmodes % 4 == 0)
+			printf("\n");
+		else
+			printf("  ");
+
+		vbe_dump_mode(mode, &mi);
+		nmodes++;
+	}
+
+done:
+	if (nmodes == 0)
+		printf("none found");
+	printf("\n");
+}
+
+static void
+vbe_print_mode(void)
+{
+	int mode, i, rc;
+	struct paletteentry pe;
+
+	memset(vbe, 0, sizeof(vbe));
+	memcpy(vbe->VbeSignature, "VBE2", 4);
+	if (biosvbe_info(vbe) != VBE_SUCCESS)
+		return;
+
+	if (memcmp(vbe->VbeSignature, "VESA", 4) != 0)
+		return;
+
+	vbe_print_vbe_info(vbe);
+
+	if (biosvbe_get_mode(&mode) != VBE_SUCCESS) {
+		printf("Error getting current VBE mode\n");
+		return;
+	}
+
+	if (biosvbe_get_mode_info(mode, vbe_mode) != VBE_SUCCESS ||
+	    vbe_mode_is_supported(vbe_mode) == 0) {
+		printf("VBE mode (0x%x) is not framebuffer mode\n", mode);
+		return;
+	}
+
+	printf("\nCurrent VBE mode: ");
+	vbe_dump_mode(mode, vbe_mode);
+	printf("\n");
+
+	printf("%ux%ux%u, stride=%u",
+	    gfx_fb.framebuffer_common.framebuffer_width,
+	    gfx_fb.framebuffer_common.framebuffer_height,
+	    gfx_fb.framebuffer_common.framebuffer_bpp,
+            (gfx_fb.framebuffer_common.framebuffer_pitch << 3) /
+	    gfx_fb.framebuffer_common.framebuffer_bpp);
+	printf("\n    frame buffer: address=%jx, size=%jx",
+	    (uintmax_t) gfx_fb.framebuffer_common.framebuffer_addr,
+	    (uintmax_t) gfx_fb.framebuffer_common.framebuffer_height *
+	    gfx_fb.framebuffer_common.framebuffer_pitch);
+
+	if (vbe_mode->MemoryModel == 0x6) {
+		printf("\n    color mask: R=%08x, G=%08x, B=%08x\n",
+		    ((1 << gfx_fb.u.fb2.framebuffer_red_mask_size) - 1) <<
+		    gfx_fb.u.fb2.framebuffer_red_field_position,
+		    ((1 << gfx_fb.u.fb2.framebuffer_green_mask_size) - 1) <<
+		    gfx_fb.u.fb2.framebuffer_green_field_position,
+		    ((1 << gfx_fb.u.fb2.framebuffer_blue_mask_size) - 1) <<
+		    gfx_fb.u.fb2.framebuffer_blue_field_position);
+		return;
+	}
+
+	mode = 1;	/* get DAC palette width */
+	rc = biosvbe_palette_format(&mode);
+	if (rc != VBE_SUCCESS)
+		return;
+
+	printf("    palette format: %x bits per primary\n", mode >> 8);
+	for (i = 0; i < 16; i++) {
+		rc = biosvbe_palette_data(1, i, &pe);
+		if (rc != VBE_SUCCESS)
+			break;
+
+		printf("%d: R=%02x, G=%02x, B=%02x\n", i,
+		    pe.Red, pe.Green, pe.Blue);
+	}
+}
+
+int
+vbe_default_mode(void)
+{
+	int modenum;
+	uint_t edid_width, edid_height;
+
+	if (vbe_get_edid(&edid_width, &edid_height)) {
+		modenum = vbe_find_mode_xydm(edid_width, edid_height, -1, -1);
+		if (modenum == 0)
+			modenum = vbe_find_mode(VBE_DEFAULT_MODE);
+	} else {
+		modenum = vbe_find_mode(VBE_DEFAULT_MODE);
+	}
+	return (modenum);
+}
+
+COMMAND_SET(framebuffer, "framebuffer", "framebuffer mode management",
+    command_vesa);
+
+int
+command_vesa(int argc, char *argv[])
+{
+	char *arg, *cp;
+	int modenum = -1, n;
+
+	if (!vbe_check())
+		return (CMD_OK);
+
+	if (argc < 2)
+		goto usage;
+
+	if (strcmp(argv[1], "list") == 0) {
+		n = -1;
+		if (argc != 2 && argc != 3)
+			goto usage;
+
+		if (argc == 3) {
+			arg = argv[2];
+			errno = 0;
+			n = strtoul(arg, &cp, 0);
+			if (errno != 0 || *arg == '\0' || cp[0] != '\0') {
+				snprintf(command_errbuf,
+				    sizeof (command_errbuf),
+				    "depth should be an integer");
+				return (CMD_ERROR);
+			}
+		}
+		vbe_modelist(n);
+		return (CMD_OK);
+	}
+
+	if (strcmp(argv[1], "get") == 0) {
+		if (argc != 2)
+			goto usage;
+
+		vbe_print_mode();
+		return (CMD_OK);
+	}
+
+	if (strcmp(argv[1], "off") == 0) {
+		if (argc != 2)
+			goto usage;
+
+		if (vbestate.vbe_mode == 0)
+			return (CMD_OK);
+
+		bios_set_text_mode(VGA_TEXT_MODE);
+		plat_cons_update_mode(0);
+		return (CMD_OK);
+	}
+
+	if (strcmp(argv[1], "on") == 0) {
+		if (argc != 2)
+			goto usage;
+
+		modenum = vbe_default_mode();
+		if (modenum == 0) {
+			snprintf(command_errbuf, sizeof (command_errbuf),
+			    "%s: no suitable VBE mode number found", argv[0]);
+			return (CMD_ERROR);
+		}
+	} else if (strcmp(argv[1], "set") == 0) {
+		if (argc != 3)
+			goto usage;
+
+		if (strncmp(argv[2], "0x", 2) == 0) {
+			arg = argv[2];
+			errno = 0;
+			n = strtoul(arg, &cp, 0);
+			if (errno != 0 || *arg == '\0' || cp[0] != '\0') {
+				snprintf(command_errbuf,
+				    sizeof (command_errbuf),
+				    "mode should be an integer");
+				return (CMD_ERROR);
+			}
+			modenum = vbe_find_mode_xydm(0, 0, 0, n);
+		} else if (strchr(argv[2], 'x') != NULL) {
+			modenum = vbe_find_mode(argv[2]);
+		}
+	}
+
+	if (modenum == 0) {
+		snprintf(command_errbuf, sizeof (command_errbuf),
+		    "%s: mode %s not supported by firmware\n",
+		    argv[0], argv[2]);
+		return (CMD_ERROR);
+	}
+
+	if (modenum >= 0x100) {
+		if (vbestate.vbe_mode != modenum) {
+			vbe_set_mode(modenum);
+			plat_cons_update_mode(1);
+		}
+		return (CMD_OK);
+	} else {
+		snprintf(command_errbuf, sizeof (command_errbuf),
+		    "%s: mode %s is not framebuffer mode\n", argv[0], argv[2]);
+		return (CMD_ERROR);
+	}
+
+usage:
+	snprintf(command_errbuf, sizeof (command_errbuf),
+	    "usage: %s on | off | get | list [depth] | "
+	    "set <display or VBE mode number>", argv[0]);
+	return (CMD_ERROR);
+}
diff --git a/usr/src/boot/sys/boot/i386/libi386/vbe.h b/usr/src/boot/sys/boot/i386/libi386/vbe.h
new file mode 100644
index 0000000000..7b428b968d
--- /dev/null
+++ b/usr/src/boot/sys/boot/i386/libi386/vbe.h
@@ -0,0 +1,145 @@
+/*-
+ * Copyright (c) 2009 Jared D. McNeill <jmcneill@invisible.ca>
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
+ */
+
+/*
+ * Default mode for VESA frame buffer.
+ * This mode is selected when there is no EDID inormation and
+ * mode is not provided by user.
+ * To provide consistent look with UEFI GOP, we use 800x600 here,
+ * and if this mode is not available, we fall back to text mode and
+ * VESA disabled.
+ */
+
+#define VBE_DEFAULT_MODE	"800x600"
+
+struct vbeinfoblock {
+	char VbeSignature[4];
+	uint16_t VbeVersion;
+	uint32_t OemStringPtr;
+	uint32_t Capabilities;
+	uint32_t VideoModePtr;
+	uint16_t TotalMemory;
+	uint16_t OemSoftwareRev;
+	uint32_t OemVendorNamePtr, OemProductNamePtr, OemProductRevPtr;
+	/* data area, in total max 512 bytes for VBE 2.0 */
+	uint8_t Reserved[222];
+	uint8_t OemData[256];
+} __packed;
+
+struct modeinfoblock {
+	/* Mandatory information for all VBE revisions */
+	uint16_t ModeAttributes;
+	uint8_t WinAAttributes, WinBAttributes;
+	uint16_t WinGranularity, WinSize, WinASegment, WinBSegment;
+	uint32_t WinFuncPtr;
+	uint16_t BytesPerScanLine;
+	/* Mandatory information for VBE 1.2 and above */
+	uint16_t XResolution, YResolution;
+	uint8_t XCharSize, YCharSize, NumberOfPlanes, BitsPerPixel;
+	uint8_t NumberOfBanks, MemoryModel, BankSize, NumberOfImagePages;
+	uint8_t Reserved1;
+	/* Direct Color fields
+	   (required for direct/6 and YUV/7 memory models) */
+	uint8_t RedMaskSize, RedFieldPosition;
+	uint8_t GreenMaskSize, GreenFieldPosition;
+	uint8_t BlueMaskSize, BlueFieldPosition;
+	uint8_t RsvdMaskSize, RsvdFieldPosition;
+	uint8_t DirectColorModeInfo;
+	/* Mandatory information for VBE 2.0 and above */
+	uint32_t PhysBasePtr;
+	uint32_t OffScreenMemOffset;	/* reserved in VBE 3.0 and above */
+	uint16_t OffScreenMemSize;	/* reserved in VBE 3.0 and above */
+
+	/* Mandatory information for VBE 3.0 and above */
+	uint16_t LinBytesPerScanLine;
+	uint8_t BnkNumberOfImagePages;
+	uint8_t LinNumberOfImagePages;
+	uint8_t LinRedMaskSize, LinRedFieldPosition;
+	uint8_t LinGreenMaskSize, LinGreenFieldPosition;
+	uint8_t LinBlueMaskSize, LinBlueFieldPosition;
+	uint8_t LinRsvdMaskSize, LinRsvdFieldPosition;
+	uint32_t MaxPixelClock;
+	/* + 1 will fix the size to 256 bytes */
+	uint8_t Reserved4[189 + 1];
+} __packed;
+
+struct crtciinfoblock {
+	uint16_t HorizontalTotal;
+	uint16_t HorizontalSyncStart;
+	uint16_t HorizontalSyncEnd;
+	uint16_t VerticalTotal;
+	uint16_t VerticalSyncStart;
+	uint16_t VerticalSyncEnd;
+	uint8_t Flags;
+	uint32_t PixelClock;
+	uint16_t RefreshRate;
+	uint8_t Reserved[40];
+} __packed;
+
+struct paletteentry {
+	uint8_t Blue;
+	uint8_t Green;
+	uint8_t Red;
+	uint8_t Alignment;
+} __packed;
+
+struct flatpanelinfo
+{
+	uint16_t HorizontalSize;
+	uint16_t VerticalSize;
+	uint16_t PanelType;
+	uint8_t RedBPP;
+	uint8_t GreenBPP;
+	uint8_t BlueBPP;
+	uint8_t ReservedBPP;
+	uint32_t ReservedOffScreenMemSize;
+	uint32_t ReservedOffScreenMemPtr;
+
+	uint8_t Reserved[14];
+} __packed;
+
+#define	VBE_BASE_MODE		(0x100)		/* VBE 3.0 page 18 */
+#define	VBE_VALID_MODE(a)	((a) >= VBE_BASE_MODE)
+#define	VBE_ERROR(a)		(((a) & 0xFF) != 0x4F || ((a) & 0xFF00) != 0)
+#define	VBE_SUCCESS		(0x004F)
+#define	VBE_FAILED		(0x014F)
+#define	VBE_NOTSUP		(0x024F)
+#define	VBE_INVALID		(0x034F)
+
+#define	VGA_TEXT_MODE		(3)		/* 80x25 text mode */
+#define	TEXT_ROWS		(25)		/* VGATEXT rows */
+#define	TEXT_COLS		(80)		/* VGATEXT columns */
+
+/* high-level VBE helpers, from vbe.c */
+void bios_set_text_mode(int);
+int biosvbe_palette_format(int *);
+void vbe_init(void);
+int vbe_available(void);
+int vbe_default_mode(void);
+int vbe_set_mode(int);
+int vbe_get_mode(void);
+int vbe_set_palette(const struct paletteentry *, size_t);
+void vbe_modelist(int);
diff --git a/usr/src/boot/sys/boot/i386/libi386/vidconsole.c b/usr/src/boot/sys/boot/i386/libi386/vidconsole.c
index edefda223c..0bfb39649e 100644
--- a/usr/src/boot/sys/boot/i386/libi386/vidconsole.c
+++ b/usr/src/boot/sys/boot/i386/libi386/vidconsole.c
@@ -1,4 +1,4 @@
-/*-
+/*
  * Copyright (c) 1998 Michael Smith (msmith@freebsd.org)
  * Copyright (c) 1997 Kazutaka YOKOTA (yokota@zodiac.mech.utsunomiya-u.ac.jp)
  * All rights reserved.
@@ -24,19 +24,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * 	Id: probe_keyboard.c,v 1.13 1997/06/09 05:10:55 bde Exp
+ *	Id: probe_keyboard.c,v 1.13 1997/06/09 05:10:55 bde Exp
  */
 
 #include <sys/cdefs.h>
 
 #include <stand.h>
 #include <bootstrap.h>
+#include <sys/tem_impl.h>
+#include <sys/visual_io.h>
+#include <sys/multiboot2.h>
 #include <btxv86.h>
 #include <machine/psl.h>
+#include <machine/metadata.h>
 #include "libi386.h"
+#include "vbe.h"
+#include <gfx_fb.h>
+#include <sys/vgareg.h>
+#include <sys/vgasubr.h>
+#include <machine/cpufunc.h>
 
 #if KEYBOARD_PROBE
-#include <machine/cpufunc.h>
 
 static int	probe_keyboard(void);
 #endif
@@ -45,605 +53,734 @@ static int	vidc_init(struct console *cp, int arg);
 static void	vidc_putchar(struct console *cp, int c);
 static int	vidc_getchar(struct console *cp);
 static int	vidc_ischar(struct console *cp);
+static int	vidc_ioctl(struct console *cp, int cmd, void *data);
+static void	vidc_biosputchar(int c);
+
+static int vidc_vbe_devinit(struct vis_devinit *);
+static void vidc_cons_cursor(struct vis_conscursor *);
+static int vidc_vbe_cons_put_cmap(struct vis_cmap *);
+
+static int vidc_text_devinit(struct vis_devinit *);
+static int vidc_text_cons_clear(struct vis_consclear *);
+static void vidc_text_cons_copy(struct vis_conscopy *);
+static void vidc_text_cons_display(struct vis_consdisplay *);
+static void vidc_text_set_cursor(screen_pos_t, screen_pos_t, boolean_t);
+static void vidc_text_get_cursor(screen_pos_t *, screen_pos_t *);
+static int vidc_text_cons_put_cmap(struct vis_cmap *);
+
+static int vidc_started;
+static uint16_t	*vgatext;
 
-static int	vidc_started;
+/* mode change callback and argument from tem */
+static vis_modechg_cb_t modechg_cb;
+static struct vis_modechg_arg *modechg_arg;
+static tem_vt_state_t tem;
 
-#ifdef TERM_EMU
-#define MAXARGS		8
 #define	KEYBUFSZ	10
 #define DEFAULT_FGCOLOR	7
 #define DEFAULT_BGCOLOR	0
 
-void		end_term(void);
-void		bail_out(int c);
-void		vidc_term_emu(int c);
-void		get_pos(int *x, int *y);
-void		curs_move(int *_x, int *_y, int x, int y);
-void		write_char(int c, int fg, int bg);
-void		scroll_up(int rows, int fg, int bg);
-void		CD(void);
-void		CM(void);
-void		HO(void);
-
-static unsigned	keybuf[KEYBUFSZ];	/* keybuf for extended codes */
-static int	args[MAXARGS], argc;
-static int	fg_c, bg_c, curx, cury;
-static int	esc;
-#endif
-
+static uint8_t	keybuf[KEYBUFSZ];	/* keybuf for extended codes */
 
 struct console text = {
-    "text",
-    "internal video/keyboard",
-    0,
-    vidc_probe,
-    vidc_init,
-    vidc_putchar,
-    vidc_getchar,
-    vidc_ischar,
-    NULL
+	.c_name = "text",
+	.c_desc = "internal video/keyboard",
+	.c_flags = 0,
+	.c_probe = vidc_probe,
+	.c_init = vidc_init,
+	.c_out = vidc_putchar,
+	.c_in = vidc_getchar,
+	.c_ready = vidc_ischar,
+	.c_ioctl = vidc_ioctl,
+	.c_private = NULL
 };
 
-static void
-vidc_probe(struct console *cp)
-{
-    
-    /* look for a keyboard */
-#if KEYBOARD_PROBE
-    if (probe_keyboard())
-#endif
-    {
-	
-	cp->c_flags |= C_PRESENTIN;
-    }
+static struct vis_identifier fb_ident = { "vidc_fb" };
+static struct vis_identifier text_ident = { "vidc_text" };
+
+struct visual_ops fb_ops = {
+	.ident = &fb_ident,
+	.kdsetmode = NULL,
+	.devinit = vidc_vbe_devinit,
+	.cons_copy = NULL,
+	.cons_display = NULL,
+	.cons_cursor = vidc_cons_cursor,
+	.cons_clear = NULL,
+	.cons_put_cmap = vidc_vbe_cons_put_cmap
+};
 
-    /* XXX for now, always assume we can do BIOS screen output */
-    cp->c_flags |= C_PRESENTOUT;
-}
+struct visual_ops text_ops = {
+	.ident = &text_ident,
+	.kdsetmode = NULL,
+	.devinit = vidc_text_devinit,
+	.cons_copy = vidc_text_cons_copy,
+	.cons_display = vidc_text_cons_display,
+	.cons_cursor = vidc_cons_cursor,
+	.cons_clear = vidc_text_cons_clear,
+	.cons_put_cmap = vidc_text_cons_put_cmap
+};
 
-static int
-vidc_init(struct console *cp, int arg)
+/*
+ * platform specific functions for tem
+ */
+int
+plat_stdout_is_framebuffer(void)
 {
-    int		i;
-
-    if (vidc_started && arg == 0)
-	return (0);
-    vidc_started = 1;
-#ifdef TERM_EMU
-    /* Init terminal emulator */
-    end_term();
-    get_pos(&curx, &cury);
-    curs_move(&curx, &cury, curx, cury);
-    fg_c = DEFAULT_FGCOLOR;
-    bg_c = DEFAULT_BGCOLOR;
-    memset(keybuf, 0, KEYBUFSZ);
-#endif
-    for (i = 0; i < 10 && vidc_ischar(cp); i++)
-	(void)vidc_getchar(cp);
-    return (0);	/* XXX reinit? */
+	if (vbe_available() && VBE_VALID_MODE(vbe_get_mode())) {
+		return (1);
+	}
+        return (0);
 }
 
 void
-vidc_biosputchar(int c)
+plat_tem_hide_prom_cursor(void)
 {
-
-    v86.ctl = 0;
-    v86.addr = 0x10;
-    v86.eax = 0xe00 | (c & 0xff);
-    v86.ebx = 0x7;
-    v86int();
+	vidc_text_set_cursor(0, 0, B_FALSE);
 }
 
-static void
-vidc_rawputchar(int c)
+void
+plat_tem_get_prom_pos(uint32_t *row, uint32_t *col)
 {
-    int		i;
-
-    if (c == '\t')
-	/* lame tab expansion */
-	for (i = 0; i < 8; i++)
-	    vidc_rawputchar(' ');
-    else {
-#ifndef TERM_EMU
-        vidc_biosputchar(c);
-#else
-	/* Emulate AH=0eh (teletype output) */
-	switch(c) {
-	case '\a':
-	    vidc_biosputchar(c);
-	    return;
-	case '\r':
-	    curx = 0;
-	    break;
-	case '\n':
-	    cury++;
-	    if ((text.c_flags & C_MODERAW) == 0)
-		curx = 0;
-
-	    if (cury > 24) {
-		scroll_up(1, fg_c, bg_c);
-		cury--;
-	    }
-	    break;
-	case '\b':
-	    if (curx > 0)
-		curx--;
-	    break;
-	default:
-		if (curx > 79) {
-			curx = 0;
-			cury++;
-			curs_move(&curx, &cury, curx, cury);
-		}
-		if ((text.c_flags & C_MODERAW) == 0) {
-			if (cury > 24) {
-				curx = 0;
-				scroll_up(1, fg_c, bg_c);
-				cury--;
-				curs_move(&curx, &cury, curx, cury);
-			}
-		}
-		write_char(c, fg_c, bg_c);
-		curx++;
-		if (text.c_flags & C_MODERAW) {
-			if (curx > 79) {
-				curx = 0;
-				if (cury == 25)
-					scroll_up(1, fg_c, bg_c);
-				else
-					cury++;
-			}
-		}
+	screen_pos_t x, y;
+
+	if (plat_stdout_is_framebuffer()) {
+		*row = 0;
+		*col = 0;
+	} else {
+		vidc_text_get_cursor(&y, &x);
+		*row = (uint32_t) y;
+		*col = (uint32_t) x;
 	}
-	curs_move(&curx, &cury, curx, cury);
-#endif
-    }
 }
 
-#ifdef TERM_EMU
-
-/* Get cursor position on the screen. Result is in edx. Sets
- * curx and cury appropriately.
+/*
+ * plat_tem_get_prom_size() is supposed to return screen size
+ * in chars. Return real data for text mode and TEM defaults for graphical
+ * mode, so the tem can compute values based on default and font.
  */
 void
-get_pos(int *x, int *y)
+plat_tem_get_prom_size(size_t *height, size_t *width)
 {
-
-    v86.ctl = 0;
-    v86.addr = 0x10;
-    v86.eax = 0x0300;
-    v86.ebx = 0x0;
-    v86int();
-    *x = v86.edx & 0x00ff;
-    *y = (v86.edx & 0xff00) >> 8;
+	if (plat_stdout_is_framebuffer()) {
+		*height = TEM_DEFAULT_ROWS;
+		*width = TEM_DEFAULT_COLS;
+	} else {
+		*height = TEXT_ROWS;
+		*width = TEXT_COLS;
+	}
 }
 
-/* Move cursor to x rows and y cols (0-based). */
 void
-curs_move(int *_x, int *_y, int x, int y)
+plat_cons_update_mode(int mode __unused)
 {
+	struct vis_devinit devinit;
+
+	if (tem == NULL)	/* tem is not set up */
+		return;
+
+	if (plat_stdout_is_framebuffer()) {
+		devinit.version = VIS_CONS_REV;
+		devinit.width = gfx_fb.framebuffer_common.framebuffer_width;
+		devinit.height = gfx_fb.framebuffer_common.framebuffer_height;
+		devinit.depth = gfx_fb.framebuffer_common.framebuffer_bpp;
+		devinit.linebytes = gfx_fb.framebuffer_common.framebuffer_pitch;
+		devinit.color_map = gfx_fb_color_map;
+		devinit.mode = VIS_PIXEL;
+		text.c_private = &fb_ops;
+	} else {
+		devinit.version = VIS_CONS_REV;
+		devinit.width = TEXT_COLS;
+		devinit.height = TEXT_ROWS;
+		devinit.depth = 4;
+		devinit.linebytes = TEXT_COLS;
+		devinit.color_map = NULL;
+		devinit.mode = VIS_TEXT;
+		text.c_private = &text_ops;
+	}
 
-    v86.ctl = 0;
-    v86.addr = 0x10;
-    v86.eax = 0x0200;
-    v86.ebx = 0x0;
-    v86.edx = ((0x00ff & y) << 8) + (0x00ff & x);
-    v86int();
-    if (_x != NULL)
-	*_x = x;
-    if (_y != NULL)
-	*_y = y;
-    /* If there is ctrl char at this position, cursor would be invisible.
-     * Make it a space instead.
-     */
-    v86.ctl = 0;
-    v86.addr = 0x10;
-    v86.eax = 0x0800;
-    v86.ebx = 0x0;
-    v86int();
-#define isvisible(c)	(((c) >= 32) && ((c) < 255))
-    if (!isvisible(v86.eax & 0x00ff)) {
-	write_char(' ', fg_c, bg_c);
-    }
-    v86.ctl = 0;	/* show normal underline cursor */
-    v86.addr = 0x10;
-    v86.eax = 0x0100;
-    v86.ecx = 0x0607;
-    v86int();
+	modechg_cb(modechg_arg, &devinit);
 }
 
-/* Scroll up the whole window by a number of rows. If rows==0,
- * clear the window. fg and bg are attributes for the new lines
- * inserted in the window.
- */
-void
-scroll_up(int rows, int fgcol, int bgcol)
+static int
+vidc_vbe_devinit(struct vis_devinit *devinit)
 {
-    if (rows == 0)
-	rows = 25;
-    v86.ctl = 0;
-    v86.addr = 0x10;
-    v86.eax = 0x0600 + (0x00ff & rows);
-    v86.ebx = (bgcol << 12) + (fgcol << 8);
-    v86.ecx = 0x0;
-    v86.edx = 0x184f;
-    v86int();
+	if (plat_stdout_is_framebuffer() == 0)
+		return (1);
+
+	devinit->version = VIS_CONS_REV;
+	devinit->width = gfx_fb.framebuffer_common.framebuffer_width;
+	devinit->height = gfx_fb.framebuffer_common.framebuffer_height;
+	devinit->depth = gfx_fb.framebuffer_common.framebuffer_bpp;
+	devinit->linebytes = gfx_fb.framebuffer_common.framebuffer_pitch;
+	devinit->color_map = gfx_fb_color_map;
+	devinit->mode = VIS_PIXEL;
+
+	modechg_cb = devinit->modechg_cb;
+	modechg_arg = devinit->modechg_arg;
+
+	return (0);
 }
 
-/* Write character and attribute at cursor position. */
-void
-write_char(int c, int fgcol, int bgcol)
+static int
+vidc_text_devinit(struct vis_devinit *devinit)
 {
+	if (plat_stdout_is_framebuffer())
+		return (1);
 
-    v86.ctl = 0;
-    v86.addr = 0x10;
-    v86.eax = 0x0900 + (0x00ff & c);
-    v86.ebx = (bgcol << 4) + fgcol;
-    v86.ecx = 0x1;
-    v86int();
-}
+	devinit->version = VIS_CONS_REV;
+	devinit->width = TEXT_COLS;
+	devinit->height = TEXT_ROWS;
+	devinit->depth = 4;
+	devinit->linebytes = TEXT_COLS;
+	devinit->color_map = NULL;
+	devinit->mode = VIS_TEXT;
 
-/**************************************************************/
-/*
- * Screen manipulation functions. They use accumulated data in
- * args[] and argc variables.
- *
- */
+	modechg_cb = devinit->modechg_cb;
+	modechg_arg = devinit->modechg_arg;
 
-/* Clear line from current position to end of line */
-void
-CL(int direction)
-{
-    v86.ctl = 0;
-    v86.addr = 0x10;
-    v86.eax = 0x0600;
-    v86.ebx = (bg_c << 12) + (fg_c << 8);
-    if (direction == 0) {	/* from cursor to end */
-	v86.ecx = (cury << 8) + curx;
-	v86.edx = (cury << 8) + 79;
-    } else if (direction == 1) { /* from beginning to cursor */
-	v86.ecx = (cury << 8) + 0;
-	v86.edx = (cury << 8) + curx;
-    } else if (direction == 2) { /* entire line */
-	v86.ecx = (cury << 8) + 0;
-	v86.edx = (cury << 8) + 79;
-    }
-    v86int();
-    end_term();
-    return;
+	return (0);
 }
 
-/* Clear display from current position to end of screen */
-void
-CD(void)
+static int
+vidc_text_cons_clear(struct vis_consclear *ca)
 {
+	uint16_t val;
+	int i;
 
-    get_pos(&curx, &cury);
-    if (curx > 0) {
-	v86.ctl = 0;
-	v86.addr = 0x10;
-	v86.eax = 0x0600;
-	v86.ebx = (bg_c << 12) + (fg_c << 8);
-	v86.ecx = (cury << 8) + curx;
-	v86.edx = (cury << 8) + 79;
-	v86int();
-	if (++cury > 24) {
-	    end_term();
-	    return;
+	val = (solaris_color_to_pc_color[ca->bg_color & 0xf] << 4) |
+	    DEFAULT_FGCOLOR;
+	val = (val << 8) | ' ';
+
+	for (i = 0; i < TEXT_ROWS * TEXT_COLS; i++)
+		vgatext[i] = val;
+
+	return (0);
+}
+
+static void
+vidc_text_cons_copy(struct vis_conscopy *ma)
+{
+	uint16_t  *from;
+	uint16_t *to;
+	int cnt;
+	screen_size_t chars_per_row;
+	uint16_t *to_row_start;
+	uint16_t *from_row_start;
+	screen_size_t rows_to_move;
+	uint16_t *base;
+
+	/*
+	 * Sanity checks.  Note that this is a last-ditch effort to avoid
+	 * damage caused by broken-ness or maliciousness above.
+	 */
+	if (ma->s_col < 0 || ma->s_col >= TEXT_COLS ||
+	    ma->s_row < 0 || ma->s_row >= TEXT_ROWS ||
+	    ma->e_col < 0 || ma->e_col >= TEXT_COLS ||
+	    ma->e_row < 0 || ma->e_row >= TEXT_ROWS ||
+	    ma->t_col < 0 || ma->t_col >= TEXT_COLS ||
+	    ma->t_row < 0 || ma->t_row >= TEXT_ROWS ||
+	    ma->s_col > ma->e_col ||
+	    ma->s_row > ma->e_row)
+		return;
+
+	/*
+	 * Remember we're going to copy shorts because each
+	 * character/attribute pair is 16 bits.
+	 */
+	chars_per_row = ma->e_col - ma->s_col + 1;
+	rows_to_move = ma->e_row - ma->s_row + 1;
+
+	/* More sanity checks. */
+	if (ma->t_row + rows_to_move > TEXT_ROWS ||
+	    ma->t_col + chars_per_row > TEXT_COLS)
+		return;
+
+	base = vgatext;
+
+	to_row_start = base + ((ma->t_row * TEXT_COLS) + ma->t_col);
+	from_row_start = base + ((ma->s_row * TEXT_COLS) + ma->s_col);
+
+	if (to_row_start < from_row_start) {
+		while (rows_to_move-- > 0) {
+			to = to_row_start;
+			from = from_row_start;
+			to_row_start += TEXT_COLS;
+			from_row_start += TEXT_COLS;
+			for (cnt = chars_per_row; cnt-- > 0; )
+				*to++ = *from++;
+		}
+	} else {
+		/*
+		 * Offset to the end of the region and copy backwards.
+		 */
+		cnt = rows_to_move * TEXT_COLS + chars_per_row;
+		to_row_start += cnt;
+		from_row_start += cnt;
+
+		while (rows_to_move-- > 0) {
+			to_row_start -= TEXT_COLS;
+			from_row_start -= TEXT_COLS;
+			to = to_row_start;
+			from = from_row_start;
+			for (cnt = chars_per_row; cnt-- > 0; )
+				*--to = *--from;
+		}
 	}
-    }
-    v86.ctl = 0;
-    v86.addr = 0x10;
-    v86.eax = 0x0600;
-    v86.ebx = (bg_c << 12) + (fg_c << 8);
-    v86.ecx = (cury << 8) + 0;
-    v86.edx = (24 << 8) + 79;
-    v86int();
-    end_term();
 }
 
-/* Absolute cursor move to args[0] rows and args[1] columns
- * (the coordinates are 1-based).
+/*
+ * Binary searchable table for Unicode to CP437 conversion.
  */
-void
-CM(void)
-{
+struct unicp437 {
+	uint16_t	unicode_base;
+	uint8_t		cp437_base;
+	uint8_t		length;
+};
 
-    if (args[0] > 0)
-	args[0]--;
-    if (args[1] > 0)
-	args[1]--;
-    curs_move(&curx, &cury, args[1], args[0]);
-    end_term();
-}
+static const struct unicp437 cp437table[] = {
+	{ 0x0020, 0x20, 0x5e }, { 0x00a0, 0x20, 0x00 },
+	{ 0x00a1, 0xad, 0x00 }, { 0x00a2, 0x9b, 0x00 },
+	{ 0x00a3, 0x9c, 0x00 }, { 0x00a5, 0x9d, 0x00 },
+	{ 0x00a7, 0x15, 0x00 }, { 0x00aa, 0xa6, 0x00 },
+	{ 0x00ab, 0xae, 0x00 }, { 0x00ac, 0xaa, 0x00 },
+	{ 0x00b0, 0xf8, 0x00 }, { 0x00b1, 0xf1, 0x00 },
+	{ 0x00b2, 0xfd, 0x00 }, { 0x00b5, 0xe6, 0x00 },
+	{ 0x00b6, 0x14, 0x00 }, { 0x00b7, 0xfa, 0x00 },
+	{ 0x00ba, 0xa7, 0x00 }, { 0x00bb, 0xaf, 0x00 },
+	{ 0x00bc, 0xac, 0x00 }, { 0x00bd, 0xab, 0x00 },
+	{ 0x00bf, 0xa8, 0x00 }, { 0x00c4, 0x8e, 0x01 },
+	{ 0x00c6, 0x92, 0x00 }, { 0x00c7, 0x80, 0x00 },
+	{ 0x00c9, 0x90, 0x00 }, { 0x00d1, 0xa5, 0x00 },
+	{ 0x00d6, 0x99, 0x00 }, { 0x00dc, 0x9a, 0x00 },
+	{ 0x00df, 0xe1, 0x00 }, { 0x00e0, 0x85, 0x00 },
+	{ 0x00e1, 0xa0, 0x00 }, { 0x00e2, 0x83, 0x00 },
+	{ 0x00e4, 0x84, 0x00 }, { 0x00e5, 0x86, 0x00 },
+	{ 0x00e6, 0x91, 0x00 }, { 0x00e7, 0x87, 0x00 },
+	{ 0x00e8, 0x8a, 0x00 }, { 0x00e9, 0x82, 0x00 },
+	{ 0x00ea, 0x88, 0x01 }, { 0x00ec, 0x8d, 0x00 },
+	{ 0x00ed, 0xa1, 0x00 }, { 0x00ee, 0x8c, 0x00 },
+	{ 0x00ef, 0x8b, 0x00 }, { 0x00f0, 0xeb, 0x00 },
+	{ 0x00f1, 0xa4, 0x00 }, { 0x00f2, 0x95, 0x00 },
+	{ 0x00f3, 0xa2, 0x00 }, { 0x00f4, 0x93, 0x00 },
+	{ 0x00f6, 0x94, 0x00 }, { 0x00f7, 0xf6, 0x00 },
+	{ 0x00f8, 0xed, 0x00 }, { 0x00f9, 0x97, 0x00 },
+	{ 0x00fa, 0xa3, 0x00 }, { 0x00fb, 0x96, 0x00 },
+	{ 0x00fc, 0x81, 0x00 }, { 0x00ff, 0x98, 0x00 },
+	{ 0x0192, 0x9f, 0x00 }, { 0x0393, 0xe2, 0x00 },
+	{ 0x0398, 0xe9, 0x00 }, { 0x03a3, 0xe4, 0x00 },
+	{ 0x03a6, 0xe8, 0x00 }, { 0x03a9, 0xea, 0x00 },
+	{ 0x03b1, 0xe0, 0x01 }, { 0x03b4, 0xeb, 0x00 },
+	{ 0x03b5, 0xee, 0x00 }, { 0x03bc, 0xe6, 0x00 },
+	{ 0x03c0, 0xe3, 0x00 }, { 0x03c3, 0xe5, 0x00 },
+	{ 0x03c4, 0xe7, 0x00 }, { 0x03c6, 0xed, 0x00 },
+	{ 0x03d5, 0xed, 0x00 }, { 0x2010, 0x2d, 0x00 },
+	{ 0x2014, 0x2d, 0x00 }, { 0x2018, 0x60, 0x00 },
+	{ 0x2019, 0x27, 0x00 }, { 0x201c, 0x22, 0x00 },
+	{ 0x201d, 0x22, 0x00 }, { 0x2022, 0x07, 0x00 },
+	{ 0x203c, 0x13, 0x00 }, { 0x207f, 0xfc, 0x00 },
+	{ 0x20a7, 0x9e, 0x00 }, { 0x20ac, 0xee, 0x00 },
+	{ 0x2126, 0xea, 0x00 }, { 0x2190, 0x1b, 0x00 },
+	{ 0x2191, 0x18, 0x00 }, { 0x2192, 0x1a, 0x00 },
+	{ 0x2193, 0x19, 0x00 }, { 0x2194, 0x1d, 0x00 },
+	{ 0x2195, 0x12, 0x00 }, { 0x21a8, 0x17, 0x00 },
+	{ 0x2202, 0xeb, 0x00 }, { 0x2208, 0xee, 0x00 },
+	{ 0x2211, 0xe4, 0x00 }, { 0x2212, 0x2d, 0x00 },
+	{ 0x2219, 0xf9, 0x00 }, { 0x221a, 0xfb, 0x00 },
+	{ 0x221e, 0xec, 0x00 }, { 0x221f, 0x1c, 0x00 },
+	{ 0x2229, 0xef, 0x00 }, { 0x2248, 0xf7, 0x00 },
+	{ 0x2261, 0xf0, 0x00 }, { 0x2264, 0xf3, 0x00 },
+	{ 0x2265, 0xf2, 0x00 }, { 0x2302, 0x7f, 0x00 },
+	{ 0x2310, 0xa9, 0x00 }, { 0x2320, 0xf4, 0x00 },
+	{ 0x2321, 0xf5, 0x00 }, { 0x2500, 0xc4, 0x00 },
+	{ 0x2502, 0xb3, 0x00 }, { 0x250c, 0xda, 0x00 },
+	{ 0x2510, 0xbf, 0x00 }, { 0x2514, 0xc0, 0x00 },
+	{ 0x2518, 0xd9, 0x00 }, { 0x251c, 0xc3, 0x00 },
+	{ 0x2524, 0xb4, 0x00 }, { 0x252c, 0xc2, 0x00 },
+	{ 0x2534, 0xc1, 0x00 }, { 0x253c, 0xc5, 0x00 },
+	{ 0x2550, 0xcd, 0x00 }, { 0x2551, 0xba, 0x00 },
+	{ 0x2552, 0xd5, 0x00 }, { 0x2553, 0xd6, 0x00 },
+	{ 0x2554, 0xc9, 0x00 }, { 0x2555, 0xb8, 0x00 },
+	{ 0x2556, 0xb7, 0x00 }, { 0x2557, 0xbb, 0x00 },
+	{ 0x2558, 0xd4, 0x00 }, { 0x2559, 0xd3, 0x00 },
+	{ 0x255a, 0xc8, 0x00 }, { 0x255b, 0xbe, 0x00 },
+	{ 0x255c, 0xbd, 0x00 }, { 0x255d, 0xbc, 0x00 },
+	{ 0x255e, 0xc6, 0x01 }, { 0x2560, 0xcc, 0x00 },
+	{ 0x2561, 0xb5, 0x00 }, { 0x2562, 0xb6, 0x00 },
+	{ 0x2563, 0xb9, 0x00 }, { 0x2564, 0xd1, 0x01 },
+	{ 0x2566, 0xcb, 0x00 }, { 0x2567, 0xcf, 0x00 },
+	{ 0x2568, 0xd0, 0x00 }, { 0x2569, 0xca, 0x00 },
+	{ 0x256a, 0xd8, 0x00 }, { 0x256b, 0xd7, 0x00 },
+	{ 0x256c, 0xce, 0x00 }, { 0x2580, 0xdf, 0x00 },
+	{ 0x2584, 0xdc, 0x00 }, { 0x2588, 0xdb, 0x00 },
+	{ 0x258c, 0xdd, 0x00 }, { 0x2590, 0xde, 0x00 },
+	{ 0x2591, 0xb0, 0x02 }, { 0x25a0, 0xfe, 0x00 },
+	{ 0x25ac, 0x16, 0x00 }, { 0x25b2, 0x1e, 0x00 },
+	{ 0x25ba, 0x10, 0x00 }, { 0x25bc, 0x1f, 0x00 },
+	{ 0x25c4, 0x11, 0x00 }, { 0x25cb, 0x09, 0x00 },
+	{ 0x25d8, 0x08, 0x00 }, { 0x25d9, 0x0a, 0x00 },
+	{ 0x263a, 0x01, 0x01 }, { 0x263c, 0x0f, 0x00 },
+	{ 0x2640, 0x0c, 0x00 }, { 0x2642, 0x0b, 0x00 },
+	{ 0x2660, 0x06, 0x00 }, { 0x2663, 0x05, 0x00 },
+	{ 0x2665, 0x03, 0x01 }, { 0x266a, 0x0d, 0x00 },
+	{ 0x266c, 0x0e, 0x00 }
+};
 
-/* Home cursor (left top corner) */
-void
-HO(void)
+static uint8_t
+vga_get_cp437(tem_char_t c)
 {
-
-    argc = 1;
-    args[0] = args[1] = 1;
-    CM();
+	int min, mid, max;
+
+	min = 0;
+	max = (sizeof(cp437table) / sizeof(struct unicp437)) - 1;
+
+	if (c < cp437table[0].unicode_base ||
+	    c > cp437table[max].unicode_base + cp437table[max].length)
+		return ('?');
+
+	while (max >= min) {
+		mid = (min + max) / 2;
+		if (c < cp437table[mid].unicode_base)
+			max = mid - 1;
+		else if (c > cp437table[mid].unicode_base +
+		    cp437table[mid].length)
+			min = mid + 1;
+                else
+			return (c - cp437table[mid].unicode_base +
+			    cp437table[mid].cp437_base);
+        }
+
+	return ('?');
 }
 
-/* Clear internal state of the terminal emulation code */
-void
-end_term(void)
+static void
+vidc_text_cons_display(struct vis_consdisplay *da)
 {
-
-    esc = 0;
-    argc = -1;
+	int i;
+	uint8_t attr;
+	tem_char_t *data;
+	struct cgatext {
+		uint8_t ch;
+		uint8_t attr;
+	} *addr;
+
+	data = (tem_char_t *)da->data;
+	attr = (solaris_color_to_pc_color[da->bg_color & 0xf] << 4) |
+	    solaris_color_to_pc_color[da->fg_color & 0xf];
+	addr = (struct cgatext *) vgatext + (da->row * TEXT_COLS + da->col);
+
+	for (i = 0; i < da->width; i++) {
+		addr[i].ch = vga_get_cp437(data[i]);
+		addr[i].attr = attr;
+	}
 }
 
-/* Gracefully exit ESC-sequence processing in case of misunderstanding */
-void
-bail_out(int c)
+static void
+vidc_text_set_cursor(screen_pos_t row, screen_pos_t col, boolean_t visible)
 {
-    char buf[16], *ch;
-    int i;
-
-    if (esc) {
-	vidc_rawputchar('\033');
-	if (esc != '\033')
-	    vidc_rawputchar(esc);
-	for (i = 0; i <= argc; ++i) {
-	    sprintf(buf, "%d", args[i]);
-	    ch = buf;
-	    while (*ch)
-		vidc_rawputchar(*ch++);
+	uint16_t addr;
+	uint8_t msl, s, e;
+
+	msl = vga_get_crtc(VGA_REG_ADDR, VGA_CRTC_MAX_S_LN) & 0x1f;
+	s = vga_get_crtc(VGA_REG_ADDR, VGA_CRTC_CSSL) & 0xC0;
+	e = vga_get_crtc(VGA_REG_ADDR, VGA_CRTC_CESL);
+
+	if (visible == B_TRUE) {
+		addr = row * TEXT_COLS + col;
+		vga_set_crtc(VGA_REG_ADDR, VGA_CRTC_CLAH, addr >> 8);
+		vga_set_crtc(VGA_REG_ADDR, VGA_CRTC_CLAL, addr & 0xff);
+		e = msl;
+	} else {
+		s |= (1<<5);
 	}
-    }
-    vidc_rawputchar(c);
-    end_term();
+	vga_set_crtc(VGA_REG_ADDR, VGA_CRTC_CSSL, s);
+	vga_set_crtc(VGA_REG_ADDR, VGA_CRTC_CESL, e);
 }
 
 static void
-get_arg(int c)
+vidc_text_get_cursor(screen_pos_t *row, screen_pos_t *col)
 {
+	uint16_t addr;
+
+	addr = (vga_get_crtc(VGA_REG_ADDR, VGA_CRTC_CLAH) << 8) +
+	    vga_get_crtc(VGA_REG_ADDR, VGA_CRTC_CLAL);
 
-    if (argc < 0)
-	argc = 0;
-    args[argc] *= 10;
-    args[argc] += c - '0';
+	*row = addr / TEXT_COLS;
+	*col = addr % TEXT_COLS;
 }
 
-/* Emulate basic capabilities of sun-color terminal */
-void
-vidc_term_emu(int c)
+static void
+vidc_cons_cursor(struct vis_conscursor *cc)
 {
-    static int ansi_col[] = {
-	0, 4, 2, 6, 1, 5, 3, 7,
-    };
-    int t;
-    int i;
-
-    switch (esc) {
-    case 0:
-	switch (c) {
-	case '\033':
-	    esc = c;
-	    break;
-	default:
-	    vidc_rawputchar(c);
-	    break;
+	switch (cc->action) {
+	case VIS_HIDE_CURSOR:
+		if (plat_stdout_is_framebuffer())
+			gfx_fb_display_cursor(cc);
+		else
+			vidc_text_set_cursor(cc->row, cc->col, B_FALSE);
+		break;
+	case VIS_DISPLAY_CURSOR:
+		if (plat_stdout_is_framebuffer())
+			gfx_fb_display_cursor(cc);
+		else
+			vidc_text_set_cursor(cc->row, cc->col, B_TRUE);
+		break;
+	case VIS_GET_CURSOR:
+		if (plat_stdout_is_framebuffer()) {
+			cc->row = 0;
+			cc->col = 0;
+		} else {
+			vidc_text_get_cursor(&cc->row, &cc->col);
+		}
+		break;
 	}
-	break;
+}
 
-    case '\033':
+static uint8_t
+c24_to_vga(uint8_t c, uint8_t mask)
+{
 	switch (c) {
-	case '[':
-	    esc = c;
-	    args[0] = 0;
-	    argc = -1;
-	    break;
+	case 0x40:
+		return (0x15 & mask);
+	case 0x80:
+		return (0x2A & mask);
+	case 0xFF:
+		return (c & mask);
 	default:
-	    bail_out(c);
-	    break;
+		return (0);
 	}
-	break;
+}
 
-    case '[':
-	switch (c) {
-	case ';':
-	    if (argc < 0)	/* XXX */
-		argc = 0;
-	    else if (argc + 1 >= MAXARGS)
-		bail_out(c);
-	    else
-		args[++argc] = 0;
-	    break;
-	case 'A':		/* UP = \E[%dA */
-	    if (argc == 0) {
-		int x, y;
-		get_pos(&x, &y);
-		args[1] = x + 1;
-		args[0] = y - args[0] + 1;
-		CM();
-	    } else
-		bail_out(c);
-	    break;
-	case 'B':		/* DO = \E[%dB */
-	    if (argc == 0) {
-		int x, y;
-		get_pos(&x, &y);
-		args[1] = x + 1;
-		args[0] = y + args[0] + 1;
-		CM();
-	    } else
-		bail_out(c);
-	    break;
-	case 'C':		/* RI = \E[%dC */
-	    if (argc == 0) {
-		int x, y;
-		get_pos(&x, &y);
-		args[1] = args[0] + 1;
-		args[0] = y + 1;
-		CM();
-	    } else
-		bail_out(c);
-	    break;
-	case 'H':		/* ho = \E[H */
-	    if (argc < 0)
-		HO();
-	    else if (argc == 1)
-		CM();
-	    else
-		bail_out(c);
-	    break;
-	case 'J':		/* cd = \E[J */
-	    if (argc < 0)
-		CD();
-	    else
-		bail_out(c);
-	    break;
-	case 'K':
-	    if (argc < 0)
-		CL(0);
-	    else if (argc == 0)
-		switch (args[0]) {
-		case 0:
-		case 1:
-		case 2:
-			CL(args[0]);
+static int
+vidc_vbe_cons_put_cmap(struct vis_cmap *cm)
+{
+	int i, bits, rc = 0;
+	struct paletteentry pe;
+
+	bits = 1;	/* get DAC palette width */
+	rc = biosvbe_palette_format(&bits);
+	if (rc != VBE_SUCCESS)
+		return (rc);
+
+	bits = 0xFF >> (8 - (bits >> 8));
+	pe.Alignment = 0;
+	for (i = 0; i < cm->count; i++) {
+		pe.Red = c24_to_vga(cm->red[i], bits);
+		pe.Green = c24_to_vga(cm->green[i], bits);
+		pe.Blue = c24_to_vga(cm->blue[i], bits);
+		rc = vbe_set_palette(&pe,
+		    solaris_color_to_pc_color[cm->index + i]);
+		if (rc != 0)
 			break;
-		default:
-			bail_out(c);
-		}
-	    else
-		bail_out(c);
-	    break;
-	case 'm':
-	    if (argc < 0) {
-		fg_c = DEFAULT_FGCOLOR;
-		bg_c = DEFAULT_BGCOLOR;
-	    }
-	    for (i = 0; i <= argc; ++i) {
-		switch (args[i]) {
-		case 0:		/* back to normal */
-		    fg_c = DEFAULT_FGCOLOR;
-		    bg_c = DEFAULT_BGCOLOR;
-		    break;
-		case 1:		/* bold */
-		    fg_c |= 0x8;
-		    break;
-		case 4:		/* underline */
-		case 5:		/* blink */
-		    bg_c |= 0x8;
-		    break;
-		case 7:		/* reverse */
-		    t = fg_c;
-		    fg_c = bg_c;
-		    bg_c = t;
-		    break;
-		case 30: case 31: case 32: case 33:
-		case 34: case 35: case 36: case 37:
-		    fg_c = ansi_col[args[i] - 30];
-		    break;
-		case 39:	/* normal */
-		    fg_c = DEFAULT_FGCOLOR;
-		    break;
-		case 40: case 41: case 42: case 43:
-		case 44: case 45: case 46: case 47:
-		    bg_c = ansi_col[args[i] - 40];
-		    break;
-		case 49:	/* normal */
-		    bg_c = DEFAULT_BGCOLOR;
-		    break;
-		}
-	    }
-	    end_term();
-	    break;
-	default:
-	    if (isdigit(c))
-		get_arg(c);
-	    else
-		bail_out(c);
-	    break;
 	}
-	break;
+	return (rc);
+}
 
-    default:
-	bail_out(c);
-	break;
-    }
+static int
+vidc_text_cons_put_cmap(struct vis_cmap *cm __unused)
+{
+	return (1);
+}
+
+static int
+vidc_ioctl(struct console *cp, int cmd, void *data)
+{
+	struct visual_ops *ops = cp->c_private;
+
+	switch (cmd) {
+	case VIS_GETIDENTIFIER:
+		memmove(data, ops->ident, sizeof (struct vis_identifier));
+		break;
+	case VIS_DEVINIT:
+		return (ops->devinit(data));
+	case VIS_CONSCLEAR:
+		return (ops->cons_clear(data));
+	case VIS_CONSCOPY:
+		ops->cons_copy(data);
+		break;
+	case VIS_CONSDISPLAY:
+		ops->cons_display(data);
+		break;
+	case VIS_CONSCURSOR:
+		ops->cons_cursor(data);
+		break;
+	case VIS_PUTCMAP:
+		ops->cons_put_cmap(data);
+		break;
+	case VIS_GETCMAP:
+	default:
+		return (EINVAL);
+	}
+	return (0);
 }
-#endif
 
 static void
-vidc_putchar(struct console *cp, int c)
+vidc_probe(struct console *cp)
 {
-#ifdef TERM_EMU
-    vidc_term_emu(c);
-#else
-    vidc_rawputchar(c);
+
+	/* look for a keyboard */
+#if KEYBOARD_PROBE
+	if (probe_keyboard())
 #endif
+	{
+		cp->c_flags |= C_PRESENTIN;
+	}
+
+	/* XXX for now, always assume we can do BIOS screen output */
+	cp->c_flags |= C_PRESENTOUT;
+	vbe_init();
+	tem = NULL;
 }
 
 static int
-vidc_getchar(struct console *cp)
+vidc_init(struct console *cp, int arg)
 {
-    int i, c;
+	int i, rc;
+
+	if (vidc_started && arg == 0)
+		return (0);
+
+	vidc_started = 1;
+	gfx_framework_init(&fb_ops);
+
+	/*
+	 * Check Miscellaneous Output Register (Read at 3CCh, Write at 3C2h)
+	 * for bit 1 (Input/Output Address Select), which means
+	 * color/graphics adapter.
+	 */
+	if (vga_get_reg(VGA_REG_ADDR, VGA_MISC_R) & VGA_MISC_IOA_SEL)
+		vgatext = (uint16_t *) PTOV(VGA_MEM_ADDR + VGA_COLOR_BASE);
+	else
+		vgatext = (uint16_t *) PTOV(VGA_MEM_ADDR + VGA_MONO_BASE);
+
+	/* set 16bit colors */
+	i = vga_get_atr(VGA_REG_ADDR, VGA_ATR_MODE);
+	i &= ~VGA_ATR_MODE_BLINK;
+	i &= ~VGA_ATR_MODE_9WIDE;
+	vga_set_atr(VGA_REG_ADDR, VGA_ATR_MODE, i);
+
+	plat_tem_hide_prom_cursor();
+
+	memset(keybuf, 0, KEYBUFSZ);
+
+	/* default to text mode */
+	cp->c_private = &text_ops;
+
+	if (vbe_available()) {
+		rc = vbe_default_mode();
+		/* if rc is not legal VBE mode, use text mode */
+		if (VBE_VALID_MODE(rc)) {
+			if (vbe_set_mode(rc) == 0)
+				cp->c_private = &fb_ops;
+			else
+				bios_set_text_mode(VGA_TEXT_MODE);
+		}
+	}
 
-    for (i = 0; i < KEYBUFSZ; i++) {
-	if (keybuf[i] != 0) {
-	    c = keybuf[i];
-	    keybuf[i] = 0;
-	    return (c);
+	rc = tem_info_init(cp);
+
+	if (rc != 0) {
+		bios_set_text_mode(3);
+		cp->c_private = &text_ops;
+		rc = tem_info_init(cp); /* try again */
+	}
+	if (rc == 0 && tem == NULL) {
+		tem = tem_init();
+		if (tem != NULL)
+			tem_activate(tem, B_TRUE);
 	}
-    }
 
-    if (vidc_ischar(cp)) {
+	for (i = 0; i < 10 && vidc_ischar(cp); i++)
+		(void)vidc_getchar(cp);
+
+	return (0);	/* XXX reinit? */
+}
+
+static void
+vidc_biosputchar(int c)
+{
 	v86.ctl = 0;
-	v86.addr = 0x16;
-	v86.eax = 0x0;
+	v86.addr = 0x10;
+	v86.eax = 0xe00 | (c & 0xff);
+	v86.ebx = 0x7;
 	v86int();
-	if ((v86.eax & 0xff) != 0) {
-		return (v86.eax & 0xff);
+}
+
+static void
+vidc_putchar(struct console *cp __unused, int c)
+{
+	uint8_t buf = c;
+
+	/* make sure we have some console output, support for panic() */
+	if (tem == NULL)
+		vidc_biosputchar(c);
+	else
+		tem_write(tem, &buf, sizeof (buf));
+}
+
+static int
+vidc_getchar(struct console *cp)
+{
+	int i, c;
+
+	for (i = 0; i < KEYBUFSZ; i++) {
+		if (keybuf[i] != 0) {
+			c = keybuf[i];
+			keybuf[i] = 0;
+			return (c);
+		}
 	}
 
-	/* extended keys */
-	switch (v86.eax & 0xff00) {
-	case 0x4800:	/* up */
-		keybuf[0] = '[';
-		keybuf[1] = 'A';
-		return (0x1b);	/* esc */
-	case 0x4b00:	/* left */
-		keybuf[0] = '[';
-		keybuf[1] = 'D';
-		return (0x1b);	/* esc */
-	case 0x4d00:	/* right */
-		keybuf[0] = '[';
-		keybuf[1] = 'C';
-		return (0x1b);	/* esc */
-	case 0x5000:	/* down */
-		keybuf[0] = '[';
-		keybuf[1] = 'B';
-		return (0x1b);	/* esc */
-	default:
+	if (vidc_ischar(cp)) {
+		v86.ctl = 0;
+		v86.addr = 0x16;
+		v86.eax = 0x0;
+		v86int();
+		if ((v86.eax & 0xff) != 0) {
+			return (v86.eax & 0xff);
+		}
+
+		/* extended keys */
+		switch (v86.eax & 0xff00) {
+		case 0x4800:	/* up */
+			keybuf[0] = '[';
+			keybuf[1] = 'A';
+			return (0x1b);	/* esc */
+		case 0x4b00:	/* left */
+			keybuf[0] = '[';
+			keybuf[1] = 'D';
+			return (0x1b);	/* esc */
+		case 0x4d00:	/* right */
+			keybuf[0] = '[';
+			keybuf[1] = 'C';
+			return (0x1b);	/* esc */
+		case 0x5000:	/* down */
+			keybuf[0] = '[';
+			keybuf[1] = 'B';
+			return (0x1b);	/* esc */
+		default:
+			return (-1);
+		}
+	} else {
 		return (-1);
 	}
-    } else {
-	return (-1);
-    }
 }
 
 static int
-vidc_ischar(struct console *cp)
+vidc_ischar(struct console *cp __unused)
 {
-    int i;
+	int i;
 
-    for (i = 0; i < KEYBUFSZ; i++) {
-	if (keybuf[i] != 0) {
-	    return (1);
+	for (i = 0; i < KEYBUFSZ; i++) {
+		if (keybuf[i] != 0) {
+			return (1);
+		}
 	}
-    }
 
-    v86.ctl = V86_FLAGS;
-    v86.addr = 0x16;
-    v86.eax = 0x100;
-    v86int();
-    return (!V86_ZR(v86.efl));
+	v86.ctl = V86_FLAGS;
+	v86.addr = 0x16;
+	v86.eax = 0x100;
+	v86int();
+	return (!V86_ZR(v86.efl));
 }
 
 #if KEYBOARD_PROBE
@@ -654,10 +791,10 @@ vidc_ischar(struct console *cp)
 #define IO_KBD		0x060		/* 8042 Keyboard */
 
 /* selected defines from kbdio.h */
-#define KBD_STATUS_PORT 	4	/* status port, read */
-#define KBD_DATA_PORT		0	/* data port, read/write 
+#define	KBD_STATUS_PORT		4	/* status port, read */
+#define KBD_DATA_PORT		0	/* data port, read/write
 					 * also used as keyboard command
-					 * and mouse command port 
+					 * and mouse command port
 					 */
 #define KBDC_ECHO		0x00ee
 #define KBDS_ANY_BUFFER_FULL	0x0001
@@ -668,13 +805,13 @@ vidc_ischar(struct console *cp)
 static void
 delay7(void)
 {
-    /* 
-     * I know this is broken, but no timer is available yet at this stage...
-     * See also comments in `delay1ms()'.
-     */
-    inb(IO_DUMMY); inb(IO_DUMMY);
-    inb(IO_DUMMY); inb(IO_DUMMY);
-    inb(IO_DUMMY); inb(IO_DUMMY);
+	/*
+	 * I know this is broken, but no timer is available yet at this stage...
+	 * See also comments in `delay1ms()'.
+	 */
+	inb(IO_DUMMY); inb(IO_DUMMY);
+	inb(IO_DUMMY); inb(IO_DUMMY);
+	inb(IO_DUMMY); inb(IO_DUMMY);
 }
 
 /*
@@ -689,12 +826,12 @@ delay7(void)
 static void
 delay1ms(void)
 {
-    int i = 800;
-    while (--i >= 0)
-	(void)inb(0x84);
+	int i = 800;
+	while (--i >= 0)
+		(void)inb(0x84);
 }
 
-/* 
+/*
  * We use the presence/absence of a keyboard to determine whether the internal
  * console can be used for input.
  *
@@ -705,55 +842,57 @@ delay1ms(void)
 static int
 probe_keyboard(void)
 {
-    int retry = PROBE_MAXRETRY;
-    int wait;
-    int i;
-
-    while (--retry >= 0) {
-	/* flush any noise */
-	while (inb(IO_KBD + KBD_STATUS_PORT) & KBDS_ANY_BUFFER_FULL) {
-	    delay7();
-	    inb(IO_KBD + KBD_DATA_PORT);
-	    delay1ms();
-	}
-
-	/* wait until the controller can accept a command */
-	for (wait = PROBE_MAXWAIT; wait > 0; --wait) {
-	    if (((i = inb(IO_KBD + KBD_STATUS_PORT)) 
-                & (KBDS_INPUT_BUFFER_FULL | KBDS_ANY_BUFFER_FULL)) == 0)
-		break;
-	    if (i & KBDS_ANY_BUFFER_FULL) {
-		delay7();
-	        inb(IO_KBD + KBD_DATA_PORT);
-	    }
-	    delay1ms();
-	}
-	if (wait <= 0)
-	    continue;
-
-	/* send the ECHO command */
-	outb(IO_KBD + KBD_DATA_PORT, KBDC_ECHO);
+	int retry = PROBE_MAXRETRY;
+	int wait;
+	int i;
+
+	while (--retry >= 0) {
+		/* flush any noise */
+		while (inb(IO_KBD + KBD_STATUS_PORT) & KBDS_ANY_BUFFER_FULL) {
+			delay7();
+			inb(IO_KBD + KBD_DATA_PORT);
+			delay1ms();
+		}
 
-	/* wait for a response */
-	for (wait = PROBE_MAXWAIT; wait > 0; --wait) {
-	     if (inb(IO_KBD + KBD_STATUS_PORT) & KBDS_ANY_BUFFER_FULL)
-		 break;
-	     delay1ms();
-	}
-	if (wait <= 0)
-	    continue;
+		/* wait until the controller can accept a command */
+		for (wait = PROBE_MAXWAIT; wait > 0; --wait) {
+			if (((i = inb(IO_KBD + KBD_STATUS_PORT)) &
+			    (KBDS_INPUT_BUFFER_FULL | KBDS_ANY_BUFFER_FULL))
+			    == 0)
+				break;
+			if (i & KBDS_ANY_BUFFER_FULL) {
+				delay7();
+				inb(IO_KBD + KBD_DATA_PORT);
+			}
+			delay1ms();
+		}
+		if (wait <= 0)
+			continue;
+
+		/* send the ECHO command */
+		outb(IO_KBD + KBD_DATA_PORT, KBDC_ECHO);
+
+		/* wait for a response */
+		for (wait = PROBE_MAXWAIT; wait > 0; --wait) {
+			if (inb(IO_KBD + KBD_STATUS_PORT) &
+			    KBDS_ANY_BUFFER_FULL)
+				break;
+			delay1ms();
+		}
+		if (wait <= 0)
+			continue;
 
-	delay7();
-	i = inb(IO_KBD + KBD_DATA_PORT);
+		delay7();
+		i = inb(IO_KBD + KBD_DATA_PORT);
 #ifdef PROBE_KBD_BEBUG
-        printf("probe_keyboard: got 0x%x.\n", i);
+		printf("probe_keyboard: got 0x%x.\n", i);
 #endif
-	if (i == KBD_ECHO) {
-	    /* got the right answer */
-	    return (1);
+		if (i == KBD_ECHO) {
+			/* got the right answer */
+			return (1);
+		}
 	}
-    }
 
-    return (0);
+	return (0);
 }
 #endif /* KEYBOARD_PROBE */
diff --git a/usr/src/boot/sys/boot/i386/loader/Makefile b/usr/src/boot/sys/boot/i386/loader/Makefile
index a6ef330289..84eb91bfde 100644
--- a/usr/src/boot/sys/boot/i386/loader/Makefile
+++ b/usr/src/boot/sys/boot/i386/loader/Makefile
@@ -16,6 +16,7 @@
 
 include $(SRC)/Makefile.master
 include $(SRC)/boot/Makefile.version
+include $(SRC)/boot/sys/boot/Makefile.inc
 
 CFLAGS=		-Os -fno-reorder-functions
 CPPFLAGS=	-D_STANDALONE -nostdinc -I../../../../include -I../../..
@@ -50,7 +51,6 @@ all: ${LOADER} loader.help
 install: all $(ROOTBOOTLOADER)
 
 PROG=		${LOADER}.sym
-INTERNALPROG=
 
 # architecture-specific loader code
 SRCS=		main.c conf.c vers.c chain.c
@@ -66,6 +66,7 @@ SRCS +=	boot.c commands.c console.c devopen.c interp.c
 SRCS +=	interp_backslash.c interp_parse.c ls.c misc.c
 SRCS +=	module.c panic.c linenoise.c multiboot2.c
 SRCS +=	zfs_cmd.c
+SRCS +=	font.c $(FONT).c list.c tem.c
 
 SRCS +=	load_elf32.c load_elf32_obj.c reloc_elf32.c
 SRCS +=	load_elf64.c load_elf64_obj.c reloc_elf64.c
@@ -89,6 +90,7 @@ CPPFLAGS +=	-I../../common
 CPPFLAGS +=	-I.
 
 CLEANFILES=	vers.c ${LOADER} ${LOADER}.sym ${LOADER}.bin loader.help
+CLEANFILES +=	$(FONT).c
 
 CFLAGS +=	-Wall
 LDFLAGS=	-static -Ttext 0x0
@@ -166,6 +168,15 @@ install: all $(ROOT_BOOT_DEFAULTS) $(ROOT_BOOT_FORTH) \
 %.o:	../../common/linenoise/%.c
 	$(COMPILE.c) -o $@ $<
 
+%.o: $(SRC)/common/list/%.c
+	$(COMPILE.c) -DNDEBUG $<
+
+%.o: $(SRC)/common/font/%.c
+	$(COMPILE.c) $<
+
+$(FONT).c: $(FONT_DIR)/$(FONT_SRC)
+	$(VTFONTCVT) -f compressed-source -o $@ $(FONT_DIR)/$(FONT_SRC)
+
 $(ROOT_BOOT)/%: ../../forth/%
 	$(INS.file)
 
diff --git a/usr/src/boot/sys/boot/i386/loader/chain.c b/usr/src/boot/sys/boot/i386/loader/chain.c
index 04658076bb..2f32a9adf0 100644
--- a/usr/src/boot/sys/boot/i386/loader/chain.c
+++ b/usr/src/boot/sys/boot/i386/loader/chain.c
@@ -27,6 +27,7 @@
 #include <sys/diskmbr.h>
 
 #include "bootstrap.h"
+#include "libi386/vbe.h"
 #include "libi386/libi386.h"
 #include "btxv86.h"
 
@@ -96,6 +97,7 @@ command_chain(int argc, char *argv[])
 		return (CMD_ERROR);
 	}
 
+	bios_set_text_mode(3);
 	relocater_data[0].src = mem;
 	relocater_data[0].dest = 0x7C00;
 	relocater_data[0].size = size;
diff --git a/usr/src/boot/sys/boot/i386/loader/main.c b/usr/src/boot/sys/boot/i386/loader/main.c
index cd605f1002..6f96c6a757 100644
--- a/usr/src/boot/sys/boot/i386/loader/main.c
+++ b/usr/src/boot/sys/boot/i386/loader/main.c
@@ -160,6 +160,7 @@ main(void)
     for (i = 0; devsw[i] != NULL; i++)
 	if (devsw[i]->dv_init != NULL)
 	    (devsw[i]->dv_init)();
+
     printf("BIOS %dkB/%dkB available memory\n", bios_basemem / 1024, bios_extmem / 1024);
     if (initial_bootinfo != NULL) {
 	initial_bootinfo->bi_basemem = bios_basemem / 1024;
@@ -177,9 +178,8 @@ main(void)
 
     printf("\n%s", bootprog_info);
 
-    extract_currdev();				/* set $currdev and $loaddev */
-    setenv("LINES", "24", 1);			/* optional */
-    setenv("COLUMNS", "80", 1);			/* optional */
+    extract_currdev();			/* set $currdev and $loaddev */
+    autoload_font();			/* Set up the font list for console. */
 
     bi_isadir();
     bios_getsmap();
diff --git a/usr/src/boot/sys/boot/libficl/Makefile.com b/usr/src/boot/sys/boot/libficl/Makefile.com
index 7ea9c354fe..4d58aa5755 100644
--- a/usr/src/boot/sys/boot/libficl/Makefile.com
+++ b/usr/src/boot/sys/boot/libficl/Makefile.com
@@ -16,10 +16,14 @@
 
 CC=		$(GNUC_ROOT)/bin/gcc
 FICLDIR=	$(SRC)/common/ficl
+PNGLITE=	$(SRC)/common/pnglite
 
 CPPFLAGS= -nostdinc -D_STANDALONE -I. -I.. -I../../../../include
 CPPFLAGS += -I../../../../lib/libstand
-CPPFLAGS += -I../../..  -I$(FICLDIR) -I../../common
+CPPFLAGS += -I../../..  -I$(FICLDIR) -I../../common -I$(PNGLITE)
+
+# For multiboot2.h, must be last, to avoid conflicts
+CPPFLAGS += -I$(SRC)/uts/common
 
 CFLAGS=		-Os -fPIC -Wall -ffreestanding -mno-mmx -mno-3dnow -mno-sse
 CFLAGS +=	-mno-sse2 -mno-sse3 -msoft-float -std=gnu99
diff --git a/usr/src/boot/sys/boot/ofw/common/main.c b/usr/src/boot/sys/boot/ofw/common/main.c
index 0f6ed132ea..a927203a76 100644
--- a/usr/src/boot/sys/boot/ofw/common/main.c
+++ b/usr/src/boot/sys/boot/ofw/common/main.c
@@ -147,7 +147,7 @@ main(int (*openfirm)(void *))
 			   ofw_setcurrdev, env_nounset);
 	env_setenv("loaddev", EV_VOLATILE, bootpath, env_noset,
 	    env_nounset);
-	setenv("LINES", "24", 1);		/* optional */
+	setenv("screen-#rows", "24", 1);		/* optional */
 
 	archsw.arch_getdev = ofw_getdev;
 	archsw.arch_copyin = ofw_copyin;
diff --git a/usr/src/boot/sys/boot/uboot/common/main.c b/usr/src/boot/sys/boot/uboot/common/main.c
index 3297aa4721..704a5a8708 100644
--- a/usr/src/boot/sys/boot/uboot/common/main.c
+++ b/usr/src/boot/sys/boot/uboot/common/main.c
@@ -482,7 +482,7 @@ main(void)
 	env_setenv("loaddev", EV_VOLATILE, ldev, env_noset, env_nounset);
 	printf("Booting from %s\n", ldev);
 
-	setenv("LINES", "24", 1);		/* optional */
+	setenv("screen-#rows", "24", 1);		/* optional */
 	setenv("prompt", "loader>", 1);
 
 	archsw.arch_loadaddr = uboot_loadaddr;
diff --git a/usr/src/boot/sys/boot/userboot/userboot/main.c b/usr/src/boot/sys/boot/userboot/userboot/main.c
index 3a53ae2b94..cb8d87ec59 100644
--- a/usr/src/boot/sys/boot/userboot/userboot/main.c
+++ b/usr/src/boot/sys/boot/userboot/userboot/main.c
@@ -98,7 +98,7 @@ loader_main(struct loader_callbacks *cb, void *arg, int version, int ndisks)
 	printf("Memory: %ld k\n", memsize() / 1024);
 #endif
 
-	setenv("LINES", "24", 1);	/* optional */
+	setenv("screen-#rows", "24", 1);	/* optional */
 
 	/*
 	 * Set custom environment variables
diff --git a/usr/src/boot/sys/boot/zfs/zfs.c b/usr/src/boot/sys/boot/zfs/zfs.c
index 1f68b012b2..471fd6b32f 100644
--- a/usr/src/boot/sys/boot/zfs/zfs.c
+++ b/usr/src/boot/sys/boot/zfs/zfs.c
@@ -30,15 +30,16 @@
  *	Stand-alone file reading package.
  */
 
+#include <stand.h>
 #include <sys/disk.h>
 #include <sys/param.h>
 #include <sys/time.h>
 #include <sys/queue.h>
+#include <disk.h>
 #include <part.h>
 #include <stddef.h>
 #include <stdarg.h>
 #include <string.h>
-#include <stand.h>
 #include <bootstrap.h>
 #include <inttypes.h>
 
@@ -521,6 +522,7 @@ zfs_probe_partition(void *arg, const char *partname,
 int
 zfs_probe_dev(const char *devname, uint64_t *pool_guid)
 {
+	struct disk_devdesc *dev;
 	struct ptable *table;
 	struct zfs_probe_args pa;
 	uint64_t mediasz;
@@ -531,10 +533,22 @@ zfs_probe_dev(const char *devname, uint64_t *pool_guid)
 	pa.fd = open(devname, O_RDONLY);
 	if (pa.fd == -1)
 		return (ENXIO);
-	/* Probe the whole disk */
-	ret = zfs_probe(pa.fd, pool_guid);
-	if (ret == 0)
-		return (0);
+	/*
+	 * We will not probe the whole disk, we can not boot from such
+	 * disks and some systems will misreport the disk sizes and will
+	 * hang while accessing the disk.
+	 */
+	if (archsw.arch_getdev((void **)&dev, devname, NULL) == 0) {
+		int partition = dev->d_partition;
+		int slice = dev->d_slice;
+
+		free(dev);
+		if (partition != -1 && slice != -1) {
+			ret = zfs_probe(pa.fd, pool_guid);
+			if (ret == 0)
+				return (0);
+		}
+	}
 
 	/* Probe each partition */
 	ret = ioctl(pa.fd, DIOCGMEDIASIZE, &mediasz);
diff --git a/usr/src/boot/sys/cddl/boot/zfs/zfsimpl.h b/usr/src/boot/sys/cddl/boot/zfs/zfsimpl.h
index 8cd5cf8f2b..ed82362221 100644
--- a/usr/src/boot/sys/cddl/boot/zfs/zfsimpl.h
+++ b/usr/src/boot/sys/cddl/boot/zfs/zfsimpl.h
@@ -63,8 +63,6 @@
 
 #define _NOTE(s)
 
-typedef enum { B_FALSE, B_TRUE } boolean_t;
-
 /* CRC64 table */
 #define	ZFS_CRC64_POLY	0xC96C5795D7870F42ULL	/* ECMA-182, reflected form */
 
@@ -1243,10 +1241,10 @@ typedef struct mzap_phys {
  * 1<<FZAP_BLOCK_SHIFT byte blocks. The layout looks like one of:
  *
  * ptrtbl fits in first block:
- * 	[zap_phys_t zap_ptrtbl_shift < 6] [zap_leaf_t] ...
+ *	[zap_phys_t zap_ptrtbl_shift < 6] [zap_leaf_t] ...
  *
  * ptrtbl too big for first block:
- * 	[zap_phys_t zap_ptrtbl_shift >= 6] [zap_leaf_t] [ptrtbl] ...
+ *	[zap_phys_t zap_ptrtbl_shift >= 6] [zap_leaf_t] [ptrtbl] ...
  *
  */
 
@@ -1396,7 +1394,7 @@ typedef struct zap_leaf_phys {
 
 typedef union zap_leaf_chunk {
 	struct zap_leaf_entry {
-		uint8_t le_type; 		/* always ZAP_CHUNK_ENTRY */
+		uint8_t le_type;		/* always ZAP_CHUNK_ENTRY */
 		uint8_t le_value_intlen;	/* size of ints */
 		uint16_t le_next;		/* next entry in hash chain */
 		uint16_t le_name_chunk;		/* first chunk of the name */
diff --git a/usr/src/boot/sys/sys/font.h b/usr/src/boot/sys/sys/font.h
new file mode 100644
index 0000000000..4ff7160b52
--- /dev/null
+++ b/usr/src/boot/sys/sys/font.h
@@ -0,0 +1,137 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef _SYS_FONT_H
+#define	_SYS_FONT_H
+
+#include <sys/queue.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum vfnt_map {
+	VFNT_MAP_NORMAL = 0,	/* Normal font. */
+	VFNT_MAP_NORMAL_RH,	/* Normal font right hand. */
+	VFNT_MAP_BOLD,		/* Bold font. */
+	VFNT_MAP_BOLD_RH,	/* Bold font right hand. */
+	VFNT_MAPS		/* Number of maps. */
+};
+
+/*
+ * If the custom console font was loaded, pass it for kernel as an module.
+ * We do not just load the font file, as the font file needs to be processed,
+ * and the early boot has very little resources. So we just set up the
+ * needed structures and make an copy of the byte arrays.
+ *
+ * Note we can not copy the structures one to one due to the pointer size,
+ * so we record the data by using fixed size structure.
+ */
+struct font_info {
+        int32_t fi_checksum;
+        uint32_t fi_width;
+        uint32_t fi_height;
+        uint32_t fi_bitmap_size;
+        uint32_t fi_map_count[VFNT_MAPS];
+};
+
+struct font_map {
+	uint32_t font_src;	/* Source glyph. */
+	uint16_t font_dst;	/* Target glyph. */
+	uint16_t font_len;	/* The number of glyphs in sequence. */
+};
+
+/* Any unknown glyph is mapped as first (offset 0) glyph in bitmap. */
+struct font {
+	struct font_map	*vf_map[VFNT_MAPS];	/* Mapping tables. */
+	uint8_t		*vf_bytes;		/* Font bitmap data. */
+	uint32_t	vf_width;		/* Glyph width. */
+	uint32_t	vf_height;		/* Glyph height. */
+	uint32_t	vf_map_count[VFNT_MAPS];	/* Entries in map */
+};
+
+typedef	struct  bitmap_data {
+	uint32_t	width;
+	uint32_t	height;
+	uint32_t	compressed_size;
+	uint32_t	uncompressed_size;
+	uint8_t		*compressed_data;
+	struct font	*font;
+} bitmap_data_t;
+
+typedef enum {
+	FONT_AUTO,
+	FONT_MANUAL,
+	FONT_BOOT
+} FONT_FLAGS;
+
+struct fontlist {
+	char		*font_name;
+	FONT_FLAGS	font_flags;
+	bitmap_data_t	*font_data;
+	bitmap_data_t   *(*font_load)(char *);
+	STAILQ_ENTRY(fontlist) font_next;
+};
+
+#define	FONT_HEADER_MAGIC	"VFNT0002"
+struct font_header {
+	uint8_t		fh_magic[8];
+	uint8_t		fh_width;
+	uint8_t		fh_height;
+	uint16_t	fh_pad;
+	uint32_t	fh_glyph_count;
+	uint32_t	fh_map_count[4];
+} __attribute__((__packed__));
+
+typedef STAILQ_HEAD(font_list, fontlist) font_list_t;
+extern font_list_t fonts;
+
+/*
+ * Built in fonts. We are using Gallant as default on sparc to keep
+ * smooth transition from prom and 8x16 on x86, for vga text mode.
+ */
+#ifdef sparc
+#define	DEFAULT_FONT_DATA	font_data_12x22
+extern bitmap_data_t font_data_12x22;
+#else
+#define	DEFAULT_FONT_DATA	font_data_8x16
+extern bitmap_data_t font_data_8x16;
+#endif
+#define	BORDER_PIXELS		10	/* space from screen border */
+
+bitmap_data_t *set_font(short *, short *, short, short);
+const uint8_t *font_lookup(const struct font *, uint32_t);
+void font_bit_to_pix4(struct font *, uint8_t *, uint32_t, uint8_t, uint8_t);
+void font_bit_to_pix8(struct font *, uint8_t *, uint32_t, uint8_t, uint8_t);
+void font_bit_to_pix16(struct font *, uint16_t *, uint32_t, uint16_t, uint16_t);
+void font_bit_to_pix24(struct font *, uint8_t *, uint32_t, uint32_t, uint32_t);
+void font_bit_to_pix32(struct font *, uint32_t *, uint32_t, uint32_t, uint32_t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_SYS_FONT_H */
diff --git a/usr/src/boot/sys/sys/sysmacros.h b/usr/src/boot/sys/sys/sysmacros.h
new file mode 100644
index 0000000000..8f7989ae1e
--- /dev/null
+++ b/usr/src/boot/sys/sys/sysmacros.h
@@ -0,0 +1,6 @@
+
+/*
+ * Compatibility header for illumos.
+ */
+#include <stand.h>
+#include <sys/param.h>
diff --git a/usr/src/boot/sys/sys/tem.h b/usr/src/boot/sys/sys/tem.h
new file mode 100644
index 0000000000..fef3277c50
--- /dev/null
+++ b/usr/src/boot/sys/sys/tem.h
@@ -0,0 +1,74 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*	Copyright (c) 1990, 1991 UNIX System Laboratories, Inc.	*/
+
+/*	Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T	*/
+/*		All Rights Reserved	*/
+
+#ifndef	_SYS_TEM_H
+#define	_SYS_TEM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+#include <sys/visual_io.h>
+
+typedef uint8_t text_color_t;
+
+typedef struct __tem_modechg_cb_arg *tem_modechg_cb_arg_t;
+typedef void (*tem_modechg_cb_t) (tem_modechg_cb_arg_t arg);
+typedef	struct __tem_vt_state *tem_vt_state_t;
+
+/*
+ * tems_* fuctions mean that they just operate on the common soft state
+ * (tem_state_t), and tem_* functions mean that they operate on the
+ * per-tem structure (tem_vt_state).
+ */
+int	tems_cls(struct vis_consclear *);
+void	tems_display(struct vis_consdisplay *);
+void	tems_copy(struct vis_conscopy *);
+void	tems_cursor(struct vis_conscursor *);
+
+int	tem_initialized(tem_vt_state_t);
+
+tem_vt_state_t tem_init(void);
+
+int	tem_info_init(struct console *);
+void	tem_write(tem_vt_state_t, uint8_t *, ssize_t);
+void	tem_get_size(uint16_t *, uint16_t *, uint16_t *, uint16_t *);
+void	tem_save_state(void);
+void	tem_register_modechg_cb(tem_modechg_cb_t, tem_modechg_cb_arg_t);
+void	tem_activate(tem_vt_state_t, boolean_t);
+void	tem_switch(tem_vt_state_t, tem_vt_state_t);
+void	tem_get_colors(tem_vt_state_t, text_color_t *, text_color_t *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_TEM_H */
diff --git a/usr/src/boot/sys/sys/tem_impl.h b/usr/src/boot/sys/sys/tem_impl.h
new file mode 100644
index 0000000000..ea4d0f2b3b
--- /dev/null
+++ b/usr/src/boot/sys/sys/tem_impl.h
@@ -0,0 +1,286 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+/*	Copyright (c) 1990, 1991 UNIX System Laboratories, Inc.	*/
+
+/*	Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T	*/
+/*		All Rights Reserved	*/
+
+#ifndef	_SYS_TEM_H
+#define	_SYS_TEM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+#include <sys/visual_io.h>
+#include <sys/font.h>
+#include <sys/list.h>
+#include <sys/tem.h>
+#include <bootstrap.h>
+#include <stdbool.h>
+
+/*
+ * Definitions for ANSI x3.64 terminal control language parser.
+ * With UTF-8 support we use 32-bit value for Unicode codepoints.
+ *
+ * However, as we only need 21 bits for unicode char, we will use the
+ * rest of the bits for attributes, so we can save memory and
+ * have combined attribute+char in screen buffer. This will also allow us
+ * to keep better track about attributes and apply other optimizations.
+ *
+ *  Bits  Meaning
+ *  0-20  char
+ * 21-31  attributes
+ */
+
+typedef uint32_t tem_char_t;	/* 32bit char to support UTF-8 */
+#define	TEM_ATTR_MASK		0x7FF
+#define	TEM_CHAR(c)		((c) & 0x1fffff)
+#define	TEM_CHAR_ATTR(c)	(((c) >> 21) & TEM_ATTR_MASK)
+#define	TEM_ATTR(c)		(((c) & TEM_ATTR_MASK) << 21)
+
+#define	TEM_MAXPARAMS	5	/* maximum number of ANSI paramters */
+#define	TEM_MAXTAB	40	/* maximum number of tab stops */
+#define	TEM_MAXFKEY	30	/* max length of function key with <ESC>Q */
+#define	MAX_TEM		2	/* max number of loadable terminal emulators */
+
+#define	TEM_SCROLL_UP		0
+#define	TEM_SCROLL_DOWN		1
+#define	TEM_SHIFT_LEFT		0
+#define	TEM_SHIFT_RIGHT		1
+
+/* Attributes 0-0x7ff */
+#define	TEM_ATTR_NORMAL		0x0000
+#define	TEM_ATTR_REVERSE	0x0001
+#define	TEM_ATTR_BOLD		0x0002
+#define	TEM_ATTR_BLINK		0x0004
+#define	TEM_ATTR_UNDERLINE	0x0008
+#define	TEM_ATTR_SCREEN_REVERSE	0x0010
+#define	TEM_ATTR_BRIGHT_FG	0x0020
+#define	TEM_ATTR_BRIGHT_BG	0x0040
+#define	TEM_ATTR_TRANSPARENT	0x0080
+#define	TEM_ATTR_IMAGE		0x0100
+
+#define	ANSI_COLOR_BLACK	0
+#define	ANSI_COLOR_RED		1
+#define	ANSI_COLOR_GREEN	2
+#define	ANSI_COLOR_YELLOW	3
+#define	ANSI_COLOR_BLUE		4
+#define	ANSI_COLOR_MAGENTA	5
+#define	ANSI_COLOR_CYAN		6
+#define	ANSI_COLOR_WHITE	7
+
+#define	TEM_TEXT_WHITE		0
+#define	TEM_TEXT_BLACK		1
+#define	TEM_TEXT_BLACK24_RED	0x00
+#define	TEM_TEXT_BLACK24_GREEN	0x00
+#define	TEM_TEXT_BLACK24_BLUE	0x00
+#define	TEM_TEXT_WHITE24_RED	0xff
+#define	TEM_TEXT_WHITE24_GREEN	0xff
+#define	TEM_TEXT_WHITE24_BLUE	0xff
+
+#define	A_STATE_START			0
+#define	A_STATE_ESC			1
+#define	A_STATE_CSI			2
+#define	A_STATE_CSI_QMARK		3
+#define	A_STATE_CSI_EQUAL		4
+
+/*
+ * Default number of rows and columns
+ */
+#define	TEM_DEFAULT_ROWS	25
+#define	TEM_DEFAULT_COLS	80
+
+/*
+ * Default foreground/background color
+ */
+
+#define	DEFAULT_ANSI_FOREGROUND	ANSI_COLOR_BLACK
+#define	DEFAULT_ANSI_BACKGROUND	ANSI_COLOR_WHITE
+
+
+#define	BUF_LEN		160 /* Two lines of data can be processed at a time */
+
+typedef uint8_t text_color_t;
+typedef uint16_t text_attr_t;
+
+typedef struct tem_color {
+	text_color_t	fg_color;
+	text_color_t	bg_color;
+	text_attr_t	a_flags;
+} tem_color_t;
+
+struct tem_pix_pos {
+	screen_pos_t	x;
+	screen_pos_t	y;
+};
+
+struct tem_char_pos {
+	screen_pos_t	col;
+	screen_pos_t	row;
+};
+
+struct tem_size {
+	screen_size_t	width;
+	screen_size_t	height;
+};
+
+typedef struct {
+	uint8_t red[16];
+	uint8_t green[16];
+	uint8_t blue[16];
+} text_cmap_t;
+
+/* Combined color and 32bit tem char */
+typedef struct term_char {
+	text_color_t	tc_fg_color;
+	text_color_t	tc_bg_color;
+	tem_char_t	tc_char;
+} term_char_t;
+
+/* Color translation tables. */
+extern const uint8_t dim_xlate[8];
+extern const uint8_t brt_xlate[8];
+extern const uint8_t solaris_color_to_pc_color[16];
+extern const text_cmap_t cmap4_to_24;
+
+/*
+ * State structure for each virtual terminal emulator
+ */
+struct tem_vt_state {
+	uint8_t		tvs_fbmode;	/* framebuffer mode */
+	text_attr_t	tvs_flags;	/* flags for this x3.64 terminal */
+	int		tvs_state;	/* state in output esc seq processing */
+	bool		tvs_gotparam;	/* does output esc seq have a param */
+
+	int	tvs_curparam;	/* current param # of output esc seq */
+	int	tvs_paramval;	/* value of current param */
+	int	tvs_params[TEM_MAXPARAMS];  /* parameters of output esc seq */
+	screen_pos_t	tvs_tabs[TEM_MAXTAB];	/* tab stops */
+	int	tvs_ntabs;		/* number of tabs used */
+	int	tvs_nscroll;		/* number of lines to scroll */
+
+	struct tem_char_pos tvs_s_cursor;	/* start cursor position */
+	struct tem_char_pos tvs_c_cursor;	/* current cursor position */
+	struct tem_char_pos tvs_r_cursor;	/* remembered cursor position */
+
+	term_char_t	*tvs_outbuf;	/* place to keep incomplete lines */
+	int		tvs_outindex;	/* index into a_outbuf */
+	void		*tvs_pix_data;	/* pointer to tmp bitmap area */
+	int		tvs_pix_data_size;
+	text_color_t	tvs_fg_color;
+	text_color_t	tvs_bg_color;
+	int		tvs_first_line;	/* kernel console output begins */
+
+	term_char_t	*tvs_screen_buf;	/* whole screen buffer */
+	unsigned	tvs_utf8_left;		/* UTF-8 code points */
+	tem_char_t	tvs_utf8_partial;	/* UTF-8 char being completed */
+
+	bool		tvs_isactive;
+	bool		tvs_initialized;	/* initialization flag */
+
+	list_node_t	tvs_list_node;
+};
+
+typedef struct tem_callbacks {
+	void (*tsc_display)(struct tem_vt_state *, term_char_t *, int,
+	    screen_pos_t, screen_pos_t);
+	void (*tsc_copy)(struct tem_vt_state *,
+	    screen_pos_t, screen_pos_t, screen_pos_t, screen_pos_t,
+	    screen_pos_t, screen_pos_t);
+	void (*tsc_cursor)(struct tem_vt_state *, short);
+	void (*tsc_bit2pix)(struct tem_vt_state *, term_char_t);
+	void (*tsc_cls)(struct tem_vt_state *, int, screen_pos_t, screen_pos_t);
+} tem_callbacks_t;
+
+typedef struct __tem_modechg_cb_arg *tem_modechg_cb_arg_t;
+typedef void (*tem_modechg_cb_t) (tem_modechg_cb_arg_t arg);
+typedef	struct __tem_vt_state *tem_vt_state_t;
+
+/*
+ * common term soft state structure shared by all virtual terminal emulators
+ */
+typedef struct tem_state {
+	struct console	*ts_hdl;	/* Framework handle for dev */
+	screen_size_t	ts_linebytes;	/* Layered on bytes per scan line */
+
+	int	ts_display_mode;	/* What mode we are in */
+
+	struct tem_size ts_c_dimension;	/* window dimensions in characters */
+	struct tem_size ts_p_dimension;	/* screen dimensions in pixels */
+	struct tem_pix_pos ts_p_offset;	/* pix offset to center the display */
+
+	int	ts_pix_data_size;	/* size of bitmap data areas */
+	int	ts_pdepth;		/* pixel depth */
+	struct font	ts_font;	/* font table */
+	bool	update_font;		/* flag the font change */
+
+	tem_callbacks_t	*ts_callbacks;	/* internal output functions */
+
+	int	ts_initialized;		/* initialization flag */
+
+	tem_modechg_cb_t	ts_modechg_cb;
+	tem_modechg_cb_arg_t	ts_modechg_arg;
+
+	color_map_fn_t	ts_color_map;
+
+	tem_color_t	ts_init_color; /* initial color and attributes */
+
+	struct tem_vt_state	*ts_active;
+	list_t		ts_list;	/* chain of all tems */
+} tem_state_t;
+
+extern tem_state_t tems;
+/*
+ * tems_* fuctions mean that they just operate on the common soft state
+ * (tem_state_t), and tem_* functions mean that they operate on the
+ * per-tem structure (tem_vt_state). All "safe" interfaces are in tem_safe.c.
+ */
+int	tems_cls(struct vis_consclear *);
+void	tems_display(struct vis_consdisplay *);
+void	tems_copy(struct vis_conscopy *);
+void	tems_cursor(struct vis_conscursor *);
+
+int	tem_initialized(tem_vt_state_t);
+
+tem_vt_state_t tem_init(void);
+
+int	tem_info_init(struct console *);
+void	tem_write(tem_vt_state_t, uint8_t *, ssize_t);
+void	tem_get_size(uint16_t *, uint16_t *, uint16_t *, uint16_t *);
+void	tem_save_state(void);
+void	tem_register_modechg_cb(tem_modechg_cb_t, tem_modechg_cb_arg_t);
+void	tem_activate(tem_vt_state_t, boolean_t);
+void	tem_get_colors(tem_vt_state_t, text_color_t *, text_color_t *);
+void	tem_image_display(struct tem_vt_state *, screen_pos_t, screen_pos_t,
+	screen_pos_t, screen_pos_t);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_TEM_H */
diff --git a/usr/src/boot/sys/sys/types.h b/usr/src/boot/sys/sys/types.h
index 81168bdff4..861cee3b39 100644
--- a/usr/src/boot/sys/sys/types.h
+++ b/usr/src/boot/sys/sys/types.h
@@ -294,6 +294,10 @@ typedef	_Bool	bool;
 
 #define offsetof(type, field) __offsetof(type, field)
 
+#else
+/* for illumos compatibility */
+typedef enum boolean { B_FALSE, B_TRUE } boolean_t;
+
 #endif /* !_KERNEL */
 
 /*
diff --git a/usr/src/cmd/Makefile b/usr/src/cmd/Makefile
index e303927b65..6d8b247797 100644
--- a/usr/src/cmd/Makefile
+++ b/usr/src/cmd/Makefile
@@ -152,6 +152,7 @@ COMMON_SUBDIRS=		\
 	enhance		\
 	env		\
 	eqn		\
+	etdump		\
 	expand		\
 	expr		\
 	exstr		\
@@ -781,7 +782,7 @@ AUDITSUBDIRS=		\
 	auditreduce	\
 	auditset	\
 	auditstat	\
-	praudit		
+	praudit
 
 #
 # commands not owned by the systems group
diff --git a/usr/src/cmd/bnu/Makefile.inc b/usr/src/cmd/bnu/Makefile.inc
index 4d16a7a8a2..5433cd6431 100644
--- a/usr/src/cmd/bnu/Makefile.inc
+++ b/usr/src/cmd/bnu/Makefile.inc
@@ -22,6 +22,8 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# Copyright (c) 2019, Joyent, Inc.
+#
 
 SRCS =		account.c anlwrk.c bnuconvert.c callers.c		\
 		chremdir.c cntrl.c conn.c cpmv.c ct.c			\
@@ -46,6 +48,9 @@ CERRWARN	+= -_gcc=-Wno-uninitialized
 CERRWARN	+= -_gcc=-Wno-extra
 CERRWARN	+= -_gcc=-Wno-implicit-function-declaration
 
+# "parse error: parsing (arg (9223372034707292160-0,2-s32max) == 2)"
+SMATCH		= off
+
 TLILIB =	-lnsl -lsocket
 PAMLIB =        -lpam
 
diff --git a/usr/src/cmd/cmd-inet/usr.bin/pppd/Makefile b/usr/src/cmd/cmd-inet/usr.bin/pppd/Makefile
index 324a3c4897..234a87f7d6 100644
--- a/usr/src/cmd/cmd-inet/usr.bin/pppd/Makefile
+++ b/usr/src/cmd/cmd-inet/usr.bin/pppd/Makefile
@@ -4,6 +4,7 @@
 #
 # cmd/cmd-inet/usr.bin/pppd/Makefile
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 include		../../../Makefile.cmd
 include		Makefile.def
@@ -52,6 +53,9 @@ CLOBBERFILES +=	mschap_test
 
 CERRWARN +=	-_gcc=-Wno-uninitialized
 
+# main() is too hairy for smatch
+SMATCH=off
+
 # This is used *only* for testing the portability of the libraries
 # required for MS-CHAPv1.  It is not needed in any normal system and
 # is not built by default.
diff --git a/usr/src/cmd/deroff/Makefile b/usr/src/cmd/deroff/Makefile
index 6f08eb2b86..5502c1e162 100644
--- a/usr/src/cmd/deroff/Makefile
+++ b/usr/src/cmd/deroff/Makefile
@@ -22,6 +22,7 @@
 #
 # Copyright (c) 1989 by Sun Microsystems, Inc.
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 PROG= deroff
 
@@ -31,9 +32,12 @@ CERRWARN += -_gcc=-Wno-char-subscripts
 CERRWARN += -_gcc=-Wno-unused-label
 CERRWARN += -_gcc=-Wno-parentheses
 
+# too hairy for smatch
+SMATCH=off
+
 .KEEP_STATE:
 
-all: $(PROG) 
+all: $(PROG)
 
 install: all $(ROOTPROG)
 
diff --git a/usr/src/cmd/devctl/Makefile b/usr/src/cmd/devctl/Makefile
index 98ba25c5c8..f3893877f6 100644
--- a/usr/src/cmd/devctl/Makefile
+++ b/usr/src/cmd/devctl/Makefile
@@ -23,6 +23,7 @@
 # Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# # Copyright (c) 2019, Joyent, Inc.
 
 PROG= devctl
 
@@ -32,7 +33,7 @@ include ../Makefile.cmd
 
 CFLAGS +=	$(CCVERBOSE)
 CERRWARN +=	-_gcc=-Wno-parentheses
-LDLIBS += -ldevice -l devinfo
+LDLIBS += -ldevice -ldevinfo
 
 all: $(PROG)
 
diff --git a/usr/src/cmd/etdump/Makefile b/usr/src/cmd/etdump/Makefile
new file mode 100644
index 0000000000..8776a2d698
--- /dev/null
+++ b/usr/src/cmd/etdump/Makefile
@@ -0,0 +1,37 @@
+#
+# This file and its contents are supplied under the terms of the
+# Common Development and Distribution License ("CDDL"), version 1.0.
+# You may only use this file in accordance with the terms of version
+# 1.0 of the CDDL.
+#
+# A full copy of the text of the CDDL should have accompanied this
+# source.  A copy of the CDDL is also available via the Internet at
+# http://www.illumos.org/license/CDDL.
+#
+
+#
+# Copyright 2018 Toomas Soome <tsoome@me.com>
+#
+
+PROG=	etdump
+OBJS=	etdump.o output_shell.o output_text.o cd9660_conversion.o
+SRCS=	$(OBJS:%.o=%.c)
+
+include ../Makefile.cmd
+
+.KEEP_STATE:
+
+all: $(PROG)
+
+install: all $(ROOTPROG)
+
+clean:
+	$(RM) $(OBJS)
+
+$(PROG):	$(OBJS)
+	$(LINK.c) $(OBJS) -o $@ $(LDLIBS)
+	$(POST_PROCESS)
+
+lint:
+
+include ../Makefile.targ
diff --git a/usr/src/cmd/etdump/THIRDPARTYLICENSE b/usr/src/cmd/etdump/THIRDPARTYLICENSE
new file mode 100644
index 0000000000..f47273514f
--- /dev/null
+++ b/usr/src/cmd/etdump/THIRDPARTYLICENSE
@@ -0,0 +1,66 @@
+cd9660_eltorito.h:
+cd9660_conversion.c:
+/*
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 2005 Daniel Watt, Walter Deignan, Ryan Gabrys, Alan
+ * Perez-Rathke and Ram Vedam.  All rights reserved.
+ *
+ * This code was written by Daniel Watt, Walter Deignan, Ryan Gabrys,
+ * Alan Perez-Rathke and Ram Vedam.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY DANIEL WATT, WALTER DEIGNAN, RYAN
+ * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM ``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 DANIEL WATT, WALTER DEIGNAN, RYAN
+ * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM 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.
+ */
+
+etdump.h:
+etdump.c:
+etdump.1:
+output_shell.c:
+output_text.c:
+/*
+ * Copyright (c) 2018 iXsystems, Inc.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
diff --git a/usr/src/cmd/etdump/THIRDPARTYLICENSE.descrip b/usr/src/cmd/etdump/THIRDPARTYLICENSE.descrip
new file mode 100644
index 0000000000..18f61b4a66
--- /dev/null
+++ b/usr/src/cmd/etdump/THIRDPARTYLICENSE.descrip
@@ -0,0 +1 @@
+etdump utility cpommand
diff --git a/usr/src/cmd/etdump/cd9660_conversion.c b/usr/src/cmd/etdump/cd9660_conversion.c
new file mode 100644
index 0000000000..a980af35fb
--- /dev/null
+++ b/usr/src/cmd/etdump/cd9660_conversion.c
@@ -0,0 +1,191 @@
+/*
+ * $NetBSD: cd9660_conversion.c,v 1.4 2007/03/14 14:11:17 christos Exp $
+ */
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 2005 Daniel Watt, Walter Deignan, Ryan Gabrys, Alan
+ * Perez-Rathke and Ram Vedam.  All rights reserved.
+ *
+ * This code was written by Daniel Watt, Walter Deignan, Ryan Gabrys,
+ * Alan Perez-Rathke and Ram Vedam.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY DANIEL WATT, WALTER DEIGNAN, RYAN
+ * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM ``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 DANIEL WATT, WALTER DEIGNAN, RYAN
+ * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE,DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+#include <endian.h>
+
+static char cd9660_compute_gm_offset(time_t);
+
+/*
+ * These can probably be implemented using a macro
+ */
+
+/* Little endian */
+void
+cd9660_721(uint16_t w, unsigned char *twochar)
+{
+#if BYTE_ORDER == BIG_ENDIAN
+	w = htole16(w);
+#endif
+	memcpy(twochar, &w, 2);
+}
+
+void
+cd9660_731(uint32_t w, unsigned char *fourchar)
+{
+#if BYTE_ORDER == BIG_ENDIAN
+	w = htole32(w);
+#endif
+	memcpy(fourchar, &w, 4);
+}
+
+/* Big endian */
+void
+cd9660_722(uint16_t w, unsigned char *twochar)
+{
+#if BYTE_ORDER == LITTLE_ENDIAN
+	w = htobe16(w);
+#endif
+	memcpy(twochar, &w, 2);
+}
+
+void
+cd9660_732(uint32_t w, unsigned char *fourchar)
+{
+#if BYTE_ORDER == LITTLE_ENDIAN
+	w = htobe32(w);
+#endif
+	memcpy(fourchar, &w, 4);
+}
+
+/*
+ * Convert a dword into a double endian string of eight characters
+ * @param int The double word to convert
+ * @param char* The string to write the both endian double word to - It is
+ * assumed this is allocated and at least eight characters long.
+ */
+void
+cd9660_bothendian_dword(uint32_t dw, unsigned char *eightchar)
+{
+	uint32_t le, be;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	le = dw;
+	be = htobe32(dw);
+#endif
+#if BYTE_ORDER == BIG_ENDIAN
+	be = dw;
+	le = htole32(dw);
+#endif
+	memcpy(eightchar, &le, 4);
+	memcpy((eightchar+4), &be, 4);
+}
+
+/*
+ * Convert a word into a double endian string of four characters
+ * @param int The word to convert
+ * @param char* The string to write the both endian word to - It is assumed
+ * this is allocated and at least four characters long.
+ */
+void
+cd9660_bothendian_word(uint16_t dw, unsigned char *fourchar)
+{
+	uint16_t le, be;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	le = dw;
+	be = htobe16(dw);
+#endif
+#if BYTE_ORDER == BIG_ENDIAN
+	be = dw;
+	le = htole16(dw);
+#endif
+	memcpy(fourchar, &le, 2);
+	memcpy((fourchar+2), &be, 2);
+}
+
+void
+cd9660_pad_string_spaces(char *str, int len)
+{
+	int i;
+
+	for (i = 0; i < len; i ++) {
+		if (str[i] == '\0')
+			str[i] = 0x20;
+	}
+}
+
+static char
+cd9660_compute_gm_offset(time_t tim)
+{
+	struct tm t, gm;
+
+	(void) localtime_r(&tim, &t);
+	(void) gmtime_r(&tim, &gm);
+	gm.tm_year -= t.tm_year;
+	gm.tm_yday -= t.tm_yday;
+	gm.tm_hour -= t.tm_hour;
+	gm.tm_min  -= t.tm_min;
+	if (gm.tm_year < 0)
+		gm.tm_yday = -1;
+	else if (gm.tm_year > 0)
+		gm.tm_yday = 1;
+
+	return (char)(-(gm.tm_min + 60* (24 * gm.tm_yday + gm.tm_hour)) / 15);
+}
+
+/* Long dates: 17 characters */
+void
+cd9660_time_8426(unsigned char *buf, time_t tim)
+{
+	struct tm t;
+	char temp[18];
+
+	(void) localtime_r(&tim, &t);
+	(void) snprintf(temp, sizeof (temp), "%04i%02i%02i%02i%02i%02i%02i",
+	    1900 + (int)t.tm_year, (int)t.tm_mon + 1, (int)t.tm_mday,
+	    (int)t.tm_hour, (int)t.tm_min, (int)t.tm_sec, 0);
+	(void) memcpy(buf, temp, 16);
+	buf[16] = cd9660_compute_gm_offset(tim);
+}
+
+/* Short dates: 7 characters */
+void
+cd9660_time_915(unsigned char *buf, time_t tim)
+{
+	struct tm t;
+
+	(void) localtime_r(&tim, &t);
+	buf[0] = t.tm_year;
+	buf[1] = t.tm_mon+1;
+	buf[2] = t.tm_mday;
+	buf[3] = t.tm_hour;
+	buf[4] = t.tm_min;
+	buf[5] = t.tm_sec;
+	buf[6] = cd9660_compute_gm_offset(tim);
+}
diff --git a/usr/src/cmd/etdump/cd9660_eltorito.h b/usr/src/cmd/etdump/cd9660_eltorito.h
new file mode 100644
index 0000000000..c73f591a73
--- /dev/null
+++ b/usr/src/cmd/etdump/cd9660_eltorito.h
@@ -0,0 +1,187 @@
+/*
+ * $NetBSD: cd9660_eltorito.h,v 1.6 2017/01/24 11:22:43 nonaka Exp $
+ */
+
+/*
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 2005 Daniel Watt, Walter Deignan, Ryan Gabrys, Alan
+ * Perez-Rathke and Ram Vedam.  All rights reserved.
+ *
+ * This code was written by Daniel Watt, Walter Deignan, Ryan Gabrys,
+ * Alan Perez-Rathke and Ram Vedam.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY DANIEL WATT, WALTER DEIGNAN, RYAN
+ * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM ``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 DANIEL WATT, WALTER DEIGNAN, RYAN
+ * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM 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 _CD9660_ELTORITO_H_
+#define	_CD9660_ELTORITO_H_
+
+#include <sys/types.h>
+#include <sys/queue.h>
+
+/* Boot defines */
+#define	ET_ID		"EL TORITO SPECIFICATION"
+#define	ET_SYS_X86	0
+#define	ET_SYS_PPC	1
+#define	ET_SYS_MAC	2
+#define	ET_SYS_EFI	0xef	/* Platform ID at section header entry */
+
+#define	ET_BOOT_ENTRY_SIZE 0x20
+
+#define	ET_BOOTABLE		0x88
+#define	ET_NOT_BOOTABLE		0
+
+#define	ET_MEDIA_NOEM			0
+#define	ET_MEDIA_12FDD			1
+#define	ET_MEDIA_144FDD			2
+#define	ET_MEDIA_288FDD			3
+#define	ET_MEDIA_HDD			4
+
+#define	ET_INDICATOR_HEADERMORE	0x90
+#define	ET_INDICATOR_HEADERLAST	0x91
+#define	ET_INDICATOR_EXTENSION	0x44
+
+/* Boot Structures */
+
+#define	ISODCL(from, to) (to - from + 1)
+
+typedef struct _boot_volume_descriptor {
+	uchar_t boot_record_indicator	[ISODCL(0x00, 0x00)];
+	uchar_t identifier		[ISODCL(0x01, 0x05)];
+	uchar_t version			[ISODCL(0x06, 0x06)];
+	uchar_t boot_system_identifier	[ISODCL(0x07, 0x26)];
+	uchar_t unused1			[ISODCL(0x27, 0x46)];
+	uchar_t boot_catalog_pointer	[ISODCL(0x47, 0x4A)];
+	uchar_t unused2			[ISODCL(0x4B, 0x7FF)];
+} boot_volume_descriptor;
+
+typedef struct _boot_catalog_validation_entry {
+	uchar_t header_id		[ISODCL(0x00, 0x00)];
+	uchar_t platform_id		[ISODCL(0x01, 0x01)];
+	uchar_t reserved1		[ISODCL(0x02, 0x03)];
+	uchar_t manufacturer		[ISODCL(0x04, 0x1B)];
+	uchar_t checksum		[ISODCL(0x1C, 0x1D)];
+	uchar_t key			[ISODCL(0x1E, 0x1F)];
+} boot_catalog_validation_entry;
+
+typedef struct _boot_catalog_initial_entry {
+	uchar_t boot_indicator		[ISODCL(0x00, 0x00)];
+	uchar_t media_type		[ISODCL(0x01, 0x01)];
+	uchar_t load_segment		[ISODCL(0x02, 0x03)];
+	uchar_t system_type		[ISODCL(0x04, 0x04)];
+	uchar_t unused_1		[ISODCL(0x05, 0x05)];
+	uchar_t sector_count		[ISODCL(0x06, 0x07)];
+	uchar_t load_rba		[ISODCL(0x08, 0x0B)];
+	uchar_t unused_2		[ISODCL(0x0C, 0x1F)];
+} boot_catalog_initial_entry;
+
+#define	ET_SECTION_HEADER_MORE		0x90
+#define	ET_SECTION_HEADER_LAST		0x91
+
+typedef struct _boot_catalog_section_header {
+	uchar_t header_indicator	[ISODCL(0x00, 0x00)];
+	uchar_t platform_id		[ISODCL(0x01, 0x01)];
+	uchar_t num_section_entries	[ISODCL(0x02, 0x03)];
+	uchar_t id_string		[ISODCL(0x04, 0x1F)];
+} boot_catalog_section_header;
+
+typedef struct _boot_catalog_section_entry {
+	uchar_t boot_indicator		[ISODCL(0x00, 0x00)];
+	uchar_t media_type		[ISODCL(0x01, 0x01)];
+	uchar_t load_segment		[ISODCL(0x02, 0x03)];
+	uchar_t system_type		[ISODCL(0x04, 0x04)];
+	uchar_t unused_1		[ISODCL(0x05, 0x05)];
+	uchar_t sector_count		[ISODCL(0x06, 0x07)];
+	uchar_t load_rba		[ISODCL(0x08, 0x0B)];
+	uchar_t selection_criteria	[ISODCL(0x0C, 0x0C)];
+	uchar_t vendor_criteria		[ISODCL(0x0D, 0x1F)];
+} boot_catalog_section_entry;
+
+typedef struct _boot_catalog_section_entry_extension {
+	uchar_t extension_indicator	[ISODCL(0x00, 0x00)];
+	uchar_t flags			[ISODCL(0x01, 0x01)];
+	uchar_t vendor_criteria		[ISODCL(0x02, 0x1F)];
+} boot_catalog_section_entry_extension;
+
+#define	ET_ENTRY_VE 1
+#define	ET_ENTRY_IE 2
+#define	ET_ENTRY_SH 3
+#define	ET_ENTRY_SE 4
+#define	ET_ENTRY_EX 5
+
+struct boot_catalog_entry {
+	char entry_type;
+	union {
+		boot_catalog_validation_entry		VE;
+		boot_catalog_initial_entry		IE;
+		boot_catalog_section_header		SH;
+		boot_catalog_section_entry		SE;
+		boot_catalog_section_entry_extension	EX;
+	} entry_data;
+
+	LIST_ENTRY(boot_catalog_entry) ll_struct;
+};
+
+/* Temporary structure */
+struct cd9660_boot_image {
+	char *filename;
+	int size;
+	int sector;			/* copied to LoadRBA */
+	int num_sectors;
+	unsigned int loadSegment;
+	uchar_t targetMode;
+	uchar_t system;
+	uchar_t bootable;
+	uchar_t platform_id;		/* for section header entry */
+	/*
+	 * If the boot image exists in the filesystem
+	 * already, this is a pointer to that node. For the sake
+	 * of simplicity in future versions, this pointer is only
+	 * to the node in the primary volume. This SHOULD be done
+	 * via a hashtable lookup.
+	 */
+	struct _cd9660node *boot_image_node;
+	TAILQ_ENTRY(cd9660_boot_image) image_list;
+	int serialno;
+};
+
+void cd9660_721(uint16_t, unsigned char *);
+
+static __inline uint16_t
+isonum_721(const unsigned char *p)
+{
+
+	return (p[0] | p[1] << 8);
+}
+
+static __inline uint32_t
+isonum_731(const unsigned char *p)
+{
+
+	return (p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24);
+}
+
+#endif /* _CD9660_ELTORITO_H_ */
diff --git a/usr/src/cmd/etdump/etdump.c b/usr/src/cmd/etdump/etdump.c
new file mode 100644
index 0000000000..5469597151
--- /dev/null
+++ b/usr/src/cmd/etdump/etdump.c
@@ -0,0 +1,272 @@
+/*
+ * Copyright (c) 2018 iXsystems, Inc.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <err.h>
+#include <getopt.h>
+#include <libgen.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/queue.h>
+
+#include <sys/fs/hsfs_isospec.h>
+#include "cd9660_eltorito.h"
+
+#include "etdump.h"
+
+#define	ISO_DEFAULT_BLOCK_SHIFT	11
+#define	ISO_DEFAULT_BLOCK_SIZE	(1 << ISO_DEFAULT_BLOCK_SHIFT)
+
+const char *
+system_id_string(uchar_t system_id)
+{
+
+	switch (system_id) {
+	case ET_SYS_X86:
+		return ("i386");
+	case ET_SYS_PPC:
+		return ("powerpc");
+	case ET_SYS_MAC:
+		return ("mac");
+	case ET_SYS_EFI:
+		return ("efi");
+	default:
+		return ("invalid");
+	}
+}
+
+const char *
+media_type_string(uchar_t media_type)
+{
+
+	switch (media_type) {
+	case ET_MEDIA_NOEM:
+		return ("no emulation");
+	case ET_MEDIA_12FDD:
+		return ("1.2MB FDD");
+	case ET_MEDIA_144FDD:
+		return ("1.44MB FDD");
+	case ET_MEDIA_288FDD:
+		return ("2.88MB FDD");
+	case ET_MEDIA_HDD:
+		return ("HDD");
+	default:
+		return ("invalid");
+	}
+}
+
+static int
+read_sector(FILE *iso, daddr_t sector, char *buffer)
+{
+
+	fseek(iso, sector * ISO_DEFAULT_BLOCK_SIZE, SEEK_SET);
+	if (fread(buffer, ISO_DEFAULT_BLOCK_SIZE, 1, iso) != 1) {
+		return (errno);
+	}
+	return (0);
+}
+
+static bool
+boot_catalog_valid(char *entry)
+{
+	boot_catalog_validation_entry *ve;
+	int16_t		checksum, sum;
+	unsigned char	*csptr;
+	size_t		i;
+
+	ve = (boot_catalog_validation_entry *)entry;
+
+	checksum = isonum_721(ve->checksum);
+	cd9660_721(0, ve->checksum);
+	csptr = (unsigned char *)ve;
+
+	for (i = sum = 0; i < sizeof (*ve); i += 2) {
+		sum += (int16_t)csptr[i];
+		sum += 256 * (int16_t)csptr[i + 1];
+	}
+	if (sum + checksum != 0) {
+		return (false);
+	}
+
+	cd9660_721(checksum, ve->checksum);
+	return (true);
+}
+
+static int
+dump_section(char *buffer, size_t offset, FILE *outfile, const char *filename,
+    struct outputter *outputter)
+{
+	boot_catalog_section_header *sh;
+	uchar_t platform_id;
+	int i;
+	size_t entry_offset;
+	boot_catalog_section_entry *entry;
+
+	sh = (boot_catalog_section_header *)&buffer[offset];
+	if (outputter->output_section != NULL) {
+		outputter->output_section(outfile, filename, sh);
+	}
+
+	platform_id = sh->platform_id[0];
+
+	if (outputter->output_entry != NULL) {
+		for (i = 1; i <= (int)sh->num_section_entries[0]; i++) {
+			entry_offset = offset + i * ET_BOOT_ENTRY_SIZE;
+			entry =
+			    (boot_catalog_section_entry *)&buffer[entry_offset];
+			outputter->output_entry(outfile, filename, entry,
+			    platform_id, false);
+		}
+	}
+
+	return (1 + (int)sh->num_section_entries[0]);
+}
+
+static void
+dump_eltorito(FILE *iso, const char *filename, FILE *outfile,
+    struct outputter *outputter)
+{
+	char buffer[ISO_DEFAULT_BLOCK_SIZE], *entry;
+	boot_volume_descriptor *bvd;
+	daddr_t boot_catalog;
+	size_t offset;
+	int entry_count;
+
+	if (read_sector(iso, 17, buffer) != 0)
+		err(1, "failed to read from image");
+
+	bvd = (boot_volume_descriptor *)buffer;
+	if (memcmp(bvd->identifier, ISO_ID_STRING, 5) != 0)
+		warnx("%s: not a valid ISO", filename);
+	if (bvd->boot_record_indicator[0] != ISO_VD_BOOT)
+		warnx("%s: not an El Torito bootable ISO", filename);
+	if (memcmp(bvd->boot_system_identifier, ET_ID, 23) != 0)
+		warnx("%s: not an El Torito bootable ISO", filename);
+
+	boot_catalog = isonum_731(bvd->boot_catalog_pointer);
+
+	if (read_sector(iso, boot_catalog, buffer) != 0)
+		err(1, "failed to read from image");
+
+	entry = buffer;
+	offset = 0;
+
+	if (!boot_catalog_valid(entry))
+		warnx("%s: boot catalog checksum is invalid", filename);
+
+	if (outputter->output_image != NULL)
+		outputter->output_image(outfile, filename, bvd);
+
+	offset += ET_BOOT_ENTRY_SIZE;
+	entry = &buffer[offset];
+	if (outputter->output_entry != NULL)
+		outputter->output_entry(outfile, filename,
+		    (boot_catalog_section_entry *)entry, 0, true);
+
+	offset += ET_BOOT_ENTRY_SIZE;
+
+	while (offset < ISO_DEFAULT_BLOCK_SIZE) {
+		entry = &buffer[offset];
+
+		if ((uint8_t)entry[0] != ET_SECTION_HEADER_MORE &&
+		    (uint8_t)entry[0] != ET_SECTION_HEADER_LAST)
+			break;
+
+		entry_count = dump_section(buffer, offset, outfile, filename,
+		    outputter);
+
+		offset += entry_count * ET_BOOT_ENTRY_SIZE;
+	}
+}
+
+static void
+usage(const char *progname)
+{
+	char *path;
+
+	path = strdup(progname);
+
+	fprintf(stderr, "usage: %s [-f format] [-o filename] filename [...]\n",
+	    basename(path));
+	fprintf(stderr, "\tsupported output formats: shell, text\n");
+	exit(1);
+}
+
+int
+main(int argc, char **argv)
+{
+	int ch, i;
+	FILE *outfile, *iso;
+	struct outputter *outputter;
+
+	outfile = stdout;
+	outputter = output_text;
+
+	static struct option longopts[] = {
+		{ "format",	required_argument,	NULL,	'f' },
+		{ "output",	required_argument,	NULL,	'o' },
+		{ NULL,		0,			NULL,	0 },
+	};
+
+	while ((ch = getopt_long(argc, argv, "f:o:", longopts, NULL)) != -1) {
+		switch (ch) {
+		case 'f':
+			if (strcmp(optarg, "shell") == 0)
+				outputter = output_shell;
+			else if (strcmp(optarg, "text") == 0)
+				outputter = output_text;
+			else
+				usage(argv[0]);
+			break;
+		case 'o':
+			if (strcmp(optarg, "-") == 0) {
+				outfile = stdout;
+			} else if ((outfile = fopen(optarg, "w")) == NULL) {
+				err(1, "unable to open %s for output", optarg);
+			}
+			break;
+		default:
+			usage(argv[0]);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	for (i = 0; i < argc; i++) {
+		if (strcmp(argv[i], "-") == 0) {
+			iso = stdin;
+		} else {
+			iso = fopen(argv[i], "r");
+			if (iso == NULL)
+				err(1, "could not open %s", argv[1]);
+		}
+		dump_eltorito(iso, argv[i], outfile, outputter);
+	}
+	return (0);
+}
diff --git a/usr/src/cmd/etdump/etdump.h b/usr/src/cmd/etdump/etdump.h
new file mode 100644
index 0000000000..f7e64205dd
--- /dev/null
+++ b/usr/src/cmd/etdump/etdump.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018 iXsystems, Inc.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: head/usr.bin/etdump/etdump.h 331949 2018-04-03 21:08:10Z benno $
+ */
+
+#ifndef	_ETDUMP_H_
+#define	_ETDUMP_H_
+
+struct outputter {
+	void (*output_image)(FILE *outfile, const char *filename,
+	    boot_volume_descriptor *bvd);
+	void (*output_section)(FILE *outfile, const char *filename,
+	    boot_catalog_section_header *bcsh);
+	void (*output_entry)(FILE *outfile, const char *filename,
+	    boot_catalog_section_entry *bcse,
+	    uchar_t platform_id, bool initial);
+};
+
+extern struct outputter *output_text;
+extern struct outputter *output_shell;
+
+const char *system_id_string(uchar_t system_id);
+const char *media_type_string(uchar_t media_type);
+
+#endif	/* _ETDUMP_H_ */
diff --git a/usr/src/cmd/etdump/output_shell.c b/usr/src/cmd/etdump/output_shell.c
new file mode 100644
index 0000000000..291983ff64
--- /dev/null
+++ b/usr/src/cmd/etdump/output_shell.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2018 iXsystems, Inc.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+
+#include "cd9660_eltorito.h"
+
+#include "etdump.h"
+
+static void
+output_entry(FILE *outfile, const char *filename __unused,
+    boot_catalog_section_entry *bcse, uchar_t platform_id, bool initial)
+{
+	const char *platform;
+
+	switch (bcse->boot_indicator[0]) {
+	case ET_BOOTABLE:
+		break;
+	case ET_NOT_BOOTABLE:
+	default:
+		return;
+	}
+
+	if (initial)
+		platform = "default";
+	else
+		platform = system_id_string(platform_id);
+
+	fprintf(outfile,
+	    "et_platform=%s;et_system=%s;et_lba=%d;et_sectors=%d\n",
+	    platform, system_id_string(bcse->system_type[0]),
+	    isonum_731(bcse->load_rba), isonum_721(bcse->sector_count));
+}
+
+static struct outputter _output_shell = {
+	.output_image = NULL,
+	.output_section = NULL,
+	.output_entry = output_entry,
+};
+
+struct outputter *output_shell = &_output_shell;
diff --git a/usr/src/cmd/etdump/output_text.c b/usr/src/cmd/etdump/output_text.c
new file mode 100644
index 0000000000..eb0681c63f
--- /dev/null
+++ b/usr/src/cmd/etdump/output_text.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2018 iXsystems, Inc.
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdbool.h>
+#include <stdio.h>
+
+#include "cd9660_eltorito.h"
+#include "etdump.h"
+
+static void
+output_image(FILE *outfile, const char *filename,
+    boot_volume_descriptor *bvd __unused)
+{
+
+	fprintf(outfile, "Image in %s\n", filename);
+}
+
+static void
+output_section(FILE *outfile, const char *filename __unused,
+    boot_catalog_section_header *bcsh)
+{
+
+	fprintf(outfile, "\nSection header: %s",
+	    system_id_string(bcsh->platform_id[0]));
+
+	if (bcsh->header_indicator[0] == ET_SECTION_HEADER_LAST)
+		fprintf(outfile, ", final\n");
+	else
+		fprintf(outfile, "\n");
+}
+
+static void
+output_entry(FILE *outfile, const char *filename __unused,
+    boot_catalog_section_entry *bcse, uchar_t platform_id __unused,
+    bool initial)
+{
+	const char *indent;
+
+	switch (bcse->boot_indicator[0]) {
+	case ET_BOOTABLE:
+		break;
+	case ET_NOT_BOOTABLE:
+	default:
+		return;
+	}
+
+	if (initial) {
+		fprintf(outfile, "Default entry\n");
+		indent = "\t";
+	} else {
+		fprintf(outfile, "\tSection entry\n");
+		indent = "\t\t";
+	}
+
+	fprintf(outfile, "%sSystem %s\n", indent,
+	    system_id_string(bcse->system_type[0]));
+	fprintf(outfile, "%sStart LBA %d (0x%x), sector count %d (0x%x)\n",
+	    indent, isonum_731(bcse->load_rba), isonum_731(bcse->load_rba),
+	    isonum_721(bcse->sector_count), isonum_721(bcse->sector_count));
+	fprintf(outfile, "%sMedia type: %s\n", indent,
+	    media_type_string(bcse->media_type[0]));
+}
+
+static struct outputter _output_text = {
+	.output_image = output_image,
+	.output_section = output_section,
+	.output_entry = output_entry,
+};
+
+struct outputter *output_text = &_output_text;
diff --git a/usr/src/cmd/fs.d/smbclnt/test/Makefile b/usr/src/cmd/fs.d/smbclnt/test/Makefile
index 64b626f5a4..affd6d9a00 100644
--- a/usr/src/cmd/fs.d/smbclnt/test/Makefile
+++ b/usr/src/cmd/fs.d/smbclnt/test/Makefile
@@ -22,6 +22,7 @@
 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 # Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
+# Copyright (c) 2019, Joyent, Inc.
 #
 
 include $(SRC)/cmd/Makefile.cmd
@@ -43,7 +44,7 @@ INST_CMDS = $(PROG:%=$(TESTDIR)/%)
 CPPFLAGS += -I../../../../uts/common
 CPPFLAGS += -I../../../../lib/libsmbfs
 
-LDLIBS += -R '$$ORIGIN/../../../usr/lib'
+LDLIBS += -R'$$ORIGIN/../../../usr/lib'
 LDLIBS += -lsmbfs
 LINTLIBS= -L$(ROOTLIB) -lsmbfs
 
@@ -51,6 +52,9 @@ CFLAGS += $(CCVERBOSE)
 CERRWARN += -_gcc=-Wno-unused-variable
 CSTD= $(CSTD_GNU99)
 
+# not linted
+SMATCH=off
+
 LINTFLAGS += -erroff=E_FUNC_RET_ALWAYS_IGNOR2
 
 # CLOBBERFILES	+= $(LIBPROG)
diff --git a/usr/src/cmd/fs.d/ufs/mkfs/Makefile b/usr/src/cmd/fs.d/ufs/mkfs/Makefile
index 6b10524058..1df1d8c86d 100644
--- a/usr/src/cmd/fs.d/ufs/mkfs/Makefile
+++ b/usr/src/cmd/fs.d/ufs/mkfs/Makefile
@@ -22,6 +22,8 @@
 # Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# Copyright (c) 2019, Joyent, Inc.
+#
 
 FSTYPE=		ufs
 LIBPROG=	mkfs
@@ -30,6 +32,8 @@ ATTMK=		$(LIBPROG)
 include		../../Makefile.fstype
 include		../Makefile.roll
 
+CPPFLAGS +=	-I../../
+
 OBJS=		$(LIBPROG).o $(ROLLOBJS) $(FSLIB)
 SRCS=		$(LIBPROG).c $(ROLLSRCS) $(FSLIBSRC)
 MKFSOBJS=	mkfs.o
@@ -39,6 +43,9 @@ CERRWARN +=	-_gcc=-Wno-unused-variable
 CERRWARN +=	-_gcc=-Wno-empty-body
 CERRWARN +=	-_gcc=-Wno-uninitialized
 
+# can't hack main() !
+SMATCH =	off
+
 # for messaging catalog
 #
 POFILE= mkfs.po
diff --git a/usr/src/cmd/geniconvtbl/Makefile.com b/usr/src/cmd/geniconvtbl/Makefile.com
index 4030af32e6..95049755ef 100644
--- a/usr/src/cmd/geniconvtbl/Makefile.com
+++ b/usr/src/cmd/geniconvtbl/Makefile.com
@@ -21,6 +21,8 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# Copyright (c) 2019, Joyent, Inc.
+#
 
 $(NOT_NATIVE)NATIVE_BUILD = $(POUND_SIGN)
 
@@ -92,7 +94,10 @@ CERRWARN	+= -_gcc=-Wno-implicit-function-declaration
 YFLAGS		+= -d -v
 CFLAGS 		+= -D_FILE_OFFSET_BITS=64
 
-$(ITM) :=	CFLAGS += $(GSHARED) $(C_PICFLAGS) $(ZTEXT) -h $@
+# dump_expr() is too hairy
+SMATCH=off
+
+$(ITM) :=	CFLAGS += $(GSHARED) $(C_PICFLAGS) $(ZTEXT) -h$@
 $(ITM) :=	CPPFLAGS += -D_REENTRANT 
 $(ITM) :=	sparc_CFLAGS += -xregs=no%appl
 $(ITM) :=	sparcv9_CFLAGS += -xregs=no%appl
diff --git a/usr/src/cmd/ipcs/Makefile b/usr/src/cmd/ipcs/Makefile
index 1050b0a571..9e4bbffb5c 100644
--- a/usr/src/cmd/ipcs/Makefile
+++ b/usr/src/cmd/ipcs/Makefile
@@ -20,13 +20,10 @@
 # CDDL HEADER END
 #
 #
-#ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# cmd/ipcs/Makefile
-#
+# Copyright (c) 2019, Joyent, Inc.
 
 PROG=		ipcs
 XPG4PROG=	$(PROG)
@@ -37,6 +34,9 @@ LINTFLAGS +=	-erroff=E_NAME_USED_NOT_DEF2
 CFLAGS +=	$(CCVERBOSE)
 LDLIBS +=	-lproject
 
+# main() too hairy
+SMATCH =	off
+
 .KEEP_STATE:
 
 all: $(PROG)
diff --git a/usr/src/cmd/loadkeys/dumpkeys.c b/usr/src/cmd/loadkeys/dumpkeys.c
index b200d5c73a..e16f319a2b 100644
--- a/usr/src/cmd/loadkeys/dumpkeys.c
+++ b/usr/src/cmd/loadkeys/dumpkeys.c
@@ -19,9 +19,6 @@
  *
  * CDDL HEADER END
  */
-#ifndef lint
-#ident	"%Z%%M%	%I%	%E% SMI"
-#endif
 
 /*
  * Copyright (c) 1988 by Sun Microsystems, Inc.
@@ -66,9 +63,7 @@ static void	printchar(int character, int delim);
 
 /*ARGSUSED*/
 int
-main(argc, argv)
-	int argc;
-	char **argv;
+main(int argc, char **argv)
 {
 	register int kbdfd;
 	register int keystation;
@@ -242,6 +237,9 @@ static char *funnies[] = {
 	"nop",
 	"oops",
 	"hole",
+	"",			/* not used */
+	"",			/* not used */
+	"",			/* not used */
 	"reset",
 	"error",
 	"idle",
@@ -258,6 +256,15 @@ static char *fa_class[] = {
 	"fa_cedilla",
 	"fa_acute",
 	"fa_grave",
+	"fa_macron",
+	"fa_breve",
+	"fa_dot",
+	"fa_slash",
+	"fa_ring",
+	"fa_apostrophe",
+	"fa_dacute",
+	"fa_ogonek",
+	"fa_caron"
 };
 
 #define	NFA_CLASS	(sizeof (fa_class) / sizeof (fa_class[0]))
@@ -311,15 +318,14 @@ static char	*padkeys[] = {
 #define	NPADKEYS	(sizeof (padkeys) / sizeof (padkeys[0]))
 
 static void
-printentry(kio)
-	register struct kiockeymap *kio;
+printentry(struct kiockeymap *kio)
 {
-	register int entry = (kio->kio_entry & 0x1F);
-	register int fkeyset;
-	register int i;
-	register int c;
+	int entry = (kio->kio_entry & 0x1F);
+	int fkeyset;
+	int i;
+	int c;
 
-	switch (kio->kio_entry >> 8) {
+	switch (KEYFLAGS(kio->kio_entry)) {
 
 	case 0x0:
 		if (kio->kio_entry == '"')
@@ -330,37 +336,37 @@ printentry(kio)
 			printchar((int)kio->kio_entry, '\'');
 		break;
 
-	case SHIFTKEYS >> 8:
+	case SHIFTKEYS:
 		if (entry < NSHIFTKEYS)
 			(void) printf("shiftkeys+%s", shiftkeys[entry]);
 		else
 			(void) printf("%#4x", kio->kio_entry);
 		break;
 
-	case BUCKYBITS >> 8:
+	case BUCKYBITS:
 		if (entry < NBUCKYBITS)
 			(void) printf("buckybits+%s", buckybits[entry]);
 		else
 			(void) printf("%#4x", kio->kio_entry);
 		break;
 
-	case FUNNY >> 8:
+	case FUNNY:
 		if (entry < NFUNNIES)
 			(void) printf("%s", funnies[entry]);
 		else
 			(void) printf("%#4x", kio->kio_entry);
 		break;
 
-	case FA_CLASS >> 8:
+	case FA_CLASS:
 		if (entry < NFA_CLASS)
 			(void) printf("%s", fa_class[entry]);
 		else
 			(void) printf("%#4x", kio->kio_entry);
 		break;
 
-	case STRING >> 8:
+	case STRING:
 		if (entry < NBUILTIN_STRINGS && strncmp(kio->kio_string,
-			builtin_strings[entry].string, KTAB_STRLEN) == 0)
+		    builtin_strings[entry].string, KTAB_STRLEN) == 0)
 			(void) printf("string+%s", builtin_strings[entry].name);
 		else {
 			(void) printf("\"");
@@ -372,16 +378,16 @@ printentry(kio)
 		}
 		break;
 
-	case FUNCKEYS >> 8:
+	case FUNCKEYS:
 		fkeyset = (int)(kio->kio_entry & 0xF0) >> 4;
 		if (fkeyset < NFKEYSETS)
 			(void) printf("%s(%d)", fkeysets[fkeyset],
-					(entry&0x0F) + 1);
+			    (entry & 0x0F) + 1);
 		else
 			(void) printf("%#4x", kio->kio_entry);
 		break;
 
-	case PADKEYS >> 8:
+	case PADKEYS:
 		if (entry < NPADKEYS)
 			(void) printf("%s", padkeys[entry]);
 		else
@@ -395,9 +401,7 @@ printentry(kio)
 }
 
 static void
-printchar(character, delim)
-	int character;
-	int delim;
+printchar(int character, int delim)
 {
 	switch (character) {
 
@@ -433,8 +437,10 @@ printchar(character, delim)
 		} else {
 			if (character < 040)
 				(void) printf("^%c", character + 0100);
-			else
+			else if (character <= 0xff)
 				(void) printf("'\\%.3o'", character);
+			else
+				(void) printf("%#4x", character);
 		}
 		break;
 	}
diff --git a/usr/src/cmd/loadkeys/loadkeys.y b/usr/src/cmd/loadkeys/loadkeys.y
index 2795f1f7bf..eb146480e6 100644
--- a/usr/src/cmd/loadkeys/loadkeys.y
+++ b/usr/src/cmd/loadkeys/loadkeys.y
@@ -21,10 +21,6 @@
  * CDDL HEADER END
  */
 
-#ifndef lint
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#endif
-
 /*
  * Copyright (c) 1999 by Sun Microsystems, Inc.
  * All rights reserved.
@@ -45,21 +41,7 @@
 
 #define	ALL	-1	/* special symbol for all tables */
 
-/*
- * SunOS 4.x and Solaris 2.[1234] put Type 4 key tables into
- * the keytables directory with no type qualification.
- * If we're a SPARC, we might be using an NFS server that
- * doesn't have the new type-qualified directories.
- * (loadkeys wasn't used on non-SPARCs in 2.[1234].)
- */
-#ifdef	sparc
-#define	COMPATIBILITY_DIR
-#endif
-
 static char	keytable_dir[] = "/usr/share/lib/keytables/type_%d/";
-#ifdef	COMPATIBILITY_DIR
-static char	keytable_dir2[] = "/usr/share/lib/keytables/";
-#endif
 static char	layout_prefix[] = "layout_";
 
 struct keyentry {
@@ -132,6 +114,7 @@ static int	loadkey(int kbdfd, keyentry *kep);
 static int	dupkey(int kbdfd, dupentry *dep, int shiftmask);
 static int	swapkey(int kbdfd, dupentry *dep, int shiftmask);
 static int	yylex();
+extern int	yyparse(void);
 static int	readesc(FILE *stream, int delim, int single_char);
 static int	wordcmp(const void *w1, const void *w2);
 static int	yyerror(char *msg);
@@ -141,20 +124,18 @@ static FILE	*open_mapping_file(char *pathbuf, char *name,
 			boolean_t explicit_name, int type);
 
 int
-main(argc, argv)
-	int argc;
-	char **argv;
+main(int argc, char **argv)
 {
-	register int kbdfd;
+	int kbdfd;
 	int type;
 	int layout;
 	/* maxint is 8 hex digits. */
 	char layout_filename[sizeof(layout_prefix)+8];
 	char pathbuf[MAXPATHLEN];
-	register int shift;
+	int shift;
 	struct kiockeymap mapentry;
-	register keyentry *kep;
-	register dupentry *dep;
+	keyentry *kep;
+	dupentry *dep;
 	boolean_t explicit_name;
 
 	while(++argv, --argc) {
@@ -333,12 +314,8 @@ set_layout(char *arg)
  * else print a message on stderr and return NULL.
  */
 FILE *
-open_mapping_file(
-	char *pathbuf,
-	char *name,
-	boolean_t explicit_name,
-	int type
-) {
+open_mapping_file(char *pathbuf, char *name, boolean_t explicit_name, int type)
+{
 	/* If the user specified the name, try it "raw". */
 	if (explicit_name) {
 		strcpy(pathbuf, name);
@@ -358,23 +335,8 @@ open_mapping_file(
 		return (NULL);
 	}
 	(void) strcat(pathbuf, name);
-	infile = fopen(pathbuf, "r");
-	if (infile) return (infile);
-	if (errno != ENOENT) goto fopen_fail;
-
-#ifdef	COMPATIBILITY_DIR
-	/* If not, and either the name was specified explicitly */
-	/*     or this is a type 4... */
-	if (explicit_name || type == KB_SUN4) {
-		/* Try the compatibility name. */
-		/* No need to check len here, it's shorter. */
-		(void) strcpy(pathbuf, keytable_dir2);
-		(void) strcat(pathbuf, infilename);
-		infile = fopen(pathbuf, "r");
-		if (infile) return (infile);
-		if (errno != ENOENT) goto fopen_fail;
-	}
-#endif
+	if ((infile = fopen(pathbuf, "r")) != NULL)
+		return (infile);
 
 fopen_fail:
 	(void) fprintf(stderr, "loadkeys: ");
@@ -425,7 +387,7 @@ makeentry(tablemask, entry)
 	kep->ke_next = NULL;
 	kep->ke_entry.kio_tablemask = tablemask;
 	kep->ke_entry.kio_station = 0;
-	kep->ke_entry.kio_entry = (u_short)entry;
+	kep->ke_entry.kio_entry = entry;
 	index = entry - STRING;
 	if (index >= 0 && index <= 15)
 		(void) strncpy(kep->ke_entry.kio_string, strings[index],
@@ -624,6 +586,10 @@ code:
 		{
 		$$ = $1;
 		}
+|	INT
+		{
+		$$ = $1;
+		}
 |	'('
 		{
 		$$ = '(';
@@ -707,9 +673,18 @@ word_t	wordtab[] = {
 	{ "downarrow",	CONSTANT,	DOWNARROW },
 	{ "error",	CONSTANT,	ERROR },
 	{ "fa_acute",	CONSTANT,	FA_ACUTE },
+	{ "fa_apostrophe", CONSTANT,	FA_APOSTROPHE },
+	{ "fa_breve",	CONSTANT,	FA_BREVE },
+	{ "fa_caron",	CONSTANT,	FA_CARON },
 	{ "fa_cedilla",	CONSTANT,	FA_CEDILLA },
 	{ "fa_cflex",	CONSTANT,	FA_CFLEX },
+	{ "fa_dacute",	CONSTANT,	FA_DACUTE },
+	{ "fa_dot",	CONSTANT,	FA_DOT },
 	{ "fa_grave",	CONSTANT,	FA_GRAVE },
+	{ "fa_macron",	CONSTANT,	FA_MACRON },
+	{ "fa_ogonek",	CONSTANT,	FA_OGONEK },
+	{ "fa_ring",	CONSTANT,	FA_RING },
+	{ "fa_slash",	CONSTANT,	FA_SLASH },
 	{ "fa_tilde",	CONSTANT,	FA_TILDE },
 	{ "fa_umlaut",	CONSTANT,	FA_UMLAUT },
 	{ "hole",	CONSTANT,	HOLE },
@@ -910,7 +885,7 @@ yylex()
 				yylval.number = wptr->w_lval;
 				tokentype = wptr->w_type;
 			} else {
-				yylval.number = strtol(tokbuf, &ptr, 10);
+				yylval.number = strtol(tokbuf, &ptr, 0);
 				if (ptr == tokbuf)
 					yyerror("syntax error");
 				else
diff --git a/usr/src/cmd/loadkeys/type_6/albania b/usr/src/cmd/loadkeys/type_6/albania
index d58ab75d5d..0ef261a8be 100644
--- a/usr/src/cmd/loadkeys/type_6/albania
+++ b/usr/src/cmd/loadkeys/type_6/albania
@@ -22,8 +22,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Albania Type 6 (USB) key layout
 #
 # Note, on the console, this keyboard layout is exactly
diff --git a/usr/src/cmd/loadkeys/type_6/belarus b/usr/src/cmd/loadkeys/type_6/belarus
index 432affeae3..b89fc72366 100644
--- a/usr/src/cmd/loadkeys/type_6/belarus
+++ b/usr/src/cmd/loadkeys/type_6/belarus
@@ -22,8 +22,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Belarus Type 6 (USB) key layout
 #
 # Note, on the console, this keyboard layout is exactly
diff --git a/usr/src/cmd/loadkeys/type_6/belgium b/usr/src/cmd/loadkeys/type_6/belgium
index 42c1edcacf..bd29bf992c 100644
--- a/usr/src/cmd/loadkeys/type_6/belgium
+++ b/usr/src/cmd/loadkeys/type_6/belgium
@@ -26,18 +26,18 @@
 # Belgian Type 6 (USB) key layout
 #
 #
-key  53  base ² shift ³ caps ² ctrl ² altg nop
+key  53  base 0x00B2 shift 0x00B3 caps 0x00B2 ctrl 0x00B2 altg nop
 key  30  base & shift 1 caps & ctrl & altg |
-key  31  base é shift 2 caps é ctrl é altg @
+key  31  base 0x00E9 shift 2 caps 0x00E9 ctrl 0x00E9 altg @
 key  32  base '"' shift 3 caps '"' ctrl '"' altg #
 key  33  base '\'' shift 4 caps '\'' ctrl '\'' altg nop
 key  34  base ( shift 5 caps ( ctrl ^[ altg nop
-key  35  base § shift 6 caps § ctrl ^_ altg ^
-key  36  base è shift 7 caps è ctrl è altg nop
+key  35  base 0x00A7 shift 6 caps 0x00A7 ctrl ^_ altg ^
+key  36  base 0x00E8 shift 7 caps 0x00E8 ctrl 0x00E8 altg nop
 key  37  base ! shift 8 caps ! ctrl ^\ altg nop
-key  38  base ç shift 9 caps ç ctrl ^^ altg {
-key  39  base à shift 0 caps à ctrl ^@ altg }
-key  45  base ) shift ° caps ) ctrl ^] altg nop
+key  38  base 0x00E7 shift 9 caps 0x00E7 ctrl ^^ altg {
+key  39  base 0x00E0 shift 0 caps 0x00E0 ctrl ^@ altg }
+key  45  base ) shift 0x00B0 caps ) ctrl ^] altg nop
 key  46  base - shift _ caps - ctrl ^_ altg nop
 key  20  base a shift A caps A ctrl ^A altg nop
 key  26  base z shift Z caps Z ctrl ^Z altg nop
@@ -45,8 +45,8 @@ key  47  base fa_cflex shift fa_umlaut caps fa_cflex ctrl fa_cflex altg [
 key  48  base $ shift * caps $ ctrl $ altg ]
 key   4  base q shift Q caps Q ctrl ^Q altg nop
 key  51  base m shift M caps M ctrl ^M altg nop
-key  52  base ù shift % caps ù ctrl ù altg fa_grave
-key  50  base µ shift £ caps µ ctrl µ altg fa_acute numl nonl up nop
+key  52  base 0x00F9 shift % caps 0x00F9 ctrl 0x00F9 altg fa_grave
+key  50  base 0x00B5 shift 0x00A3 caps 0x00B5 ctrl 0x00B5 altg fa_acute numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl < altg '\\' numl nonl up nop
 key  29  base w shift W caps W ctrl ^W altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/brazil b/usr/src/cmd/loadkeys/type_6/brazil
index d20cdfe74e..b1c905f5e4 100644
--- a/usr/src/cmd/loadkeys/type_6/brazil
+++ b/usr/src/cmd/loadkeys/type_6/brazil
@@ -29,44 +29,44 @@
 # "caps lock" acts as "shift lock" on this keyboard
 #
 #
-key  53  base '\'' shift '"' caps '\'' ctrl '\'' altg ¬
-key  30  base 1 shift ! caps 1 ctrl 1 altg ¹
-key  31  base 2 shift @ caps 2 ctrl ^@ altg ²
-key  32  base 3 shift # caps 3 ctrl 3 altg ³
-key  33  base 4 shift $ caps 4 ctrl 4 altg £
-key  34  base 5 shift % caps 5 ctrl 5 altg ¢
-key  35  base 6 shift fa_umlaut caps 6 ctrl ^^ altg ¬
+key  53  base '\'' shift '"' caps '\'' ctrl '\'' altg 0x00AC
+key  30  base 1 shift ! caps 1 ctrl 1 altg 0x00B9
+key  31  base 2 shift @ caps 2 ctrl ^@ altg 0x00B2
+key  32  base 3 shift # caps 3 ctrl 3 altg 0x00B3
+key  33  base 4 shift $ caps 4 ctrl 4 altg 0x00A3
+key  34  base 5 shift % caps 5 ctrl 5 altg 0x00A2
+key  35  base 6 shift fa_umlaut caps 6 ctrl ^^ altg 0x00AC
 key  36  base 7 shift & caps 7 ctrl 7 altg {
 key  37  base 8 shift * caps 8 ctrl ^[ altg [
 key  38  base 9 shift ( caps 9 ctrl ^] altg ]
 key  39  base 0 shift ) caps 0 ctrl 0 altg }
 key  45  base - shift _ caps - ctrl ^_ altg '\\' 
-key  46  base = shift + caps = ctrl = altg §
+key  46  base = shift + caps = ctrl = altg 0x00A7
 key  20  base q shift Q caps Q ctrl ^Q altg nop
 key  26  base w shift W caps W ctrl ^W altg nop
 key  8   base e shift E caps E ctrl ^E altg nop
 key  28  base y shift Y caps Y ctrl ^Y altg nop
-key  18  base o shift O caps O ctrl ^O altg §
-key  19  base p shift P caps P ctrl ^P altg ¶
+key  18  base o shift O caps O ctrl ^O altg 0x00A7
+key  19  base p shift P caps P ctrl ^P altg 0x00B6
 key  47  base fa_acute shift fa_grave caps fa_acute ctrl fa_acute altg '`'
-key  48  base [ shift { caps [ ctrl ^[ altg ª
+key  48  base [ shift { caps [ ctrl ^[ altg 0x00AA
 key   4  base a shift A caps A ctrl ^A altg nop
 key  22  base s shift S caps S ctrl ^S altg nop
-key  51  base ç shift Ç caps Ç ctrl ç altg ¡
+key  51  base 0x00E7 shift 0x00C7 caps 0x00C7 ctrl 0x00E7 altg ¡
 key  52  base fa_tilde shift fa_cflex caps fa_tilde ctrl ^^ altg ~
-key  50  base ] shift } caps ] ctrl ^] altg º numl nonl up nop
-key  29  base z shift Z caps Z ctrl ^Z altg «
-key  27  base x shift X caps X ctrl ^X altg »
+key  50  base ] shift } caps ] ctrl ^] altg 0x00BA numl nonl up nop
+key  29  base z shift Z caps Z ctrl ^Z altg 0x00AB
+key  27  base x shift X caps X ctrl ^X altg 0x00BB
 key   6  base c shift C caps C ctrl ^C altg nop
 key  25  base v shift V caps V ctrl ^V altg nop
 key   5  base b shift B caps B ctrl ^B altg nop
 key  17  base n shift N caps N ctrl ^N altg nop
-key  16  base m shift M caps M ctrl ^M altg µ
+key  16  base m shift M caps M ctrl ^M altg 0x00B5
 key  49  all hole
-key 100  base / shift | caps / ctrl ^\ altg ° numl nonl up nop
+key 100  base / shift | caps / ctrl ^\ altg 0x00B0 numl nonl up nop
 key  54  base , shift < caps , ctrl , altg ?
 key  55  base . shift > caps . ctrl . altg nop
-key  56  base ; shift : caps ; ctrl ; altg ¿
+key  56  base ; shift : caps ; ctrl ; altg 0x00BF
 #
 #
 #
diff --git a/usr/src/cmd/loadkeys/type_6/bulgaria b/usr/src/cmd/loadkeys/type_6/bulgaria
index 1846c455c5..feafdf59b3 100644
--- a/usr/src/cmd/loadkeys/type_6/bulgaria
+++ b/usr/src/cmd/loadkeys/type_6/bulgaria
@@ -22,8 +22,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Bulgaria Type 6 (USB) key layout
 #
 # Note, on the console, this keyboard layout is exactly
diff --git a/usr/src/cmd/loadkeys/type_6/canadian_bilingual b/usr/src/cmd/loadkeys/type_6/canadian_bilingual
index d27e0abe84..e727c55cbf 100644
--- a/usr/src/cmd/loadkeys/type_6/canadian_bilingual
+++ b/usr/src/cmd/loadkeys/type_6/canadian_bilingual
@@ -28,42 +28,42 @@
 # "caps lock" acts as "shift lock" on this keyboard
 #
 key  53  base / shift | caps / ctrl ^\ altg '\\'
-key  30  base 1 shift ! caps 1 ctrl 1 altg ±
+key  30  base 1 shift ! caps 1 ctrl 1 altg 0x00B1
 key  31  base 2 shift @ caps 2 ctrl 2 altg nop
-key  32  base 3 shift # caps 3 ctrl 3 altg £
-key  33  base 4 shift $ caps 4 ctrl 4 altg ¢
-key  34  base 5 shift % caps 5 ctrl 5 altg ¤
-key  35  base 6 shift ? caps 6 ctrl 6 altg ¬
+key  32  base 3 shift # caps 3 ctrl 3 altg 0x00A3
+key  33  base 4 shift $ caps 4 ctrl 4 altg 0x00A2
+key  34  base 5 shift % caps 5 ctrl 5 altg 0x00A4
+key  35  base 6 shift ? caps 6 ctrl 6 altg 0x00AC
 key  36  base 7 shift & caps 7 ctrl 7 altg {
 key  37  base 8 shift * caps 8 ctrl 8 altg }
 key  38  base 9 shift ( caps 9 ctrl 9 altg [
 key  39  base 0 shift ) caps 0 ctrl 0 altg ]
-key  45  base - shift _ caps - ctrl ^_ altg ½
-key  46  base = shift + caps = ctrl = altg ¬
+key  45  base - shift _ caps - ctrl ^_ altg 0x00B0
+key  46  base = shift + caps = ctrl = altg 0x00AC
 key  20  base q shift Q caps Q ctrl ^Q altg nop
 key  26  base w shift W caps W ctrl ^W altg nop
 key  8   base e shift E caps E ctrl ^E altg nop
 key  28  base y shift Y caps Y ctrl ^Y altg nop
-key  18  base o shift O caps O ctrl ^O altg §
-key  19  base p shift P caps P ctrl ^P altg ¶
+key  18  base o shift O caps O ctrl ^O altg 0x00A7
+key  19  base p shift P caps P ctrl ^P altg 0x00B6
 key  47  base fa_cflex shift fa_umlaut caps fa_cflex ctrl fa_cflex altg fa_grave
-key  48  base ç shift Ç caps Ç ctrl ç altg ~
+key  48  base 0x00E7 shift 0x00C7 caps 0x00C7 ctrl 0x00E7 altg ~
 key   4  base a shift A caps A ctrl ^A altg nop
 key  22  base s shift S caps S ctrl ^S altg nop
 key  51  base ; shift : caps ; ctrl ; altg °
-key  52  base è shift È caps È ctrl ¨ altg {
-key  50  base à shift À caps À ctrl à altg } numl nonl up nop
-key  29  base z shift Z caps Z ctrl ^Z altg «
-key  27  base x shift X caps X ctrl ^X altg »
+key  52  base 0x00E8 shift 0x00C8 caps 0x00C8 ctrl 0x00A8 altg {
+key  50  base 0x00E0 shift 0x00C0 caps 0x00C0 ctrl 0x00E0 altg } numl nonl up nop
+key  29  base z shift Z caps Z ctrl ^Z altg 0x00AB
+key  27  base x shift X caps X ctrl ^X altg 0x00BB
 key   6  base c shift C caps C ctrl ^C altg nop
 key  25  base v shift V caps V ctrl ^V altg nop
 key   5  base b shift B caps B ctrl ^B altg nop
 key  17  base n shift N caps N ctrl ^N altg nop
-key  16  base m shift M caps M ctrl ^M altg µ
+key  16  base m shift M caps M ctrl ^M altg 0x00B5
 key  54  base , shift '\'' caps , ctrl , altg <
 key  55  base . shift '"' caps . ctrl . altg >
-key  56  base é shift É caps É ctrl é altg fa_acute
-key 100  base ù shift Ù caps Ù ctrl ù altg nop numl nonl up nop
+key  56  base 0x00E9 shift 0x00C9 caps 0x00C9 ctrl 0x00E9 altg fa_acute
+key 100  base 0x00F9 shift 0x00D9 caps 0x00D9 ctrl 0x00F9 altg nop numl nonl up nop
 #
 #
 # New function keys assigned old codes
diff --git a/usr/src/cmd/loadkeys/type_6/canadian_french b/usr/src/cmd/loadkeys/type_6/canadian_french
index fab1b9a32c..8ebf7eecb8 100644
--- a/usr/src/cmd/loadkeys/type_6/canadian_french
+++ b/usr/src/cmd/loadkeys/type_6/canadian_french
@@ -22,40 +22,38 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Canadian French Type 6 (USB) key layout
 #
 # "caps lock" acts as "shift lock" on this keyboard
 #
-key  53  base ² shift nop caps ² ctrl ² altg nop
+key  53  base 0x00B2 shift nop caps 0x00B2 ctrl 0x00B2 altg nop
 key  30  base & shift 1 caps & ctrl & altg nop
-key  31  base é shift 2 caps é ctrl é altg ~
+key  31  base 0x00E9 shift 2 caps 0x00E9 ctrl 0x00E9 altg ~
 key  32  base '"' shift 3 caps '"' ctrl '"' altg #
 key  33  base '\'' shift 4 caps '\'' ctrl '\'' altg {
 key  34  base ( shift 5 caps ( ctrl ^[ altg [
 key  35  base - shift 6 caps - ctrl ^_ altg |
-key  36  base è shift 7 caps è ctrl è altg `
+key  36  base 0x00E8 shift 7 caps 0x00E8 ctrl 0x00E8 altg `
 key  37  base _ shift 8 caps _ ctrl ^\ altg \
-key  38  base ç shift 9 caps ç ctrl ^^ altg ^
-key  39  base à shift 0 caps à ctrl ^@ altg @
-key  45  base ) shift ° caps ) ctrl ^] altg ]
+key  38  base 0x00E7 shift 9 caps 0x00E7 ctrl ^^ altg ^
+key  39  base 0x00E0 shift 0 caps 0x00E0 ctrl ^@ altg @
+key  45  base ) shift 0x00B0 caps ) ctrl ^] altg ]
 key  46  base = shift + caps = ctrl = altg }
 key  20  base a shift A caps A ctrl ^A altg nop
 key  26  base z shift Z caps Z ctrl ^Z altg nop
 key  47  base fa_cflex shift fa_umlaut caps fa_cflex ctrl fa_cflex altg nop
-key  48  base $ shift £ caps $ ctrl $ altg ¤
+key  48  base $ shift 0x00A3 caps $ ctrl $ altg 0x00A4
 key   4  base q shift Q caps Q ctrl ^Q altg nop
 key  51  base m shift M caps M ctrl ^M altg nop
-key  52  base ù shift % caps ù ctrl ù altg nop
-key  50  base * shift µ caps * ctrl * altg nop numl nonl up nop
+key  52  base 0x00F9 shift % caps 0x00F9 ctrl 0x00F9 altg nop
+key  50  base * shift 0x00B5 caps * ctrl * altg nop numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl < altg nop numl nonl up nop
 key  29  base w shift W caps W ctrl ^W altg nop
 key  16  base , shift ? caps , ctrl , altg nop
 key  54  base ; shift . caps ; ctrl ; altg nop
 key  55  base : shift / caps : ctrl : altg nop
-key  56  base ! shift § caps ! ctrl ! altg nop
+key  56  base ! shift 0x00A7 caps ! ctrl ! altg nop
 #
 #
 #
diff --git a/usr/src/cmd/loadkeys/type_6/croatia b/usr/src/cmd/loadkeys/type_6/croatia
index bcedf7b51c..16530a2648 100644
--- a/usr/src/cmd/loadkeys/type_6/croatia
+++ b/usr/src/cmd/loadkeys/type_6/croatia
@@ -22,8 +22,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Croatia Type 6 (USB) key layout
 #
 # Note, on the console, this keyboard layout is exactly
diff --git a/usr/src/cmd/loadkeys/type_6/czech b/usr/src/cmd/loadkeys/type_6/czech
index c68d403b4f..e762e3d7af 100644
--- a/usr/src/cmd/loadkeys/type_6/czech
+++ b/usr/src/cmd/loadkeys/type_6/czech
@@ -21,8 +21,6 @@
 #
 # CDDL HEADER END
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Czech Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/denmark b/usr/src/cmd/loadkeys/type_6/denmark
index fbebfb1d56..4f493d11f6 100644
--- a/usr/src/cmd/loadkeys/type_6/denmark
+++ b/usr/src/cmd/loadkeys/type_6/denmark
@@ -22,14 +22,12 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Danish Type 6 (USB) key layout
 #
-key  53  base ½ shift § caps ½ ctrl ½ altg nop
+key  53  base 0x00BD shift 0x00A7 caps 0x00BD ctrl 0x00BD altg nop
 key  31  base 2 shift '"' caps 2 ctrl ^@ altg @
-key  32  base 3 shift # caps 3 ctrl 3 altg £
-key  33  base 4 shift ¤ caps 4 ctrl 4 altg $
+key  32  base 3 shift # caps 3 ctrl 3 altg 0x00A3
+key  33  base 4 shift 0x00A4 caps 4 ctrl 4 altg $
 key  34  base 5 shift % caps 5 ctrl 5 altg ~
 key  35  base 6 shift & caps 6 ctrl ^^ altg ^
 key  36  base 7 shift / caps 7 ctrl 7 altg {
@@ -38,10 +36,10 @@ key  38  base 9 shift ) caps 9 ctrl ^] altg ]
 key  39  base 0 shift = caps 0 ctrl 0 altg }
 key  45  base + shift ? caps + ctrl ^_ altg nop
 key  46  base fa_acute shift fa_grave caps fa_acute ctrl fa_acute altg |
-key  47  base å shift Å caps Å ctrl å altg nop
+key  47  base 0x00E5 shift 0x00C5 caps 0x00C5 ctrl 0x00E5 altg nop
 key  48  base fa_umlaut shift fa_cflex caps fa_umlaut ctrl fa_umlaut altg fa_tilde
-key  51  base æ shift Æ caps Æ ctrl æ altg nop
-key  52  base ø shift Ø caps Ø ctrl ø altg nop
+key  51  base 0x00E6 shift 0x00C6 caps 0x00C6 ctrl 0x00E6 altg nop
+key  52  base 0x00F8 shift 0x00D8 caps 0x00D8 ctrl 0x00F8 altg nop
 key  50  base '\'' shift * caps '\'' ctrl '\'' altg '`' numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl ^\ altg '\\' numl nonl up nop
diff --git a/usr/src/cmd/loadkeys/type_6/estonia b/usr/src/cmd/loadkeys/type_6/estonia
index eadf99a94a..8b9f62b3f1 100644
--- a/usr/src/cmd/loadkeys/type_6/estonia
+++ b/usr/src/cmd/loadkeys/type_6/estonia
@@ -30,13 +30,13 @@
 # However, all necessary ASCII characters are placed onto the right keys. 
 #
 #
-key  53  base ` shift fa_tilde caps ` ctrl ^^ altg '¬'
-key  30  base 1 shift ! caps 1 ctrl 1 altg ¹
+key  53  base fa_caron shift fa_tilde caps ` ctrl ^^ altg '~'
+key  30  base 1 shift ! caps 1 ctrl 1 altg 0x00B9
 key  31  base 2 shift '"' caps 2 ctrl ^@ altg @
-key  32  base 3 shift # caps 3 ctrl 3 altg £
-key  33  base 4 shift ¤ caps 4 ctrl 4 altg $
-key  34  base 5 shift % caps 5 ctrl 5 altg ½
-key  35  base 6 shift & caps 6 ctrl 6 altg '¬'
+key  32  base 3 shift # caps 3 ctrl 3 altg 0x00A2
+key  33  base 4 shift 0x00A4 caps 4 ctrl 4 altg $
+key  34  base 5 shift % caps 5 ctrl 5 altg 0x00BD
+key  35  base 6 shift & caps 6 ctrl 6 altg 0x00AC
 key  36  base 7 shift / caps 7 ctrl 7 altg {
 key  37  base 8 shift ( caps 8 ctrl ^[ altg [
 key  38  base 9 shift ) caps 9 ctrl ^] altg ]
@@ -44,17 +44,19 @@ key  39  base 0 shift = caps 0 ctrl 0 altg }
 key  45  base + shift ? caps + ctrl ^_ altg '\\'
 key  46  base fa_acute shift fa_grave caps fa_acute ctrl fa_acute altg `
 key  20  base q shift Q caps Q ctrl ^Q altg @
-key  47  base ü shift Ü caps Ü ctrl ü altg fa_umlaut
-key  48  base fa_umlaut shift ^ caps fa_umlaut ctrl fa_tilde altg ~
-key  51  base ö shift Ö caps Ö ctrl ö altg nop
-key  52  base ä shift Ä caps Ä ctrl ä altg ^
+key  47  base 0x00FC shift 0x00DC caps 0x00DC ctrl nop altg fa_umlaut
+key  48  base 0x00F5 shift 0x00D5 caps 0x00D5 ctrl nop altg ~
+key  51  base 0x00F6 shift 0x00D6 caps 0x00D6 ctrl nop altg nop
+key  52  base 0x00E4 shift 0x00C4 caps 0x00C4 ctrl nop altg ^
 key  50  base '\'' shift * caps '\'' ctrl '\'' altg '`' numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl ^| altg | numl nonl up nop
-key  29  base z shift Z caps Z ctrl ^Z altg «
-key  27  base x shift X caps X ctrl ^X altg »
-key   6  base c shift C caps C ctrl ^C altg ¢
-key  16  base m shift M caps M ctrl '\r' altg µ
+key  22  base s shift S caps S ctrl ^S altg 0x0161
+key  29  base z shift Z caps Z ctrl ^Z altg 0x017E
+key  27  base x shift X caps X ctrl ^X altg nop
+key   6  base c shift C caps C ctrl ^C altg 0x00A2
+key   8  base e shift E caps E ctrl ^E altg 0x20AC
+key  16  base m shift M caps M ctrl '\r' altg 0x00B5
 key  54  base , shift ; caps , ctrl , altg <
 key  55  base . shift : caps . ctrl . altg >
 key  56  base - shift _ caps - ctrl ^_ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/finnish b/usr/src/cmd/loadkeys/type_6/finnish
index 6a7f113331..bc3926aa17 100644
--- a/usr/src/cmd/loadkeys/type_6/finnish
+++ b/usr/src/cmd/loadkeys/type_6/finnish
@@ -22,13 +22,11 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Finnish Type 6 (USB) key layout
 #
-key  53  base  § shift ½ caps §  ctrl §  altg nop
+key  53  base 0x00A7 shift 0x00B0 caps 0x00A7 ctrl 0x00A7 altg nop
 key  31  base 2 shift '"' caps 2 ctrl ^@ altg @
-key  32  base 3 shift # caps 3 ctrl 3 altg £
+key  32  base 3 shift # caps 3 ctrl 3 altg 0x00A3
 key  33  base 4 shift ¤ caps 4 ctrl 4 altg $
 key  34  base 5 shift % caps 5 ctrl 5 altg nop
 key  35  base 6 shift & caps 6 ctrl 6 altg nop
@@ -38,10 +36,10 @@ key  38  base 9 shift ) caps 9 ctrl ^] altg ]
 key  39  base 0 shift = caps 0 ctrl 0 altg }
 key  45  base + shift ? caps + ctrl ^_ altg '\\'
 key  46  base fa_acute shift fa_grave caps fa_acute ctrl fa_acute altg nop
-key  47  base å shift Å caps Å ctrl å altg nop
+key  47  base 0x00E5 shift 0x00C5 caps 0x00C5 ctrl 0x00E5 altg nop
 key  48  base fa_umlaut shift ^ caps fa_umlaut ctrl fa_umlaut altg ~
-key  51  base ö shift Ö caps Ö ctrl ö altg nop
-key  52  base ä shift Ä caps Ä ctrl ä altg nop
+key  51  base 0x00F6 shift 0x00D6 caps 0x00D6 ctrl 0x00F6 altg nop
+key  52  base 0x00E4 shift 0x00C4 caps 0x00C4 ctrl 0x00E4 altg nop
 key  50  base '\'' shift * caps '\'' ctrl '\'' altg '`' numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl ^| altg | numl nonl up nop
diff --git a/usr/src/cmd/loadkeys/type_6/france b/usr/src/cmd/loadkeys/type_6/france
index 0e1c39c3cb..edcad8053c 100644
--- a/usr/src/cmd/loadkeys/type_6/france
+++ b/usr/src/cmd/loadkeys/type_6/france
@@ -22,40 +22,38 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # French Type 6 (USB) key layout
 #
 # "caps lock" acts as "shift lock" on this keyboard
 #
-key  53  base ² shift nop caps ² ctrl ² altg nop
+key  53  base 0x00B2 shift nop caps 0x00B2 ctrl 0x00B2 altg nop
 key  30  base & shift 1 caps & ctrl & altg nop
-key  31  base é shift 2 caps é ctrl é altg ~
+key  31  base 0x00E9 shift 2 caps 0x00E9 ctrl 0x00E9 altg ~
 key  32  base '"' shift 3 caps '"' ctrl '"' altg #
 key  33  base '\'' shift 4 caps '\'' ctrl '\'' altg {
 key  34  base ( shift 5 caps ( ctrl ^[ altg [
 key  35  base - shift 6 caps - ctrl ^_ altg |
-key  36  base è shift 7 caps è ctrl è altg `
+key  36  base 0x00E8 shift 7 caps 0x00E8 ctrl 0x00E8 altg `
 key  37  base _ shift 8 caps _ ctrl ^\ altg \
-key  38  base ç shift 9 caps ç ctrl ^^ altg ^
-key  39  base à shift 0 caps à ctrl ^@ altg @
-key  45  base ) shift ° caps ) ctrl ^] altg ]
+key  38  base 0x00E7 shift 9 caps 0x00E7 ctrl ^^ altg ^
+key  39  base 0x00E0 shift 0 caps 0x00E0 ctrl ^@ altg @
+key  45  base ) shift 0x00B0 caps ) ctrl ^] altg ]
 key  46  base = shift + caps = ctrl = altg }
 key  20  base a shift A caps A ctrl ^A altg nop
 key  26  base z shift Z caps Z ctrl ^Z altg nop
 key  47  base fa_cflex shift fa_umlaut caps fa_cflex ctrl fa_cflex altg nop
-key  48  base $ shift £ caps $ ctrl $ altg ¤
+key  48  base $ shift 0x00A3 caps $ ctrl $ altg 0x00A4
 key   4  base q shift Q caps Q ctrl ^Q altg nop
 key  51  base m shift M caps M ctrl ^M altg nop
-key  52  base ù shift % caps ù ctrl ù altg nop
-key  50  base * shift µ caps * ctrl * altg nop numl nonl up nop
+key  52  base 0x00F9 shift % caps 0x00F9 ctrl 0x00F9 altg nop
+key  50  base * shift 0x00B5 caps * ctrl * altg nop numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl < altg nop numl nonl up nop
 key  29  base w shift W caps W ctrl ^W altg nop
 key  16  base , shift ? caps , ctrl , altg nop
 key  54  base ; shift . caps ; ctrl ; altg nop
 key  55  base : shift / caps : ctrl : altg nop
-key  56  base ! shift § caps ! ctrl ! altg nop
+key  56  base ! shift 0x00A7 caps ! ctrl ! altg nop
 #
 #
 #
diff --git a/usr/src/cmd/loadkeys/type_6/germany b/usr/src/cmd/loadkeys/type_6/germany
index c26ba4eee1..1377c4c4b4 100644
--- a/usr/src/cmd/loadkeys/type_6/germany
+++ b/usr/src/cmd/loadkeys/type_6/germany
@@ -22,16 +22,14 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # German Type 6 (USB) key layout
 #
 # "caps lock" acts as "shift lock" on this keyboard
 #
-key  53  base ^ shift ° caps ^ ctrl ^^ altg nop
+key  53  base ^ shift 0x00B0 caps ^ ctrl ^^ altg nop
 key  30  base 1 shift ! caps 1 ctrl 1 altg nop
-key  31  base 2 shift '"' caps 2 ctrl ^@ altg ²
-key  32  base 3 shift § caps 3 ctrl 3 altg ³
+key  31  base 2 shift '"' caps 2 ctrl ^@ altg 0x00B2
+key  32  base 3 shift 0x00A7 caps 3 ctrl 3 altg 0x00B3
 key  33  base 4 shift $ caps 4 ctrl 4 altg nop
 key  34  base 5 shift % caps 5 ctrl 5 altg nop
 key  35  base 6 shift & caps 6 ctrl 6 altg nop
@@ -39,19 +37,19 @@ key  36  base 7 shift / caps 7 ctrl 7 altg {
 key  37  base 8 shift ( caps 8 ctrl ^[ altg [
 key  38  base 9 shift ) caps 9 ctrl ^] altg ]
 key  39  base 0 shift = caps 0 ctrl 0 altg }
-key  45  base ß shift ? caps ß ctrl ^\ altg '\\'
+key  45  base 0x00DF shift ? caps 0x00DF ctrl ^\ altg '\\'
 key  46  base fa_acute shift fa_grave caps fa_acute ctrl fa_acute altg nop
 key  20  base q shift Q caps Q ctrl ^Q altg @
 key  28  base z shift Z caps Z ctrl ^Z altg nop
-key  47  base ü shift Ü caps Ü ctrl ü altg nop
+key  47  base 0x00FC shift 0x00DC caps 0x00DC ctrl 0x00FC altg nop
 key  48  base + shift * caps + ctrl + altg ~
-key  51  base ö shift Ö caps Ö ctrl ö altg nop
-key  52  base ä shift Ä caps Ä ctrl ä altg nop
+key  51  base 0x00F6 shift 0x00D6 caps 0x00D6 ctrl 0x00F6 altg nop
+key  52  base 0x00E4 shift 0x00C4 caps 0x00C4 ctrl 0x00E4 altg nop
 key  50  base # shift '\'' caps # ctrl # altg '`' numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl < altg | numl nonl up nop
 key  29  base y shift Y caps Y ctrl ^Y altg nop
-key  16  base m shift M caps M ctrl '\r' altg µ
+key  16  base m shift M caps M ctrl '\r' altg 0x00B5
 key  54  base , shift ; caps , ctrl , altg nop
 key  55  base . shift : caps . ctrl . altg nop
 key  56  base - shift _ caps - ctrl ^_ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/greece b/usr/src/cmd/loadkeys/type_6/greece
index c20507e228..aa9f6ca157 100644
--- a/usr/src/cmd/loadkeys/type_6/greece
+++ b/usr/src/cmd/loadkeys/type_6/greece
@@ -22,8 +22,6 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Greek Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/hungary b/usr/src/cmd/loadkeys/type_6/hungary
index 668765061f..0227c744b2 100644
--- a/usr/src/cmd/loadkeys/type_6/hungary
+++ b/usr/src/cmd/loadkeys/type_6/hungary
@@ -22,8 +22,6 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Hungary Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/iceland b/usr/src/cmd/loadkeys/type_6/iceland
index e18c8206e2..4ff9b4ab8a 100644
--- a/usr/src/cmd/loadkeys/type_6/iceland
+++ b/usr/src/cmd/loadkeys/type_6/iceland
@@ -22,8 +22,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Iceland Type 6 (USB) key layout
 #
 # Note, on the console, this keyboard layout is exactly
diff --git a/usr/src/cmd/loadkeys/type_6/italy b/usr/src/cmd/loadkeys/type_6/italy
index c2b70a221b..6c9e1effc0 100644
--- a/usr/src/cmd/loadkeys/type_6/italy
+++ b/usr/src/cmd/loadkeys/type_6/italy
@@ -22,25 +22,23 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Italian Type 6 (USB) key layout
 #
 key  53  base '\\' shift | caps '\\' ctrl ^\ altg nop
 key  31  base 2 shift '"' caps 2 ctrl 2 altg nop
-key  32  base 3 shift £ caps 3 ctrl 3 altg nop
+key  32  base 3 shift 0x00A3 caps 3 ctrl 3 altg nop
 key  35  base 6 shift & caps 6 ctrl 6 altg nop
 key  36  base 7 shift / caps 7 ctrl 7 altg nop
 key  37  base 8 shift ( caps 8 ctrl 8 altg {
 key  38  base 9 shift ) caps 9 ctrl 9 altg }
 key  39  base 0 shift = caps 0 ctrl 0 altg nop
 key  45  base '\'' shift ? caps '\'' ctrl '\'' altg '`'
-key  46  base ì shift ^ caps Ì ctrl ^^ altg nop
-key  47  base è shift é caps È ctrl ^[ altg [
+key  46  base 0x00EC shift ^ caps 0x00CC ctrl ^^ altg nop
+key  47  base 0x00E8 shift 0x00E9 caps 0x00C8 ctrl ^[ altg [
 key  48  base + shift * caps + ctrl ^] altg ]
-key  51  base ò shift ç caps Ò ctrl ^@ altg @
-key  52  base à shift ° caps À ctrl à altg #
-key  50  base ù shift § caps Ù ctrl ù altg ~ numl nonl up nop
+key  51  base 0x00F2 shift 0x00E7 caps 0x00D2 ctrl ^@ altg @
+key  52  base 0x00E0 shift 0x00B0 caps 0x00C0 ctrl 0x00E0 altg #
+key  50  base 0x00F9 shift 0x00A7 caps 0x00D9 ctrl 0x00F9 altg ~ numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl < altg nop numl nonl up nop
 key  54  base , shift ; caps , ctrl , altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/japan b/usr/src/cmd/loadkeys/type_6/japan
index c4b2ea1eeb..37f87cf47b 100644
--- a/usr/src/cmd/loadkeys/type_6/japan
+++ b/usr/src/cmd/loadkeys/type_6/japan
@@ -22,8 +22,6 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Japanese Type 6 (USB) key layout
 #
 # key 13: ROMAN/KANA
diff --git a/usr/src/cmd/loadkeys/type_6/korea b/usr/src/cmd/loadkeys/type_6/korea
index 2f8df8125f..473a996db6 100644
--- a/usr/src/cmd/loadkeys/type_6/korea
+++ b/usr/src/cmd/loadkeys/type_6/korea
@@ -22,8 +22,6 @@
 #
 # CDDL HEADER END
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Korean Type 6 (USB) key layout
 #
 #
diff --git a/usr/src/cmd/loadkeys/type_6/latinamerica b/usr/src/cmd/loadkeys/type_6/latinamerica
index 26182531ce..a383f26390 100644
--- a/usr/src/cmd/loadkeys/type_6/latinamerica
+++ b/usr/src/cmd/loadkeys/type_6/latinamerica
@@ -22,11 +22,9 @@
 #
 # CDDL HEADER END
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Latin American Type 6 (USB) key layout
 #
-key  53  base | shift ° caps | ctrl hole altg ¬
+key  53  base | shift 0x00B0 caps | ctrl hole altg 0x00AC
 key  30  base 1 shift ! caps 1 ctrl 1 altg nop
 key  31  base 2 shift '"' caps 2 ctrl 2 altg nop
 key  32  base 3 shift # caps 3 ctrl 3 altg nop
@@ -38,11 +36,11 @@ key  37  base 8 shift ( caps 8 ctrl 8 altg nop
 key  38  base 9 shift ) caps 9 ctrl 9 altg nop
 key  39  base 0 shift = caps 0 ctrl 0 altg nop
 key  45  base '\'' shift ? caps '\'' ctrl '\'' altg '\\'
-key  46  base ¿ shift ¡ caps ¿ ctrl ¿ altg nop
+key  46  base 0x00BF shift 0x00A1 caps 0x00BF ctrl 0x00BF altg nop
 key  20  base q shift Q caps Q ctrl ^@ altg @
 key  47  base fa_acute shift fa_umlaut caps fa_acute ctrl fa_acute altg nop
 key  48  base + shift * caps + ctrl + altg ~
-key  51  base ñ shift Ñ caps Ñ ctrl ñ altg nop
+key  51  base 0x00F1 shift 0x00D1 caps 0x00D1 ctrl 0x00F1 altg nop
 key  52  base { shift [ caps { ctrl ^[ altg ^
 key  50  base } shift ] caps } ctrl ^] altg ` numl nonl up nop
 key  49  all hole
diff --git a/usr/src/cmd/loadkeys/type_6/latvia b/usr/src/cmd/loadkeys/type_6/latvia
index 99d9514c0d..b2794e5186 100644
--- a/usr/src/cmd/loadkeys/type_6/latvia
+++ b/usr/src/cmd/loadkeys/type_6/latvia
@@ -22,8 +22,6 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Latvian Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/lithuania b/usr/src/cmd/loadkeys/type_6/lithuania
index 9b5fa55d8a..a594d3f440 100644
--- a/usr/src/cmd/loadkeys/type_6/lithuania
+++ b/usr/src/cmd/loadkeys/type_6/lithuania
@@ -22,8 +22,6 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Lithuanian Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/macedonia b/usr/src/cmd/loadkeys/type_6/macedonia
index f287e76aa9..a48c051c54 100644
--- a/usr/src/cmd/loadkeys/type_6/macedonia
+++ b/usr/src/cmd/loadkeys/type_6/macedonia
@@ -22,8 +22,6 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Macedonian Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/maltauk b/usr/src/cmd/loadkeys/type_6/maltauk
index 6e2862208d..71b10d6f09 100644
--- a/usr/src/cmd/loadkeys/type_6/maltauk
+++ b/usr/src/cmd/loadkeys/type_6/maltauk
@@ -22,8 +22,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Malta UK Type 6 (USB) key layout
 #
 # Note, on the console, this keyboard layout is exactly
diff --git a/usr/src/cmd/loadkeys/type_6/maltaus b/usr/src/cmd/loadkeys/type_6/maltaus
index 4e95c9aa28..bc93655470 100644
--- a/usr/src/cmd/loadkeys/type_6/maltaus
+++ b/usr/src/cmd/loadkeys/type_6/maltaus
@@ -22,8 +22,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Malta US Type 6 (USB) key layout
 #
 # Note, on the console, this keyboard layout is exactly
diff --git a/usr/src/cmd/loadkeys/type_6/netherlands b/usr/src/cmd/loadkeys/type_6/netherlands
index a412f185ff..7524bacf09 100644
--- a/usr/src/cmd/loadkeys/type_6/netherlands
+++ b/usr/src/cmd/loadkeys/type_6/netherlands
@@ -22,37 +22,35 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Dutch Type 6 (USB) key layout
 #
-key  53  base @ shift § caps @ ctrl ^@ altg '¬'
-key  30  base 1 shift ! caps 1 ctrl 1 altg ¹
-key  31  base 2 shift '"' caps 2 ctrl 2 altg ²
-key  32  base 3 shift # caps 3 ctrl 3 altg ³
-key  33  base 4 shift $ caps 4 ctrl 4 altg ¼
-key  34  base 5 shift % caps 5 ctrl 5 altg ½
-key  35  base 6 shift & caps 6 ctrl 6 altg ¾
-key  36  base 7 shift _ caps 7 ctrl ^_ altg £
+key  53  base @ shift 0x00A7 caps @ ctrl ^@ altg 0x00AC
+key  30  base 1 shift ! caps 1 ctrl 1 altg 0x00B9
+key  31  base 2 shift '"' caps 2 ctrl 2 altg 0x00B2
+key  32  base 3 shift # caps 3 ctrl 3 altg 0x00B3
+key  33  base 4 shift $ caps 4 ctrl 4 altg 0x00BC
+key  34  base 5 shift % caps 5 ctrl 5 altg 0x00BD
+key  35  base 6 shift & caps 6 ctrl 6 altg 0x00BE
+key  36  base 7 shift _ caps 7 ctrl ^_ altg 0x00A3
 key  37  base 8 shift ( caps 8 ctrl 8 altg {
 key  38  base 9 shift ) caps 9 ctrl ^] altg }
 key  39  base 0 shift '\'' caps 0 ctrl 0 altg '`'
 key  45  base / shift ? caps / ctrl ^\ altg '\\'
-key  46  base ° shift fa_tilde caps ° ctrl ° altg fa_cedilla
+key  46  base 0x00B0 shift fa_tilde caps 0x00B0 ctrl 0x00B0 altg fa_cedilla
 key  47  base fa_umlaut shift fa_cflex caps fa_umlaut ctrl fa_umlaut altg nop
 key  48  base * shift | caps * ctrl * altg ~
-key  22  base s shift S caps S ctrl ^S altg ß
-key  51  base + shift ± caps + ctrl + altg nop
+key  22  base s shift S caps S ctrl ^S altg 0x00DF
+key  51  base + shift 0x00B1 caps + ctrl + altg nop
 key  52  base fa_acute shift fa_grave caps fa_acute ctrl fa_acute altg nop
 key  50  base < shift > caps < ctrl ^^ altg ^ numl nonl up nop
 key  49  all hole
-key 100  base ] shift [ caps [ ctrl ^[ altg ¦ numl nonl up nop
-key  29  base z shift Z caps Z ctrl ^Z altg «
-key  27  base x shift X caps X ctrl ^X altg »
-key   6  base c shift C caps C ctrl ^C altg ¢
-key  16  base m shift M caps M ctrl '\r' altg µ
+key 100  base ] shift [ caps [ ctrl ^[ altg 0x00A6 numl nonl up nop
+key  29  base z shift Z caps Z ctrl ^Z altg 0x00AB
+key  27  base x shift X caps X ctrl ^X altg 0x00BB
+key   6  base c shift C caps C ctrl ^C altg 0x00A2
+key  16  base m shift M caps M ctrl '\r' altg 0x00B5
 key  54  base , shift ; caps , ctrl , altg nop
-key  55  base . shift : caps . ctrl . altg ·
+key  55  base . shift : caps . ctrl . altg 0x00B7
 key  56  base - shift = caps - ctrl ^_ altg nop
 #
 #
diff --git a/usr/src/cmd/loadkeys/type_6/norway b/usr/src/cmd/loadkeys/type_6/norway
index 182f912305..21f93521a3 100644
--- a/usr/src/cmd/loadkeys/type_6/norway
+++ b/usr/src/cmd/loadkeys/type_6/norway
@@ -22,14 +22,12 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Norwegian Type 6 (USB) key layout
 #
-key  53  base | shift § caps | ctrl | altg nop
+key  53  base | shift 0x00A7 caps | ctrl | altg nop
 key  31  base 2 shift '"' caps 2 ctrl ^@ altg @
-key  32  base 3 shift # caps 3 ctrl 3 altg £
-key  33  base 4 shift ¤ caps 4 ctrl 4 altg $
+key  32  base 3 shift # caps 3 ctrl 3 altg 0x00A3
+key  33  base 4 shift 0x00A4 caps 4 ctrl 4 altg $
 key  34  base 5 shift % caps 5 ctrl 5 altg ~
 key  35  base 6 shift & caps 6 ctrl ^^ altg ^
 key  36  base 7 shift / caps 7 ctrl 7 altg {
@@ -38,10 +36,10 @@ key  38  base 9 shift ) caps 9 ctrl ^] altg ]
 key  39  base 0 shift = caps 0 ctrl 0 altg }
 key  45  base + shift ? caps + ctrl + altg nop
 key  46  base '\\' shift fa_grave caps '\\' ctrl ^\ altg fa_acute
-key  47  base å shift Å caps Å ctrl å altg nop
+key  47  base 0x00E5 shift 0x00C5 caps 0x00C5 ctrl 0x00E5 altg nop
 key  48  base fa_umlaut shift fa_cflex caps fa_umlaut ctrl ^^ altg fa_tilde
-key  51  base ø shift Ø caps Ø ctrl ø altg nop
-key  52  base æ shift Æ caps Æ ctrl æ altg nop
+key  51  base 0x00F8 shift 0x00D8 caps 0x00D8 ctrl 0x00F8 altg nop
+key  52  base 0x00E6 shift 0x00C6 caps 0x00C6 ctrl 0x00E6 altg nop
 key  50  base '\'' shift * caps '\'' ctrl '\'' altg '`' numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl < altg nop numl nonl up nop
diff --git a/usr/src/cmd/loadkeys/type_6/poland b/usr/src/cmd/loadkeys/type_6/poland
index 4c7c605aef..b5da164e8a 100644
--- a/usr/src/cmd/loadkeys/type_6/poland
+++ b/usr/src/cmd/loadkeys/type_6/poland
@@ -21,8 +21,6 @@
 #
 # CDDL HEADER END
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Polish  Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/portugal b/usr/src/cmd/loadkeys/type_6/portugal
index 335ea464e5..817b821ab7 100644
--- a/usr/src/cmd/loadkeys/type_6/portugal
+++ b/usr/src/cmd/loadkeys/type_6/portugal
@@ -22,14 +22,12 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Portuguese Type 6 (USB) key layout
 #
 key  53  base '\\' shift | caps '\\' ctrl ^\ altg nop
 key  31  base 2 shift '"' caps 2 ctrl ^@ altg @
-key  32  base 3 shift # caps 3 ctrl 3 altg £
-key  33  base 4 shift $ caps 4 ctrl 4 altg §
+key  32  base 3 shift # caps 3 ctrl 3 altg 0x00A3
+key  33  base 4 shift $ caps 4 ctrl 4 altg 0x00A7
 key  34  base 5 shift % caps 5 ctrl 5 altg ~
 key  35  base 6 shift & caps 6 ctrl ^^ altg ^
 key  36  base 7 shift / caps 7 ctrl 7 altg {
@@ -37,11 +35,11 @@ key  37  base 8 shift ( caps 8 ctrl ^[ altg [
 key  38  base 9 shift ) caps 9 ctrl ^] altg ]
 key  39  base 0 shift = caps 0 ctrl 0 altg }
 key  45  base '\'' shift ? caps '\'' ctrl '\'' altg '`'
-key  46  base « shift » caps « ctrl « altg nop
+key  46  base 0x00AB shift 0x00BB caps 0x00AB ctrl 0x00AB altg nop
 key  47  base + shift * caps + ctrl + altg fa_umlaut
 key  48  base fa_acute shift fa_grave caps fa_acute ctrl fa_acute altg nop
-key  51  base ç shift Ç caps Ç ctrl ç altg nop
-key  52  base º shift ª caps º ctrl º altg nop
+key  51  base 0x00E7 shift 0x00C7 caps 0x00C7 ctrl 0x00E7 altg nop
+key  52  base 0x00BA shift 0x00AA caps 0x00BA ctrl 0x00BA altg nop
 key  50  base fa_tilde shift fa_cflex caps fa_tilde ctrl ^^ altg nop numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl < altg nop numl nonl up nop
diff --git a/usr/src/cmd/loadkeys/type_6/russia b/usr/src/cmd/loadkeys/type_6/russia
index 15a7272e43..22803f8357 100644
--- a/usr/src/cmd/loadkeys/type_6/russia
+++ b/usr/src/cmd/loadkeys/type_6/russia
@@ -22,8 +22,6 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Russian Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/serbiaandmontenegro b/usr/src/cmd/loadkeys/type_6/serbiaandmontenegro
index 9b91b1fef0..68712e9ee5 100644
--- a/usr/src/cmd/loadkeys/type_6/serbiaandmontenegro
+++ b/usr/src/cmd/loadkeys/type_6/serbiaandmontenegro
@@ -21,8 +21,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Serbia-And-Montenegro Type 6 (USB) key layout
 #
 # Note, on the console, this keyboard layout is exactly
diff --git a/usr/src/cmd/loadkeys/type_6/slovakia b/usr/src/cmd/loadkeys/type_6/slovakia
index 038490b74a..429d36edff 100644
--- a/usr/src/cmd/loadkeys/type_6/slovakia
+++ b/usr/src/cmd/loadkeys/type_6/slovakia
@@ -20,8 +20,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Slovakia Type 6 (USB) key layout
 #
 # Note, on the console, this keyboard layout is exactly
diff --git a/usr/src/cmd/loadkeys/type_6/spain b/usr/src/cmd/loadkeys/type_6/spain
index 41acd98d81..b9d60e76f7 100644
--- a/usr/src/cmd/loadkeys/type_6/spain
+++ b/usr/src/cmd/loadkeys/type_6/spain
@@ -23,28 +23,26 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Spanish Type 6 (USB) key layout
 #
-key  53  base º shift ª caps º ctrl ^\ altg '\\'
+key  53  base 0x00BA shift 0x00AA caps 0x00BA ctrl ^\ altg '\\'
 key  30  base 1 shift ! caps 1 ctrl 1 altg |
 key  31  base 2 shift '"' caps 2 ctrl ^@ altg @
-key  32  base 3 shift · caps 3 ctrl 3 altg #
+key  32  base 3 shift 0x00B7 caps 3 ctrl 3 altg #
 key  33  base 4 shift $ caps 4 ctrl ^^ altg ^
 key  34  base 5 shift % caps 5 ctrl 5 altg ~
-key  35  base 6 shift & caps 6 ctrl 6 altg ¬
+key  35  base 6 shift & caps 6 ctrl 6 altg 0x00AC
 key  36  base 7 shift / caps 7 ctrl 7 altg nop
 key  37  base 8 shift ( caps 8 ctrl 8 altg nop
 key  38  base 9 shift ) caps 9 ctrl 9 altg nop
 key  39  base 0 shift = caps 0 ctrl 0 altg nop
 key  45  base '\'' shift ? caps '\'' ctrl '\'' altg '`'
-key  46  base ¡ shift ¿ caps ¡ ctrl ¡ altg nop
+key  46  base 0x00A1 shift 0x00BF caps 0x00A1 ctrl 0x00A1 altg nop
 key  47  base fa_grave shift fa_cflex caps fa_grave ctrl ^[ altg [
 key  48  base + shift * caps + ctrl ^] altg ]
-key  51  base ñ shift Ñ caps Ñ ctrl ñ altg nop
+key  51  base 0x00F1 shift 0x00D1 caps 0x00D1 ctrl 0x00F1 altg nop
 key  52  base fa_acute shift fa_umlaut caps fa_acute ctrl fa_acute altg {
-key  50  base ç shift Ç caps Ç ctrl ç altg } numl nonl up nop
+key  50  base 0x00E7 shift 0x00C7 caps 0x00C7 ctrl 0x00E7 altg } numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl ^^ altg nop numl nonl up nop
 key  54  base , shift ; caps , ctrl , altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/sweden b/usr/src/cmd/loadkeys/type_6/sweden
index 2561cc7c2f..9b04ff05af 100644
--- a/usr/src/cmd/loadkeys/type_6/sweden
+++ b/usr/src/cmd/loadkeys/type_6/sweden
@@ -22,14 +22,12 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Swedish Type 6 (USB) key layout
 #
-key  53  base  § shift ½ caps §  ctrl §  altg nop
+key  53  base 0x00A7 shift 0x00BD caps 0x00A7  ctrl 0x00A7  altg nop
 key  31  base 2 shift '"' caps 2 ctrl ^@ altg @
-key  32  base 3 shift # caps 3 ctrl 3 altg £
-key  33  base 4 shift ¤ caps 4 ctrl 4 altg $
+key  32  base 3 shift # caps 3 ctrl 3 altg 0x00A3
+key  33  base 4 shift 0x00A4 caps 4 ctrl 4 altg $
 key  34  base 5 shift % caps 5 ctrl 5 altg nop
 key  35  base 6 shift & caps 6 ctrl 6 altg nop
 key  36  base 7 shift / caps 7 ctrl 7 altg {
@@ -38,10 +36,10 @@ key  38  base 9 shift ) caps 9 ctrl ^] altg ]
 key  39  base 0 shift = caps 0 ctrl 0 altg }
 key  45  base + shift ? caps + ctrl ^_ altg '\\'
 key  46  base fa_acute shift fa_grave caps fa_acute ctrl fa_acute altg nop
-key  47  base å shift Å caps Å ctrl å altg nop
+key  47  base 0x00E5 shift 0x00C5 caps 0x00C5 ctrl 0x00E5 altg nop
 key  48  base fa_umlaut shift ^ caps fa_umlaut ctrl fa_umlaut altg ~
-key  51  base ö shift Ö caps Ö ctrl ö altg nop
-key  52  base ä shift Ä caps Ä ctrl ä altg nop
+key  51  base 0x00F6 shift 0x00D6 caps 0x00D6 ctrl 0x00F6 altg nop
+key  52  base 0x00E4 shift 0x00C4 caps 0x00C4 ctrl 0x00E4 altg nop
 key  50  base '\'' shift * caps '\'' ctrl '\'' altg '`' numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl ^| altg | numl nonl up nop
diff --git a/usr/src/cmd/loadkeys/type_6/swiss_french b/usr/src/cmd/loadkeys/type_6/swiss_french
index 0b4efa5ca6..5a5e9af0fe 100644
--- a/usr/src/cmd/loadkeys/type_6/swiss_french
+++ b/usr/src/cmd/loadkeys/type_6/swiss_french
@@ -22,15 +22,13 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Swiss French Type 6 (USB) key layout
 #
-key  53  base § shift ° caps § ctrl § altg nop
+key  53  base 0x00A7 shift 0x00B0 caps 0x00A7 ctrl 0x00A7 altg nop
 key  30  base 1 shift + caps 1 ctrl 1 altg |
 key  31  base 2 shift '"' caps 2 ctrl ^@ altg @
 key  32  base 3 shift * caps 3 ctrl 3 altg #
-key  33  base 4 shift ç caps 4 ctrl ^^ altg ^
+key  33  base 4 shift 0x00E7 caps 4 ctrl ^^ altg ^
 key  34  base 5 shift % caps 5 ctrl 5 altg ~
 key  35  base 6 shift & caps 6 ctrl 6 altg nop
 key  36  base 7 shift / caps 7 ctrl 7 altg nop
@@ -40,11 +38,11 @@ key  39  base 0 shift = caps 0 ctrl 0 altg '`'
 key  45  base '\'' shift ? caps '\'' ctrl '\'' altg fa_acute
 key  46  base fa_cflex shift fa_grave caps fa_cflex ctrl ^^ altg fa_tilde
 key  28  base z shift Z caps Z ctrl ^Z altg nop
-key  47  base è shift ü caps È ctrl ^[ altg [
+key  47  base 0x00E8 shift 0x00FC caps 0x00C8 ctrl ^[ altg [
 key  48  base fa_umlaut shift ! caps fa_umlaut ctrl ^] altg ]
-key  51  base é shift ö caps É ctrl é altg nop
-key  52  base à shift ä caps À ctrl à altg {
-key  50  base $ shift £ caps $ ctrl $ altg } numl nonl up nop
+key  51  base 0x00E9 shift 0x00F6 caps 0x00C9 ctrl 0x00E9 altg nop
+key  52  base 0x00E0 shift 0x00E4 caps 0x00C0 ctrl 0x00E0 altg {
+key  50  base $ shift 0x00A3 caps $ ctrl $ altg } numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl ^\ altg '\\' numl nonl up nop
 key  29  base y shift Y caps Y ctrl ^Y altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/swiss_german b/usr/src/cmd/loadkeys/type_6/swiss_german
index 0131514521..bae367d68d 100644
--- a/usr/src/cmd/loadkeys/type_6/swiss_german
+++ b/usr/src/cmd/loadkeys/type_6/swiss_german
@@ -22,15 +22,13 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Swiss German Type 6 (USB) key layout
 #
-key  53  base § shift ° caps § ctrl § altg nop
+key  53  base 0x00A7 shift 0x00B0 caps 0x00A7 ctrl 0x00A7 altg nop
 key  30  base 1 shift + caps 1 ctrl 1 altg |
 key  31  base 2 shift '"' caps 2 ctrl ^@ altg @
 key  32  base 3 shift * caps 3 ctrl 3 altg #
-key  33  base 4 shift ç caps 4 ctrl ^^ altg ^
+key  33  base 4 shift 0x00E7 caps 4 ctrl ^^ altg ^
 key  34  base 5 shift % caps 5 ctrl 5 altg ~
 key  35  base 6 shift & caps 6 ctrl 6 altg nop
 key  36  base 7 shift / caps 7 ctrl 7 altg nop
@@ -40,11 +38,11 @@ key  39  base 0 shift = caps 0 ctrl 0 altg '`'
 key  45  base '\'' shift ? caps '\'' ctrl '\'' altg fa_acute
 key  46  base fa_cflex shift fa_grave caps fa_cflex ctrl ^^ altg fa_tilde
 key  28  base z shift Z caps Z ctrl ^Z altg nop
-key  47  base ü shift è caps Ü ctrl ^[ altg [
+key  47  base 0x00FC shift 0x00E8 caps 0x00DC ctrl ^[ altg [
 key  48  base fa_umlaut shift ! caps fa_umlaut ctrl ^] altg ]
-key  51  base ö shift é caps Ö ctrl ö altg nop
-key  52  base ä shift à caps Ä ctrl ä altg {
-key  50  base $ shift £ caps $ ctrl $ altg } numl nonl up nop
+key  51  base 0x00F6 shift 0x00E9 caps 0x00D6 ctrl 0x00F6 altg nop
+key  52  base 0x00E4 shift 0x00E0 caps 0x00C4 ctrl 0x00E4 altg {
+key  50  base $ shift 0x00A3 caps $ ctrl $ altg } numl nonl up nop
 key  49  all hole
 key 100  base < shift > caps < ctrl ^\ altg '\\' numl nonl up nop
 key  29  base y shift Y caps Y ctrl ^Y altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/turkeyf b/usr/src/cmd/loadkeys/type_6/turkeyf
index 56d77fffc2..d74476ea09 100644
--- a/usr/src/cmd/loadkeys/type_6/turkeyf
+++ b/usr/src/cmd/loadkeys/type_6/turkeyf
@@ -21,8 +21,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Turkey F Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/turkeyq b/usr/src/cmd/loadkeys/type_6/turkeyq
index e794343a27..a8e337c3dd 100644
--- a/usr/src/cmd/loadkeys/type_6/turkeyq
+++ b/usr/src/cmd/loadkeys/type_6/turkeyq
@@ -21,8 +21,6 @@
 # Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-#
 # Turkey F Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/loadkeys/type_6/uk b/usr/src/cmd/loadkeys/type_6/uk
index 5f1ab05034..1a07302667 100644
--- a/usr/src/cmd/loadkeys/type_6/uk
+++ b/usr/src/cmd/loadkeys/type_6/uk
@@ -22,13 +22,11 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # UK Type 6 (USB) key layout
 #
-key  53  base ` shift ¬ caps ` ctrl ` altg ¦
+key  53  base ` shift 0x00AC caps ` ctrl ` altg 0x00A6
 key  31  base 2 shift '"' caps 2 ctrl 2 altg nop
-key  32  base 3 shift £ caps 3 ctrl 3 altg nop
+key  32  base 3 shift 0x00A3 caps 3 ctrl 3 altg nop
 key  52  base '\'' shift @ caps '\'' ctrl ^@ altg nop
 key  50  base # shift ~ caps # ctrl # altg nop numl nonl up nop
 key  49  all hole
diff --git a/usr/src/cmd/loadkeys/type_6/us b/usr/src/cmd/loadkeys/type_6/us
index 8d66fdadd0..4375f25e12 100644
--- a/usr/src/cmd/loadkeys/type_6/us
+++ b/usr/src/cmd/loadkeys/type_6/us
@@ -22,8 +22,6 @@
 #
 # CDDL HEADER END
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # US Type 6 (USB) key layout
 #
 key  49  base '\\' shift | caps '\\' ctrl ^\ altg nop
diff --git a/usr/src/cmd/perl/contrib/Sun/Solaris/Kstat/Kstat.xs b/usr/src/cmd/perl/contrib/Sun/Solaris/Kstat/Kstat.xs
index 99556bf1c7..58dcfe2a46 100644
--- a/usr/src/cmd/perl/contrib/Sun/Solaris/Kstat/Kstat.xs
+++ b/usr/src/cmd/perl/contrib/Sun/Solaris/Kstat/Kstat.xs
@@ -1219,6 +1219,14 @@ read_kstats(HV *self, int refresh)
 	return (1);
 }
 
+static int
+read_kstats_wrap(HV *self, void *ptr)
+{
+	int refresh = (intptr_t)ptr;
+
+	return (read_kstats(self, refresh));
+}
+
 /*
  * The XS code exported to perl is below here.  Note that the XS preprocessor
  * has its own commenting syntax, so all comments from this point on are in
@@ -1383,7 +1391,7 @@ PPCODE:
 	 * that have already been read
 	 */
 	if (ret == 0) {
-		if (! apply_to_ties(self, (ATTCb_t)read_kstats, (void *)TRUE)) {
+		if (! apply_to_ties(self, read_kstats_wrap, (void *)TRUE)) {
 			if (GIMME_V == G_ARRAY) {
 				EXTEND(SP, 2);
 				PUSHs(sv_2mortal(newRV_noinc((SV *)add)));
diff --git a/usr/src/cmd/sendmail/Makefile.cmd b/usr/src/cmd/sendmail/Makefile.cmd
index a90a1502ac..d3378329bd 100644
--- a/usr/src/cmd/sendmail/Makefile.cmd
+++ b/usr/src/cmd/sendmail/Makefile.cmd
@@ -23,6 +23,8 @@
 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# Copyright (c) 2019, Joyent, Inc.
+#
 
 CPPFLAGS.sm=	$(CPPFLAGS.master) -DSOLARIS=2$(RELEASE_MINOR)00 \
 		-D_FILE_OFFSET_BITS=64
@@ -36,6 +38,9 @@ CERRWARN +=	-_gcc=-Wno-unused-but-set-parameter
 CERRWARN +=	-_gcc=-Wno-unused-but-set-variable
 DBMDEF=		-DNDBM -DNEWDB -DNIS -DUSERDB -DMAP_REGEX -DLDAPMAP
 
+# smatch can't handle main()
+SMATCH =	off
+
 ROOTLIBSMTPSM = $(ROOTLIB)/smtp/sendmail
 
 $(ROOTLIBSMTPSM):
diff --git a/usr/src/cmd/sgs/libld/common/support.c b/usr/src/cmd/sgs/libld/common/support.c
index e449602952..cd3a8f9ba3 100644
--- a/usr/src/cmd/sgs/libld/common/support.c
+++ b/usr/src/cmd/sgs/libld/common/support.c
@@ -64,7 +64,7 @@ static Support_list support[LDS_NUM] = {
 uintptr_t
 ld_sup_loadso(Ofl_desc *ofl, const char *obj)
 {
-	void	*handle, (*fptr)();
+	void	*handle, *fptr;
 	uint_t	interface, version = LD_SUP_VERSION1;
 
 	/*
@@ -80,8 +80,7 @@ ld_sup_loadso(Ofl_desc *ofl, const char *obj)
 	for (interface = 0; interface < LDS_NUM; interface++) {
 		Func_list	fl;
 
-		if ((fptr = (void (*)())dlsym(handle,
-		    support[interface].sup_name)) == NULL)
+		if ((fptr = dlsym(handle, support[interface].sup_name)) == NULL)
 			continue;
 
 		DBG_CALL(Dbg_support_load(ofl->ofl_lml, obj,
diff --git a/usr/src/cmd/sgs/rtld/common/external.c b/usr/src/cmd/sgs/rtld/common/external.c
index c0bde0fd57..2476a6dbbc 100644
--- a/usr/src/cmd/sgs/rtld/common/external.c
+++ b/usr/src/cmd/sgs/rtld/common/external.c
@@ -202,7 +202,7 @@
  *	call during process execution.
  *
  *   -	_ld_libc() can also be called by libc during process execution to
- * 	re-establish interfaces such as the locale.
+ *	re-establish interfaces such as the locale.
  */
 static void
 get_lcinterface(Rt_map *lmp, Lc_interface *funcs)
@@ -475,14 +475,13 @@ rt_bind_clear(int flags)
 void
 rt_thr_init(Lm_list *lml)
 {
-	void	(*fptr)(void);
+	int	(*fptr)(void);
 
-	if ((fptr =
-	    (void (*)())lml->lm_lcs[CI_THRINIT].lc_un.lc_func) != NULL) {
+	if ((fptr = lml->lm_lcs[CI_THRINIT].lc_un.lc_func) != NULL) {
 		lml->lm_lcs[CI_THRINIT].lc_un.lc_func = NULL;
 
 		leave(lml, thr_flg_reenter);
-		(*fptr)();
+		(void) (*fptr)();
 		(void) enter(thr_flg_reenter);
 
 		/*
diff --git a/usr/src/cmd/sgs/rtld/common/tls.c b/usr/src/cmd/sgs/rtld/common/tls.c
index e36c03c02d..21dc63cb65 100644
--- a/usr/src/cmd/sgs/rtld/common/tls.c
+++ b/usr/src/cmd/sgs/rtld/common/tls.c
@@ -120,12 +120,12 @@ tls_modaddrem(Rt_map *lmp, uint_t flag)
 	Lm_list		*lml = LIST(lmp);
 	TLS_modinfo	tmi;
 	Phdr		*tlsphdr;
-	void		(*fptr)(TLS_modinfo *);
+	int		(*fptr)(TLS_modinfo *);
 
 	if (flag & TM_FLG_MODADD) {
-		fptr = (void (*)())lml->lm_lcs[CI_TLS_MODADD].lc_un.lc_func;
+		fptr = lml->lm_lcs[CI_TLS_MODADD].lc_un.lc_func;
 	} else if (FLAGS1(lmp) & FL1_RT_TLSADD) {
-		fptr = (void (*)())lml->lm_lcs[CI_TLS_MODREM].lc_un.lc_func;
+		fptr = lml->lm_lcs[CI_TLS_MODREM].lc_un.lc_func;
 	} else {
 		return;
 	}
@@ -147,7 +147,7 @@ tls_modaddrem(Rt_map *lmp, uint_t flag)
 	tmi.tm_stattlsoffset = 0;
 
 	DBG_CALL(Dbg_tls_modactivity(LIST(lmp), &tmi, flag));
-	(*fptr)(&tmi);
+	(void) (*fptr)(&tmi);
 
 	/*
 	 * Tag that this link-map has registered its TLS, and, if this object
@@ -258,9 +258,9 @@ tls_statmod(Lm_list *lml, Rt_map *lmp)
 	uint_t		tlsmodndx, tlsmodcnt = lml->lm_tls;
 	TLS_modinfo	**tlsmodlist, *tlsbuflist;
 	Phdr		*tlsphdr;
-	void		(*fptr)(TLS_modinfo **, ulong_t);
+	int		(*fptr)(TLS_modinfo **, ulong_t);
 
-	fptr = (void (*)())lml->lm_lcs[CI_TLS_STATMOD].lc_un.lc_func;
+	fptr = lml->lm_lcs[CI_TLS_STATMOD].lc_un.lc_func;
 
 	/*
 	 * Allocate a buffer to report the TLS modules, the buffer consists of:
@@ -285,8 +285,8 @@ tls_statmod(Lm_list *lml, Rt_map *lmp)
 	 * If we don't have any TLS modules - report that and return.
 	 */
 	if (tlsmodcnt == 0) {
-		if (fptr)
-			(*fptr)(tlsmodlist, tls_static_resv);
+		if (fptr != NULL)
+			(void) (*fptr)(tlsmodlist, tls_static_resv);
 		DBG_CALL(Dbg_tls_static_block(&lml_main, 0, 0,
 		    tls_static_resv));
 		return (1);
@@ -330,7 +330,7 @@ tls_statmod(Lm_list *lml, Rt_map *lmp)
 
 	DBG_CALL(Dbg_tls_static_block(&lml_main, (void *)tlsmodlist,
 	    tls_static_size, tls_static_resv));
-	(*fptr)(tlsmodlist, (tls_static_size + tls_static_resv));
+	(void) (*fptr)(tlsmodlist, (tls_static_size + tls_static_resv));
 
 	/*
 	 * We're done with the list - clean it up.
diff --git a/usr/src/cmd/troff/nroff.d/Makefile b/usr/src/cmd/troff/nroff.d/Makefile
index 295dcfb704..4a33471ff6 100644
--- a/usr/src/cmd/troff/nroff.d/Makefile
+++ b/usr/src/cmd/troff/nroff.d/Makefile
@@ -22,6 +22,7 @@
 #
 # Copyright (c) 1989 by Sun Microsystems, Inc.
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 include 	../../Makefile.cmd
 
@@ -45,6 +46,9 @@ CERRWARN +=	-_gcc=-Wno-implicit-function-declaration
 CERRWARN +=	-_gcc=-Wno-parentheses
 CERRWARN +=	-_gcc=-Wno-unused-variable
 
+# parse error: parsing (i (9223372034707292160-96) >= 65)
+SMATCH =	off
+
 LDLIBS +=	-lmapmalloc
 #
 # message catalog
diff --git a/usr/src/cmd/troff/troff.d/Makefile b/usr/src/cmd/troff/troff.d/Makefile
index e94bea647d..dfe5b8fee7 100644
--- a/usr/src/cmd/troff/troff.d/Makefile
+++ b/usr/src/cmd/troff/troff.d/Makefile
@@ -24,6 +24,7 @@
 #
 # cmd/troff/troff.d/Makefile
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 include 	../../Makefile.cmd
 
@@ -50,6 +51,9 @@ CERRWARN +=	-_gcc=-Wno-parentheses
 CERRWARN +=	-_gcc=-Wno-uninitialized
 CERRWARN +=	-_gcc=-Wno-extra
 
+# "parse error: parsing (i (9223372034707292160-96) >= 65)"
+SMATCH =	off
+
 #
 # For message catalog
 #
diff --git a/usr/src/common/ficl/ficlplatform/pager.c b/usr/src/common/ficl/ficlplatform/pager.c
index f297945dbb..115353d181 100644
--- a/usr/src/common/ficl/ficlplatform/pager.c
+++ b/usr/src/common/ficl/ficlplatform/pager.c
@@ -67,7 +67,7 @@ pager_open(void)
 
 	nlines = 24;		/* sensible default */
 	if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_row == 0) {
-		if ((cp = getenv("LINES")) != NULL) {
+		if ((cp = getenv("screen-#rows")) != NULL) {
 			nlines = strtol(cp, &lp, 0);
 		}
 	} else
diff --git a/usr/src/common/ficl/loader.c b/usr/src/common/ficl/loader.c
index d581015c5c..a2172d11bb 100644
--- a/usr/src/common/ficl/loader.c
+++ b/usr/src/common/ficl/loader.c
@@ -43,6 +43,7 @@
 #include <termios.h>
 #else
 #include <stand.h>
+#include <gfx_fb.h>
 #include "bootstrap.h"
 #endif
 #ifdef _STANDALONE
@@ -69,6 +70,114 @@
  *		.#	    ( value -- )
  */
 
+#ifdef _STANDALONE
+void
+ficl_fb_putimage(ficlVm *pVM)
+{
+	char *namep, *name;
+	ficlUnsigned names;
+	ficlInteger ret = FICL_FALSE;
+	png_t png;
+
+	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 1);
+
+	names = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	namep = (char *)ficlStackPopPointer(ficlVmGetDataStack(pVM));
+
+	name = ficlMalloc(names+1);
+	if (!name)
+		ficlVmThrowError(pVM, "Error: out of memory");
+	strncpy(name, namep, names);
+	name[names] = '\0';
+
+	if (png_open(&png, name) != PNG_NO_ERROR) {
+		ret = FICL_FALSE;
+		ficlFree(name);
+		ficlStackPushInteger(ficlVmGetDataStack(pVM), ret);
+		return;
+	}
+
+	if (gfx_fb_putimage(&png) == 0)
+		ret = FICL_TRUE;	/* success */
+	png_close(&png);
+	ficlFree(name);
+	ficlStackPushInteger(ficlVmGetDataStack(pVM), ret);
+}
+
+void
+ficl_fb_setpixel(ficlVm *pVM)
+{
+	ficlUnsigned x, y;
+
+	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 2, 0);
+
+	y = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	gfx_fb_setpixel(x, y);
+}
+
+void
+ficl_fb_line(ficlVm *pVM)
+{
+	ficlUnsigned x0, y0, x1, y1, wd;
+
+	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 5, 0);
+
+	wd = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	y1 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x1 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	y0 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x0 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	gfx_fb_line(x0, y0, x1, y1, wd);
+}
+
+void
+ficl_fb_bezier(ficlVm *pVM)
+{
+	ficlUnsigned x0, y0, x1, y1, x2, y2, width;
+
+	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 7, 0);
+
+	width = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	y2 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x2 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	y1 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x1 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	y0 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x0 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	gfx_fb_bezier(x0, y0, x1, y1, x2, y2, width);
+}
+
+void
+ficl_fb_drawrect(ficlVm *pVM)
+{
+	ficlUnsigned x1, x2, y1, y2, fill;
+
+	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 5, 0);
+
+	fill = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	y2 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x2 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	y1 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x1 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	gfx_fb_drawrect(x1, y1, x2, y2, fill);
+}
+
+void
+ficl_term_drawrect(ficlVm *pVM)
+{
+	ficlUnsigned x1, x2, y1, y2;
+
+	FICL_STACK_CHECK(ficlVmGetDataStack(pVM), 4, 0);
+
+	y2 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x2 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	y1 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	x1 = ficlStackPopUnsigned(ficlVmGetDataStack(pVM));
+	gfx_term_drawrect(x1, y1, x2, y2);
+}
+#endif /* _STANDALONE */
+
 void
 ficlSetenv(ficlVm *pVM)
 {
@@ -915,6 +1024,18 @@ ficlSystemCompilePlatform(ficlSystem *pSys)
 	ficlDictionarySetPrimitive(dp, "uuid-to-string", ficlUuidToString,
 	    FICL_WORD_DEFAULT);
 #ifdef _STANDALONE
+	ficlDictionarySetPrimitive(dp, "fb-setpixel", ficl_fb_setpixel,
+	    FICL_WORD_DEFAULT);
+	ficlDictionarySetPrimitive(dp, "fb-line", ficl_fb_line,
+	    FICL_WORD_DEFAULT);
+	ficlDictionarySetPrimitive(dp, "fb-bezier", ficl_fb_bezier,
+	    FICL_WORD_DEFAULT);
+	ficlDictionarySetPrimitive(dp, "fb-drawrect", ficl_fb_drawrect,
+	    FICL_WORD_DEFAULT);
+	ficlDictionarySetPrimitive(dp, "fb-putimage", ficl_fb_putimage,
+	    FICL_WORD_DEFAULT);
+	ficlDictionarySetPrimitive(dp, "term-drawrect", ficl_term_drawrect,
+	    FICL_WORD_DEFAULT);
 	/* Register words from linker set. */
 	SET_FOREACH(fnpp, Xficl_compile_set)
 		(*fnpp)(pSys);
diff --git a/usr/src/common/ficl/main.c b/usr/src/common/ficl/main.c
index 78ea2d3a00..b625c6d84c 100644
--- a/usr/src/common/ficl/main.c
+++ b/usr/src/common/ficl/main.c
@@ -102,10 +102,10 @@ main(int argc, char **argv)
 
 	clearenv();
 	asprintf(&buffer, "%d", cols);
-	setenv("COLUMNS", buffer, 1);
+	setenv("screen-#cols", buffer, 1);
 	free(buffer);
 	asprintf(&buffer, "%d", rows);
-	setenv("LINES", buffer, 1);
+	setenv("screen-#rows", buffer, 1);
 	free(buffer);
 
 	if (getenv("prompt") == NULL)
diff --git a/usr/src/common/ficl/tools.c b/usr/src/common/ficl/tools.c
index 39759b388a..2c1227ee7c 100644
--- a/usr/src/common/ficl/tools.c
+++ b/usr/src/common/ficl/tools.c
@@ -724,7 +724,7 @@ ficlPrimitiveWords(ficlVm *vm)
 	char *pPad;
 	int columns;
 
-	cp = getenv("COLUMNS");
+	cp = getenv("screen-#cols");
 	/*
 	 * using strtol for now. TODO: refactor number conversion from
 	 * ficlPrimitiveToNumber() and use it instead.
diff --git a/usr/src/common/font/font.c b/usr/src/common/font/font.c
new file mode 100644
index 0000000000..f7a1abd914
--- /dev/null
+++ b/usr/src/common/font/font.c
@@ -0,0 +1,569 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Copyright 2017 Toomas Soome <tsoome@me.com>
+ */
+
+/*
+ * Generic font related data and functions shared by early boot console
+ * in dboot, kernel startup and full kernel.
+ */
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/tem_impl.h>
+#include <sys/font.h>
+#include <sys/sysmacros.h>
+
+/*
+ * To simplify my life, I am "temporarily" collecting the commonly used
+ * color bits here. The bits shared between loader, dboot, early boot, tem.
+ * This data would need some sort of API, but I am in no condition to figure
+ * something out right now.
+ */
+
+/* ANSI color to sun color translation. */
+/* BEGIN CSTYLED */
+/*                            Bk  Rd  Gr  Br  Bl  Mg  Cy  Wh */
+const uint8_t dim_xlate[] = {  1,  5,  3,  7,  2,  6,  4,  8 };
+const uint8_t brt_xlate[] = {  9, 13, 11, 15, 10, 14, 12,  0 };
+
+/* The pc color here is actually referring to standard 16 color VGA map. */
+typedef enum pc_colors {
+	pc_black	= 0,
+	pc_blue		= 1,
+	pc_green	= 2,
+	pc_cyan		= 3,
+	pc_red		= 4,
+	pc_magenta	= 5,
+	pc_brown	= 6,
+	pc_white	= 7,
+	pc_grey		= 8,
+	pc_brt_blue	= 9,
+	pc_brt_green	= 10,
+	pc_brt_cyan	= 11,
+	pc_brt_red	= 12,
+	pc_brt_magenta	= 13,
+	pc_yellow	= 14,
+	pc_brt_white	= 15
+} pc_colors_t;
+
+const uint8_t solaris_color_to_pc_color[16] = {
+	pc_brt_white,		/*  0 - brt_white	*/
+	pc_black,		/*  1 - black		*/
+	pc_blue,		/*  2 - blue		*/
+	pc_green,		/*  3 - green		*/
+	pc_cyan,		/*  4 - cyan		*/
+	pc_red,			/*  5 - red		*/
+	pc_magenta,		/*  6 - magenta		*/
+	pc_brown,		/*  7 - brown		*/
+	pc_white,		/*  8 - white		*/
+	pc_grey,		/*  9 - gery		*/
+	pc_brt_blue,		/* 10 - brt_blue	*/
+	pc_brt_green,		/* 11 - brt_green	*/
+	pc_brt_cyan,		/* 12 - brt_cyan	*/
+	pc_brt_red,		/* 13 - brt_red		*/
+	pc_brt_magenta,		/* 14 - brt_magenta	*/
+	pc_yellow		/* 15 - yellow		*/
+};
+
+/* 4-bit to 24-bit color translation. */
+const text_cmap_t cmap4_to_24 = {
+/* 0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15
+  Wh+  Bk   Bl   Gr   Cy   Rd   Mg   Br   Wh   Bk+  Bl+  Gr+  Cy+  Rd+  Mg+  Yw */
+  .red = {
+ 0xff,0x00,0x00,0x00,0x00,0x80,0x80,0x80,0x80,0x40,0x00,0x00,0x00,0xff,0xff,0xff
+},
+  .green = {
+ 0xff,0x00,0x00,0x80,0x80,0x00,0x00,0x80,0x80,0x40,0x00,0xff,0xff,0x00,0x00,0xff
+},
+  .blue = {
+ 0xff,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x40,0xff,0x00,0xff,0x00,0xff,0x00
+}
+};
+/* END CSTYLED */
+
+/*
+ * Fonts are statically linked with this module. At some point an
+ * RFE might be desireable to allow dynamic font loading.  The
+ * original intention to facilitate dynamic fonts can be seen
+ * by examining the data structures and set_font().  As much of
+ * the original code is retained but modified to be suited for
+ * traversing a list of static fonts.
+ */
+
+/*
+ * Must be sorted by font size in descending order
+ */
+font_list_t fonts = STAILQ_HEAD_INITIALIZER(fonts);
+
+bitmap_data_t *
+set_font(short *rows, short *cols, short h, short w)
+{
+	bitmap_data_t *font = NULL;
+	struct fontlist	*fl;
+	unsigned height = h;
+	unsigned width = w;
+
+	/*
+	 * First check for manually loaded font.
+	 */
+	STAILQ_FOREACH(fl, &fonts, font_next) {
+		if (fl->font_flags == FONT_MANUAL ||
+		    fl->font_flags == FONT_BOOT) {
+			font = fl->font_data;
+			if (font->font == NULL && fl->font_load != NULL &&
+			    fl->font_name != NULL) {
+				font = fl->font_load(fl->font_name);
+			}
+			if (font == NULL || font->font == NULL)
+				font = NULL;
+			break;
+		}
+	}
+
+	if (font != NULL) {
+		*rows = (height - BORDER_PIXELS) / font->height;
+		*cols = (width - BORDER_PIXELS) / font->width;
+		return (font);
+	}
+
+	/*
+	 * Find best font for these dimensions, or use default
+	 *
+	 * A 1 pixel border is the absolute minimum we could have
+	 * as a border around the text window (BORDER_PIXELS = 2),
+	 * however a slightly larger border not only looks better
+	 * but for the fonts currently statically built into the
+	 * emulator causes much better font selection for the
+	 * normal range of screen resolutions.
+	 */
+	STAILQ_FOREACH(fl, &fonts, font_next) {
+		font = fl->font_data;
+		if ((((*rows * font->height) + BORDER_PIXELS) <= height) &&
+		    (((*cols * font->width) + BORDER_PIXELS) <= width)) {
+			if (font->font == NULL) {
+				if (fl->font_load != NULL &&
+				    fl->font_name != NULL) {
+					font = fl->font_load(fl->font_name);
+				}
+				if (font == NULL)
+					continue;
+			}
+			*rows = (height - BORDER_PIXELS) / font->height;
+			*cols = (width - BORDER_PIXELS) / font->width;
+			break;
+		}
+		font = NULL;
+	}
+
+	if (font == NULL) {
+		/*
+		 * We have fonts sorted smallest last, try it before
+		 * falling back to builtin.
+		 */
+		fl = STAILQ_LAST(&fonts, fontlist, font_next);
+		if (fl != NULL && fl->font_load != NULL &&
+		    fl->font_name != NULL) {
+			font = fl->font_load(fl->font_name);
+		}
+		if (font == NULL)
+			font = &DEFAULT_FONT_DATA;
+
+		*rows = (height - BORDER_PIXELS) / font->height;
+		*cols = (width - BORDER_PIXELS) / font->width;
+	}
+
+	return (font);
+}
+
+/* Binary search for the glyph. Return 0 if not found. */
+static uint16_t
+font_bisearch(const struct font_map *map, uint32_t len, uint32_t src)
+{
+	unsigned min, mid, max;
+
+	min = 0;
+	max = len - 1;
+
+	/* Empty font map. */
+	if (len == 0)
+		return (0);
+	/* Character below minimal entry. */
+	if (src < map[0].font_src)
+		return (0);
+	/* Optimization: ASCII characters occur very often. */
+	if (src <= map[0].font_src + map[0].font_len)
+		return (src - map[0].font_src + map[0].font_dst);
+	/* Character above maximum entry. */
+	if (src > map[max].font_src + map[max].font_len)
+		return (0);
+
+	/* Binary search. */
+	while (max >= min) {
+		mid = (min + max) / 2;
+		if (src < map[mid].font_src)
+			max = mid - 1;
+		else if (src > map[mid].font_src + map[mid].font_len)
+			min = mid + 1;
+		else
+			return (src - map[mid].font_src + map[mid].font_dst);
+	}
+
+	return (0);
+}
+
+/*
+ * Return glyph bitmap. If glyph is not found, we will return bitmap
+ * for the first (offset 0) glyph.
+ */
+const uint8_t *
+font_lookup(const struct font *vf, uint32_t c)
+{
+	uint32_t src;
+	uint16_t dst;
+	size_t stride;
+
+	src = TEM_CHAR(c);
+
+	/* Substitute bold with normal if not found. */
+	if (TEM_CHAR_ATTR(c) & TEM_ATTR_BOLD) {
+		dst = font_bisearch(vf->vf_map[VFNT_MAP_BOLD],
+		    vf->vf_map_count[VFNT_MAP_BOLD], src);
+		if (dst != 0)
+			goto found;
+	}
+	dst = font_bisearch(vf->vf_map[VFNT_MAP_NORMAL],
+	    vf->vf_map_count[VFNT_MAP_NORMAL], src);
+
+found:
+	stride = howmany(vf->vf_width, 8) * vf->vf_height;
+	return (&vf->vf_bytes[dst * stride]);
+}
+
+/*
+ * bit_to_pix4 is for 4-bit frame buffers.  It will write one output byte
+ * for each 2 bits of input bitmap.  It inverts the input bits before
+ * doing the output translation, for reverse video.
+ *
+ * Assuming foreground is 0001 and background is 0000...
+ * An input data byte of 0x53 will output the bit pattern
+ * 00000001 00000001 00000000 00010001.
+ */
+
+void
+font_bit_to_pix4(
+    struct font *f,
+    uint8_t *dest,
+    uint32_t c,
+    uint8_t fg_color,
+    uint8_t bg_color)
+{
+	uint32_t row;
+	int	byte;
+	int	i;
+	const uint8_t *cp, *ul;
+	uint8_t	data;
+	uint8_t	nibblett;
+	int	bytes_wide;
+
+	if (TEM_CHAR_ATTR(c) & TEM_ATTR_UNDERLINE)
+		ul = font_lookup(f, 0x0332);	/* combining low line */
+	else
+		ul = NULL;
+
+	cp = font_lookup(f, c);
+	bytes_wide = (f->vf_width + 7) / 8;
+
+	for (row = 0; row < f->vf_height; row++) {
+		for (byte = 0; byte < bytes_wide; byte++) {
+			if (ul == NULL)
+				data = *cp++;
+			else
+				data = *cp++ | *ul++;
+			for (i = 0; i < 4; i++) {
+				nibblett = (data >> ((3-i) * 2)) & 0x3;
+				switch (nibblett) {
+				case 0x0:
+					*dest++ = bg_color << 4 | bg_color;
+					break;
+				case 0x1:
+					*dest++ = bg_color << 4 | fg_color;
+					break;
+				case 0x2:
+					*dest++ = fg_color << 4 | bg_color;
+					break;
+				case 0x3:
+					*dest++ = fg_color << 4 | fg_color;
+					break;
+				}
+			}
+		}
+	}
+}
+
+/*
+ * bit_to_pix8 is for 8-bit frame buffers.  It will write one output byte
+ * for each bit of input bitmap.  It inverts the input bits before
+ * doing the output translation, for reverse video.
+ *
+ * Assuming foreground is 00000001 and background is 00000000...
+ * An input data byte of 0x53 will output the bit pattern
+ * 0000000 000000001 00000000 00000001 00000000 00000000 00000001 00000001.
+ */
+
+void
+font_bit_to_pix8(
+    struct font *f,
+    uint8_t *dest,
+    uint32_t c,
+    uint8_t fg_color,
+    uint8_t bg_color)
+{
+	uint32_t row;
+	int	byte;
+	int	i;
+	const uint8_t *cp, *ul;
+	uint8_t	data;
+	int	bytes_wide;
+	uint8_t	mask;
+	int	bitsleft, nbits;
+
+	if (TEM_CHAR_ATTR(c) & TEM_ATTR_UNDERLINE)
+		ul = font_lookup(f, 0x0332);	/* combining low line */
+	else
+		ul = NULL;
+
+	cp = font_lookup(f, c);
+	bytes_wide = (f->vf_width + 7) / 8;
+
+	for (row = 0; row < f->vf_height; row++) {
+		bitsleft = f->vf_width;
+		for (byte = 0; byte < bytes_wide; byte++) {
+			if (ul == NULL)
+				data = *cp++;
+			else
+				data = *cp++ | *ul++;
+			mask = 0x80;
+			nbits = MIN(8, bitsleft);
+			bitsleft -= nbits;
+			for (i = 0; i < nbits; i++) {
+				*dest++ = (data & mask ? fg_color: bg_color);
+				mask = mask >> 1;
+			}
+		}
+	}
+}
+
+/*
+ * bit_to_pix16 is for 16-bit frame buffers.  It will write two output bytes
+ * for each bit of input bitmap.  It inverts the input bits before
+ * doing the output translation, for reverse video.
+ *
+ * Assuming foreground is 11111111 11111111
+ * and background is 00000000 00000000
+ * An input data byte of 0x53 will output the bit pattern
+ *
+ * 00000000 00000000
+ * 11111111 11111111
+ * 00000000 00000000
+ * 11111111 11111111
+ * 00000000 00000000
+ * 00000000 00000000
+ * 11111111 11111111
+ * 11111111 11111111
+ *
+ */
+
+void
+font_bit_to_pix16(
+    struct font *f,
+    uint16_t *dest,
+    uint32_t c,
+    uint16_t fg_color16,
+    uint16_t bg_color16)
+{
+	uint32_t row;
+	int	byte;
+	int	i;
+	const uint8_t *cp, *ul;
+	uint16_t data, d;
+	int	bytes_wide;
+	int	bitsleft, nbits;
+
+	if (TEM_CHAR_ATTR(c) & TEM_ATTR_UNDERLINE)
+		ul = font_lookup(f, 0x0332);	/* combining low line */
+	else
+		ul = NULL;
+
+	cp = font_lookup(f, c);
+	bytes_wide = (f->vf_width + 7) / 8;
+
+	for (row = 0; row < f->vf_height; row++) {
+		bitsleft = f->vf_width;
+		for (byte = 0; byte < bytes_wide; byte++) {
+			if (ul == NULL)
+				data = *cp++;
+			else
+				data = *cp++ | *ul++;
+			nbits = MIN(8, bitsleft);
+			bitsleft -= nbits;
+			for (i = 0; i < nbits; i++) {
+				d = ((data << i) & 0x80 ?
+				    fg_color16 : bg_color16);
+				*dest++ = d;
+			}
+		}
+	}
+}
+
+/*
+ * bit_to_pix24 is for 24-bit frame buffers.  It will write three output bytes
+ * for each bit of input bitmap.  It inverts the input bits before
+ * doing the output translation, for reverse video.
+ *
+ * Assuming foreground is 11111111 11111111 11111111
+ * and background is 00000000 00000000 00000000
+ * An input data byte of 0x53 will output the bit pattern
+ *
+ * 00000000 00000000 00000000
+ * 11111111 11111111 11111111
+ * 00000000 00000000 00000000
+ * 11111111 11111111 11111111
+ * 00000000 00000000 00000000
+ * 00000000 00000000 00000000
+ * 11111111 11111111 11111111
+ * 11111111 11111111 11111111
+ *
+ */
+
+void
+font_bit_to_pix24(
+    struct font *f,
+    uint8_t *dest,
+    uint32_t c,
+    uint32_t fg_color32,
+    uint32_t bg_color32)
+{
+	uint32_t row;
+	int	byte;
+	int	i;
+	const uint8_t *cp, *ul;
+	uint32_t data, d;
+	int	bytes_wide;
+	int	bitsleft, nbits;
+
+	if (TEM_CHAR_ATTR(c) & TEM_ATTR_UNDERLINE)
+		ul = font_lookup(f, 0x0332);	/* combining low line */
+	else
+		ul = NULL;
+
+	cp = font_lookup(f, c);
+	bytes_wide = (f->vf_width + 7) / 8;
+
+	for (row = 0; row < f->vf_height; row++) {
+		bitsleft = f->vf_width;
+		for (byte = 0; byte < bytes_wide; byte++) {
+			if (ul == NULL)
+				data = *cp++;
+			else
+				data = *cp++ | *ul++;
+
+			nbits = MIN(8, bitsleft);
+			bitsleft -= nbits;
+			for (i = 0; i < nbits; i++) {
+				d = ((data << i) & 0x80 ?
+				    fg_color32 : bg_color32);
+				*dest++ = d & 0xff;
+				*dest++ = (d >> 8) & 0xff;
+				*dest++ = (d >> 16) & 0xff;
+			}
+		}
+	}
+}
+
+/*
+ * bit_to_pix32 is for 32-bit frame buffers.  It will write four output bytes
+ * for each bit of input bitmap.  It inverts the input bits before
+ * doing the output translation, for reverse video.  Note that each
+ * 24-bit RGB value is finally stored in a 32-bit unsigned int, with the
+ * high-order byte set to zero.
+ *
+ * Assuming foreground is 00000000 11111111 11111111 11111111
+ * and background is 00000000 00000000 00000000 00000000
+ * An input data byte of 0x53 will output the bit pattern
+ *
+ * 00000000 00000000 00000000 00000000
+ * 00000000 11111111 11111111 11111111
+ * 00000000 00000000 00000000 00000000
+ * 00000000 11111111 11111111 11111111
+ * 00000000 00000000 00000000 00000000
+ * 00000000 00000000 00000000 00000000
+ * 00000000 11111111 11111111 11111111
+ * 00000000 11111111 11111111 11111111
+ *
+ */
+
+void
+font_bit_to_pix32(
+    struct font *f,
+    uint32_t *dest,
+    uint32_t c,
+    uint32_t fg_color32,
+    uint32_t bg_color32)
+{
+	uint32_t row;
+	int	byte;
+	int	i;
+	const uint8_t *cp, *ul;
+	uint32_t data;
+	int	bytes_wide;
+	int	bitsleft, nbits;
+
+	if (TEM_CHAR_ATTR(c) & TEM_ATTR_UNDERLINE)
+		ul = font_lookup(f, 0x0332);	/* combining low line */
+	else
+		ul = NULL;
+
+	cp = font_lookup(f, c);
+	bytes_wide = (f->vf_width + 7) / 8;
+
+	for (row = 0; row < f->vf_height; row++) {
+		bitsleft = f->vf_width;
+		for (byte = 0; byte < bytes_wide; byte++) {
+			if (ul == NULL)
+				data = *cp++;
+			else
+				data = *cp++ | *ul++;
+			nbits = MIN(8, bitsleft);
+			bitsleft -= nbits;
+			for (i = 0; i < nbits; i++) {
+				*dest++ = ((data << i) & 0x80 ?
+				    fg_color32 : bg_color32);
+			}
+		}
+	}
+}
diff --git a/usr/src/common/pnglite/THIRDPARTYLICENSE b/usr/src/common/pnglite/THIRDPARTYLICENSE
new file mode 100644
index 0000000000..7f9379bbf9
--- /dev/null
+++ b/usr/src/common/pnglite/THIRDPARTYLICENSE
@@ -0,0 +1,26 @@
+/*
+ *  pnglite.h - Interface for pnglite library
+ *	Copyright (c) 2007 Daniel Karling
+ *
+ *	This software is provided 'as-is', without any express or implied
+ *	warranty. In no event will the authors be held liable for any damages
+ *	arising from the use of this software.
+ *
+ *	Permission is granted to anyone to use this software for any purpose,
+ *	including commercial applications, and to alter it and redistribute it
+ *	freely, subject to the following restrictions:
+ *
+ *	1. The origin of this software must not be misrepresented; you must not
+ *	   claim that you wrote the original software. If you use this software
+ *	   in a product, an acknowledgment in the product documentation would be
+ *	   appreciated but is not required.
+ *
+ *	2. Altered source versions must be plainly marked as such, and must not
+ *	   be misrepresented as being the original software.
+ *
+ *	3. This notice may not be removed or altered from any source
+ *	   distribution.
+ *
+ *	Daniel Karling
+ *	daniel.karling@gmail.com
+ */
diff --git a/usr/src/common/pnglite/THIRDPARTYLICENSE.descrip b/usr/src/common/pnglite/THIRDPARTYLICENSE.descrip
new file mode 100644
index 0000000000..64d37cdaba
--- /dev/null
+++ b/usr/src/common/pnglite/THIRDPARTYLICENSE.descrip
@@ -0,0 +1 @@
+pnglite
diff --git a/usr/src/common/pnglite/pnglite.c b/usr/src/common/pnglite/pnglite.c
new file mode 100644
index 0000000000..59b9df1db6
--- /dev/null
+++ b/usr/src/common/pnglite/pnglite.c
@@ -0,0 +1,620 @@
+/*
+ * pnglite.c - pnglite library
+ * For conditions of distribution and use, see copyright notice in pnglite.h
+ */
+
+#ifdef _STANDALONE
+#include <sys/cdefs.h>
+#include <stand.h>
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#endif
+#include <zlib.h>
+#include "pnglite.h"
+
+#ifndef abs
+#define	abs(x)	((x) < 0? -(x):(x))
+#endif
+
+#define	PNG_32b(b, s) ((uint32_t)(b) << (s))
+#define	PNG_U32(b1, b2, b3, b4) \
+	(PNG_32b(b1, 24) | PNG_32b(b2, 16) | PNG_32b(b3, 8) | PNG_32b(b4, 0))
+
+#define	png_IDAT PNG_U32(73,  68,  65,  84)
+#define	png_IEND PNG_U32(73,  69,  78,  68)
+
+static ssize_t
+file_read(png_t *png, void *out, size_t size, size_t numel)
+{
+	ssize_t result;
+	off_t offset = (off_t)(size * numel);
+
+	if (offset < 0)
+		return (PNG_FILE_ERROR);
+
+	if (!out) {
+		result = lseek(png->fd, offset, SEEK_CUR);
+	} else {
+		result = read(png->fd, out, size * numel);
+	}
+
+	return (result);
+}
+
+static int
+file_read_ul(png_t *png, unsigned *out)
+{
+	uint8_t buf[4];
+
+	if (file_read(png, buf, 1, 4) != 4)
+		return (PNG_FILE_ERROR);
+
+	*out = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
+
+	return (PNG_NO_ERROR);
+}
+
+static unsigned
+get_ul(uint8_t *buf)
+{
+	unsigned result;
+	uint8_t foo[4];
+
+	memcpy(foo, buf, 4);
+
+	result = (foo[0]<<24) | (foo[1]<<16) | (foo[2]<<8) | foo[3];
+
+	return (result);
+}
+
+static int
+png_get_bpp(png_t *png)
+{
+	int bpp;
+
+	switch (png->color_type) {
+	case PNG_GREYSCALE:
+		bpp = 1; break;
+	case PNG_TRUECOLOR:
+		bpp = 3; break;
+	case PNG_INDEXED:
+		bpp = 1; break;
+	case PNG_GREYSCALE_ALPHA:
+		bpp = 2; break;
+	case PNG_TRUECOLOR_ALPHA:
+		bpp = 4; break;
+	default:
+		return (PNG_FILE_ERROR);
+	}
+
+	bpp *= png->depth / 8;
+
+	return (bpp);
+}
+
+static int
+png_read_ihdr(png_t *png)
+{
+	unsigned length;
+	unsigned orig_crc;
+	unsigned calc_crc;
+	uint8_t ihdr[13+4]; /* length should be 13, make room for type (IHDR) */
+
+	file_read_ul(png, &length);
+
+	if (length != 13)
+		return (PNG_CRC_ERROR);
+
+	if (file_read(png, ihdr, 1, 13+4) != 13+4)
+		return (PNG_EOF_ERROR);
+
+	file_read_ul(png, &orig_crc);
+
+	calc_crc = crc32(0L, Z_NULL, 0);
+	calc_crc = crc32(calc_crc, ihdr, 13+4);
+
+	if (orig_crc != calc_crc) {
+		return (PNG_CRC_ERROR);
+	}
+
+	png->width = get_ul(ihdr+4);
+	png->height = get_ul(ihdr+8);
+	png->depth = ihdr[12];
+	png->color_type = ihdr[13];
+	png->compression_method = ihdr[14];
+	png->filter_method = ihdr[15];
+	png->interlace_method = ihdr[16];
+
+	if (png->color_type == PNG_INDEXED)
+		return (PNG_NOT_SUPPORTED);
+
+	if (png->depth != 8 && png->depth != 16)
+		return (PNG_NOT_SUPPORTED);
+
+	if (png->interlace_method)
+		return (PNG_NOT_SUPPORTED);
+
+	return (PNG_NO_ERROR);
+}
+
+void
+png_print_info(png_t *png)
+{
+	printf("PNG INFO:\n");
+	printf("\twidth:\t\t%d\n", png->width);
+	printf("\theight:\t\t%d\n", png->height);
+	printf("\tdepth:\t\t%d\n", png->depth);
+	printf("\tcolor:\t\t");
+
+	switch (png->color_type) {
+	case PNG_GREYSCALE:
+		printf("greyscale\n"); break;
+	case PNG_TRUECOLOR:
+		printf("truecolor\n"); break;
+	case PNG_INDEXED:
+		printf("palette\n"); break;
+	case PNG_GREYSCALE_ALPHA:
+		printf("greyscale with alpha\n"); break;
+	case PNG_TRUECOLOR_ALPHA:
+		printf("truecolor with alpha\n"); break;
+	default:
+		printf("unknown, this is not good\n"); break;
+	}
+
+	printf("\tcompression:\t%s\n",
+	    png->compression_method?
+	    "unknown, this is not good":"inflate/deflate");
+	printf("\tfilter:\t\t%s\n",
+	    png->filter_method? "unknown, this is not good":"adaptive");
+	printf("\tinterlace:\t%s\n",
+	    png->interlace_method? "interlace":"no interlace");
+}
+
+int
+png_open(png_t *png, const char *filename)
+{
+	char header[8];
+	int result;
+
+	png->image = NULL;
+	png->fd = open(filename, O_RDONLY);
+	if (png->fd == -1)
+		return (PNG_FILE_ERROR);
+
+	if (file_read(png, header, 1, 8) != 8) {
+		result = PNG_EOF_ERROR;
+		goto done;
+	}
+
+	if (memcmp(header, "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A", 8) != 0) {
+		result = PNG_HEADER_ERROR;
+		goto done;
+	}
+
+	result = png_read_ihdr(png);
+	if (result == PNG_NO_ERROR) {
+		result = png_get_bpp(png);
+		if (result > 0) {
+			png->bpp = (uint8_t)result;
+			result = PNG_NO_ERROR;
+		}
+	}
+
+done:
+	if (result == PNG_NO_ERROR) {
+		uint64_t size = png->width * png->height * png->bpp;
+
+		if (size < UINT_MAX)
+			png->image = malloc(size);
+		if (png->image == NULL)
+			result = PNG_MEMORY_ERROR;
+	}
+
+	if (result == PNG_NO_ERROR)
+		result = png_get_data(png, png->image);
+
+	if (result != PNG_NO_ERROR) {
+		free(png->image);
+		close(png->fd);
+		png->fd = -1;
+		return (result);
+	}
+
+	return (result);
+}
+
+int
+png_close(png_t *png)
+{
+	close(png->fd);
+	png->fd = -1;
+	free(png->image);
+	png->image = NULL;
+
+	return (PNG_NO_ERROR);
+}
+
+static int
+png_init_inflate(png_t *png)
+{
+	z_stream *stream;
+	png->zs = calloc(1, sizeof (z_stream));
+
+	stream = png->zs;
+
+	if (!stream)
+		return (PNG_MEMORY_ERROR);
+
+	if (inflateInit(stream) != Z_OK) {
+		free(png->zs);
+		png->zs = NULL;
+		return (PNG_ZLIB_ERROR);
+	}
+
+	stream->next_out = png->png_data;
+	stream->avail_out = png->png_datalen;
+
+	return (PNG_NO_ERROR);
+}
+
+static int
+png_end_inflate(png_t *png)
+{
+	z_stream *stream = png->zs;
+	int rc = PNG_NO_ERROR;
+
+	if (!stream)
+		return (PNG_MEMORY_ERROR);
+
+	if (inflateEnd(stream) != Z_OK) {
+		printf("ZLIB says: %s\n", stream->msg);
+		rc = PNG_ZLIB_ERROR;
+	}
+
+	free(png->zs);
+	png->zs = NULL;
+
+	return (rc);
+}
+
+static int
+png_inflate(png_t *png, uint8_t *data, int len)
+{
+	int result;
+	z_stream *stream = png->zs;
+
+	if (!stream)
+		return (PNG_MEMORY_ERROR);
+
+	stream->next_in = data;
+	stream->avail_in = len;
+
+	result = inflate(stream, Z_SYNC_FLUSH);
+
+	if (result != Z_STREAM_END && result != Z_OK) {
+		printf("%s\n", stream->msg);
+		return (PNG_ZLIB_ERROR);
+	}
+
+	if (stream->avail_in != 0)
+		return (PNG_ZLIB_ERROR);
+
+	return (PNG_NO_ERROR);
+}
+
+static int
+png_read_idat(png_t *png, unsigned length)
+{
+	unsigned orig_crc;
+	unsigned calc_crc;
+	ssize_t len = length;
+
+	if (!png->readbuf || png->readbuflen < length) {
+		png->readbuf = realloc(png->readbuf, length);
+		png->readbuflen = length;
+	}
+
+	if (!png->readbuf)
+		return (PNG_MEMORY_ERROR);
+
+	if (file_read(png, png->readbuf, 1, length) != len)
+		return (PNG_FILE_ERROR);
+
+	calc_crc = crc32(0L, Z_NULL, 0);
+	calc_crc = crc32(calc_crc, (uint8_t *)"IDAT", 4);
+	calc_crc = crc32(calc_crc, (uint8_t *)png->readbuf, length);
+
+	file_read_ul(png, &orig_crc);
+
+	if (orig_crc != calc_crc)
+		return (PNG_CRC_ERROR);
+
+	return (png_inflate(png, png->readbuf, length));
+}
+
+static int
+png_process_chunk(png_t *png)
+{
+	int result = PNG_NO_ERROR;
+	unsigned type;
+	unsigned length;
+
+	file_read_ul(png, &length);
+
+	if (file_read_ul(png, &type))
+		return (PNG_FILE_ERROR);
+
+	/*
+	 * if we found an idat, all other idats should be followed with no
+	 * other chunks in between
+	 */
+	if (type == png_IDAT) {
+		if (!png->png_data) {	/* first IDAT */
+			png->png_datalen = png->width * png->height *
+			    png->bpp + png->height;
+			png->png_data = malloc(png->png_datalen);
+		}
+
+		if (!png->png_data)
+			return (PNG_MEMORY_ERROR);
+
+		if (!png->zs) {
+			result = png_init_inflate(png);
+			if (result != PNG_NO_ERROR)
+				return (result);
+		}
+
+		return (png_read_idat(png, length));
+	} else if (type == png_IEND)
+		return (PNG_DONE);
+	else
+		file_read(png, 0, 1, length + 4); /* unknown chunk */
+
+	return (result);
+}
+
+static void
+png_filter_sub(unsigned stride, uint8_t *in, uint8_t *out, unsigned len)
+{
+	unsigned i;
+	uint8_t a = 0;
+
+	for (i = 0; i < len; i++) {
+		if (i >= stride)
+			a = out[i - stride];
+
+		out[i] = in[i] + a;
+	}
+}
+
+static void
+png_filter_up(unsigned stride __unused, uint8_t *in, uint8_t *out,
+    uint8_t *prev_line, unsigned len)
+{
+	unsigned i;
+
+	if (prev_line) {
+		for (i = 0; i < len; i++)
+			out[i] = in[i] + prev_line[i];
+	} else
+		memcpy(out, in, len);
+}
+
+static void
+png_filter_average(unsigned stride, uint8_t *in, uint8_t *out,
+    uint8_t *prev_line, unsigned len)
+{
+	unsigned int i;
+	uint8_t a = 0;
+	uint8_t b = 0;
+	unsigned int sum = 0;
+
+	for (i = 0; i < len; i++) {
+		if (prev_line)
+			b = prev_line[i];
+
+		if (i >= stride)
+			a = out[i - stride];
+
+		sum = a;
+		sum += b;
+
+		out[i] = in[i] + sum/2;
+	}
+}
+
+static uint8_t
+png_paeth(uint8_t a, uint8_t b, uint8_t c)
+{
+	int p = (int)a + b - c;
+	int pa = abs(p - a);
+	int pb = abs(p - b);
+	int pc = abs(p - c);
+
+	int pr;
+
+	if (pa <= pb && pa <= pc)
+		pr = a;
+	else if (pb <= pc)
+		pr = b;
+	else
+		pr = c;
+
+	return (pr);
+}
+
+static void
+png_filter_paeth(unsigned stride, uint8_t *in, uint8_t *out, uint8_t *prev_line,
+    unsigned len)
+{
+	unsigned i;
+	uint8_t a;
+	uint8_t b;
+	uint8_t c;
+
+	for (i = 0; i < len; i++) {
+		if (prev_line && i >= stride) {
+			a = out[i - stride];
+			b = prev_line[i];
+			c = prev_line[i - stride];
+		} else {
+			if (prev_line)
+				b = prev_line[i];
+			else
+				b = 0;
+
+			if (i >= stride)
+				a = out[i - stride];
+			else
+				a = 0;
+
+			c = 0;
+		}
+
+		out[i] = in[i] + png_paeth(a, b, c);
+	}
+}
+
+static int
+png_unfilter(png_t *png, uint8_t *data)
+{
+	unsigned i;
+	unsigned pos = 0;
+	unsigned outpos = 0;
+	uint8_t *filtered = png->png_data;
+	unsigned stride = png->bpp;
+
+	while (pos < png->png_datalen) {
+		uint8_t filter = filtered[pos];
+
+		pos++;
+
+		if (png->depth == 16) {
+			for (i = 0; i < png->width * stride; i += 2) {
+				*(short *)(filtered+pos+i) =
+				    (filtered[pos+i] << 8) | filtered[pos+i+1];
+			}
+		}
+
+		switch (filter) {
+		case 0: /* none */
+			memcpy(data+outpos, filtered+pos, png->width * stride);
+			break;
+		case 1: /* sub */
+			png_filter_sub(stride, filtered+pos, data+outpos,
+			    png->width * stride);
+			break;
+		case 2: /* up */
+			if (outpos) {
+				png_filter_up(stride, filtered+pos, data+outpos,
+				    data + outpos - (png->width*stride),
+				    png->width*stride);
+			} else {
+				png_filter_up(stride, filtered+pos, data+outpos,
+				    0, png->width*stride);
+			}
+			break;
+		case 3: /* average */
+			if (outpos) {
+				png_filter_average(stride, filtered+pos,
+				    data+outpos,
+				    data + outpos - (png->width*stride),
+				    png->width*stride);
+			} else {
+				png_filter_average(stride, filtered+pos,
+				    data+outpos, 0, png->width*stride);
+			}
+			break;
+		case 4: /* paeth */
+			if (outpos) {
+				png_filter_paeth(stride, filtered+pos,
+				    data+outpos,
+				    data + outpos - (png->width*stride),
+				    png->width*stride);
+			} else {
+				png_filter_paeth(stride, filtered+pos,
+				    data+outpos, 0, png->width*stride);
+			}
+			break;
+		default:
+			return (PNG_UNKNOWN_FILTER);
+		}
+
+		outpos += png->width * stride;
+		pos += png->width * stride;
+	}
+
+	return (PNG_NO_ERROR);
+}
+
+int
+png_get_data(png_t *png, uint8_t *data)
+{
+	int result = PNG_NO_ERROR;
+
+	png->zs = NULL;
+	png->png_datalen = 0;
+	png->png_data = NULL;
+	png->readbuf = NULL;
+	png->readbuflen = 0;
+
+	while (result == PNG_NO_ERROR)
+		result = png_process_chunk(png);
+
+	if (png->readbuf) {
+		free(png->readbuf);
+		png->readbuflen = 0;
+	}
+	if (png->zs)
+		png_end_inflate(png);
+
+	if (result != PNG_DONE) {
+		free(png->png_data);
+		return (result);
+	}
+
+	result = png_unfilter(png, data);
+
+	free(png->png_data);
+
+	return (result);
+}
+
+char *
+png_error_string(int error)
+{
+	switch (error) {
+	case PNG_NO_ERROR:
+		return ("No error");
+	case PNG_FILE_ERROR:
+		return ("Unknown file error.");
+	case PNG_HEADER_ERROR:
+		return ("No PNG header found. Are you sure this is a PNG?");
+	case PNG_IO_ERROR:
+		return ("Failure while reading file.");
+	case PNG_EOF_ERROR:
+		return ("Reached end of file.");
+	case PNG_CRC_ERROR:
+		return ("CRC or chunk length error.");
+	case PNG_MEMORY_ERROR:
+		return ("Could not allocate memory.");
+	case PNG_ZLIB_ERROR:
+		return ("zlib reported an error.");
+	case PNG_UNKNOWN_FILTER:
+		return ("Unknown filter method used in scanline.");
+	case PNG_DONE:
+		return ("PNG done");
+	case PNG_NOT_SUPPORTED:
+		return ("The PNG is unsupported by pnglite, too bad for you!");
+	case PNG_WRONG_ARGUMENTS:
+		return ("Wrong combination of arguments passed to png_open. "
+		    "You must use either a read_function or supply a file "
+		    "pointer to use.");
+	default:
+		return ("Unknown error.");
+	};
+}
diff --git a/usr/src/common/pnglite/pnglite.h b/usr/src/common/pnglite/pnglite.h
new file mode 100644
index 0000000000..3c3a3320c2
--- /dev/null
+++ b/usr/src/common/pnglite/pnglite.h
@@ -0,0 +1,169 @@
+/*
+ *  pnglite.h - Interface for pnglite library
+ *	Copyright (c) 2007 Daniel Karling
+ *
+ *	This software is provided 'as-is', without any express or implied
+ *	warranty. In no event will the authors be held liable for any damages
+ *	arising from the use of this software.
+ *
+ *	Permission is granted to anyone to use this software for any purpose,
+ *	including commercial applications, and to alter it and redistribute it
+ *	freely, subject to the following restrictions:
+ *
+ *	1. The origin of this software must not be misrepresented; you must not
+ *	   claim that you wrote the original software. If you use this software
+ *	   in a product, an acknowledgment in the product documentation would be
+ *	   appreciated but is not required.
+ *
+ *	2. Altered source versions must be plainly marked as such, and must not
+ *	   be misrepresented as being the original software.
+ *
+ *	3. This notice may not be removed or altered from any source
+ *	   distribution.
+ *
+ *	Daniel Karling
+ *	daniel.karling@gmail.com
+ */
+
+
+#ifndef _PNGLITE_H_
+#define	_PNGLITE_H_
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ *	Enumerations for pnglite.
+ *	Negative numbers are error codes and 0 and up are okay responses.
+ */
+
+enum {
+	PNG_DONE			= 1,
+	PNG_NO_ERROR			= 0,
+	PNG_FILE_ERROR			= -1,
+	PNG_HEADER_ERROR		= -2,
+	PNG_IO_ERROR			= -3,
+	PNG_EOF_ERROR			= -4,
+	PNG_CRC_ERROR			= -5,
+	PNG_MEMORY_ERROR		= -6,
+	PNG_ZLIB_ERROR			= -7,
+	PNG_UNKNOWN_FILTER		= -8,
+	PNG_NOT_SUPPORTED		= -9,
+	PNG_WRONG_ARGUMENTS		= -10
+};
+
+/*
+ *	The five different kinds of color storage in PNG files.
+ */
+
+enum {
+	PNG_GREYSCALE			= 0,
+	PNG_TRUECOLOR			= 2,
+	PNG_INDEXED			= 3,
+	PNG_GREYSCALE_ALPHA		= 4,
+	PNG_TRUECOLOR_ALPHA		= 6
+};
+
+typedef struct {
+	void			*zs;		/* pointer to z_stream */
+	int			fd;
+	unsigned char		*image;
+
+	unsigned char		*png_data;
+	unsigned		png_datalen;
+
+	unsigned		width;
+	unsigned		height;
+	unsigned char		depth;
+	unsigned char		color_type;
+	unsigned char		compression_method;
+	unsigned char		filter_method;
+	unsigned char		interlace_method;
+	unsigned char		bpp;
+
+	unsigned char		*readbuf;
+	unsigned		readbuflen;
+} png_t;
+
+
+/*
+ *	Function: png_open
+ *
+ *	This function is used to open a png file with the internal file
+ *	IO system.
+ *
+ *	Parameters:
+ *		png - Empty png_t struct.
+ *		filename - Filename of the file to be opened.
+ *
+ *	Returns:
+ *		PNG_NO_ERROR on success, otherwise an error code.
+ */
+
+int png_open(png_t *png, const char *filename);
+
+/*
+ *	Function: png_print_info
+ *
+ *	This function prints some info about the opened png file to stdout.
+ *
+ *	Parameters:
+ *		png - png struct to get info from.
+ */
+
+void png_print_info(png_t *png);
+
+/*
+ *	Function: png_error_string
+ *
+ *	This function translates an error code to a human readable string.
+ *
+ *	Parameters:
+ *		error - Error code.
+ *
+ *	Returns:
+ *		Pointer to string.
+ */
+
+char *png_error_string(int error);
+
+/*
+ *	Function: png_get_data
+ *
+ *	This function decodes the opened png file and stores the result in data.
+ *	data should be big enough to hold the decoded png.
+ *	Required size will be:
+ *
+ *	> width*height*(bytes per pixel)
+ *
+ *	Parameters:
+ *		data - Where to store result.
+ *
+ *	Returns:
+ *		PNG_NO_ERROR on success, otherwise an error code.
+ */
+
+int png_get_data(png_t *png, uint8_t *data);
+
+/*
+ *	Function: png_close
+ *
+ *	Closes an open png file pointer.
+ *
+ *	Parameters:
+ *		png - png to close.
+ *
+ *	Returns:
+ *		PNG_NO_ERROR
+ */
+
+int png_close(png_t *png);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _PNGLITE_H_ */
diff --git a/usr/src/uts/common/io/vgasubr.c b/usr/src/common/vga/vgasubr.c
index 5fc151232a..ccd5e56ddc 100644
--- a/usr/src/uts/common/io/vgasubr.c
+++ b/usr/src/common/vga/vgasubr.c
@@ -22,14 +22,14 @@
 /*
  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
+ * Copyright 2018 Toomas Soome <tsoome@me.com>
  */
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 /*
  * Support routines for VGA drivers
  */
 
+#if defined(_KERNEL)
 #include <sys/debug.h>
 #include <sys/types.h>
 #include <sys/param.h>
@@ -39,8 +39,6 @@
 #include <sys/systm.h>
 #include <sys/conf.h>
 
-#include <sys/vgareg.h>
-#include <sys/vgasubr.h>
 #include <sys/cmn_err.h>
 
 #include <sys/kmem.h>
@@ -51,6 +49,21 @@
 
 #include <sys/modctl.h>
 
+#define	PUTB(reg, off, v)	ddi_put8(reg->handle, reg->addr + (off), v)
+#define	GETB(reg, off)		ddi_get8(reg->handle, reg->addr + (off))
+
+#elif defined(_STANDALONE)
+
+#include <stand.h>
+#include <machine/cpufunc.h>
+
+#define	PUTB(reg, off, v)	outb(reg + (off), v)
+#define	GETB(reg, off)		inb(reg + (off))
+#endif
+
+#include <sys/vgareg.h>
+#include <sys/vgasubr.h>
+
 #define	GET_HORIZ_END(c)	vga_get_crtc(c, VGA_CRTC_H_D_END)
 #define	GET_VERT_END(c)	(vga_get_crtc(c, VGA_CRTC_VDE) \
 	+ (((vga_get_crtc(c, VGA_CRTC_OVFL_REG) >> \
@@ -76,66 +89,63 @@ unsigned char VGA_ATR_TEXT[NUM_ATR_REG] = {
 	0x0c, 0x00, 0x0f, 0x08, 0x00 };
 
 void
-vga_get_hardware_settings(struct vgaregmap *reg, int *width, int *height)
+vga_get_hardware_settings(vgaregmap_t reg, int *width, int *height)
 {
 	*width = (GET_HORIZ_END(reg)+1)*8;
 	*height = GET_VERT_END(reg)+1;
 	if (GET_VERT_X2(reg)) *height *= 2;
 }
 
-#define	PUTB(reg, off, v) ddi_put8(reg->handle, reg->addr + (off), v)
-#define	GETB(reg, off) ddi_get8(reg->handle, reg->addr + (off))
-
 int
-vga_get_reg(struct vgaregmap *reg, int indexreg)
+vga_get_reg(vgaregmap_t reg, int indexreg)
 {
 	return (GETB(reg, indexreg));
 }
 
 void
-vga_set_reg(struct vgaregmap *reg, int indexreg, int v)
+vga_set_reg(vgaregmap_t reg, int indexreg, int v)
 {
 	PUTB(reg, indexreg, v);
 }
 
 int
-vga_get_crtc(struct vgaregmap *reg, int i)
+vga_get_crtc(vgaregmap_t reg, int i)
 {
 	return (vga_get_indexed(reg, VGA_CRTC_ADR, VGA_CRTC_DATA, i));
 }
 
 void
-vga_set_crtc(struct vgaregmap *reg, int i, int v)
+vga_set_crtc(vgaregmap_t reg, int i, int v)
 {
 	vga_set_indexed(reg, VGA_CRTC_ADR, VGA_CRTC_DATA, i, v);
 }
 
 int
-vga_get_seq(struct vgaregmap *reg, int i)
+vga_get_seq(vgaregmap_t reg, int i)
 {
 	return (vga_get_indexed(reg, VGA_SEQ_ADR, VGA_SEQ_DATA, i));
 }
 
 void
-vga_set_seq(struct vgaregmap *reg, int i, int v)
+vga_set_seq(vgaregmap_t reg, int i, int v)
 {
 	vga_set_indexed(reg, VGA_SEQ_ADR, VGA_SEQ_DATA, i, v);
 }
 
 int
-vga_get_grc(struct vgaregmap *reg, int i)
+vga_get_grc(vgaregmap_t reg, int i)
 {
 	return (vga_get_indexed(reg, VGA_GRC_ADR, VGA_GRC_DATA, i));
 }
 
 void
-vga_set_grc(struct vgaregmap *reg, int i, int v)
+vga_set_grc(vgaregmap_t reg, int i, int v)
 {
 	vga_set_indexed(reg, VGA_GRC_ADR, VGA_GRC_DATA, i, v);
 }
 
 int
-vga_get_atr(struct vgaregmap *reg, int i)
+vga_get_atr(vgaregmap_t reg, int i)
 {
 	int ret;
 
@@ -150,7 +160,7 @@ vga_get_atr(struct vgaregmap *reg, int i)
 }
 
 void
-vga_set_atr(struct vgaregmap *reg, int i, int v)
+vga_set_atr(vgaregmap_t reg, int i, int v)
 {
 	(void) GETB(reg, CGA_STAT);
 	PUTB(reg, VGA_ATR_AD, i);
@@ -162,7 +172,7 @@ vga_set_atr(struct vgaregmap *reg, int i, int v)
 
 void
 vga_set_indexed(
-	struct vgaregmap *reg,
+	vgaregmap_t reg,
 	int indexreg,
 	int datareg,
 	unsigned char index,
@@ -174,7 +184,7 @@ vga_set_indexed(
 
 int
 vga_get_indexed(
-	struct vgaregmap *reg,
+	vgaregmap_t reg,
 	int indexreg,
 	int datareg,
 	unsigned char index)
@@ -190,7 +200,7 @@ vga_get_indexed(
  */
 void
 vga_put_cmap(
-	struct vgaregmap *reg,
+	vgaregmap_t reg,
 	int index,
 	unsigned char r,
 	unsigned char g,
@@ -205,7 +215,7 @@ vga_put_cmap(
 
 void
 vga_get_cmap(
-	struct vgaregmap *reg,
+	vgaregmap_t reg,
 	int index,
 	unsigned char *r,
 	unsigned char *g,
@@ -220,8 +230,7 @@ vga_get_cmap(
 #ifdef	DEBUG
 
 void
-vga_dump_regs(struct vgaregmap *reg,
-	int maxseq, int maxcrtc, int maxatr, int maxgrc)
+vga_dump_regs(vgaregmap_t reg, int maxseq, int maxcrtc, int maxatr, int maxgrc)
 {
 	int i, j;
 
diff --git a/usr/src/lib/libast/Makefile.com b/usr/src/lib/libast/Makefile.com
index 3ec9d8313e..46c4dad799 100644
--- a/usr/src/lib/libast/Makefile.com
+++ b/usr/src/lib/libast/Makefile.com
@@ -22,6 +22,7 @@
 #
 # Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 SHELL=/usr/bin/ksh93
 
@@ -738,6 +739,8 @@ CERRWARN += -_gcc=-Wno-empty-body
 CERRWARN += -_gcc=-Wno-type-limits
 CERRWARN += -_gcc=-Wno-address
 
+SMATCH=off
+
 pics/$(MACH)/src/lib/libast/conftab.o \
 pics/$(MACH64)/src/lib/libast/conftab.o	:= CERRWARN += -erroff=E_INIT_DOES_NOT_FIT
 pics/common/comp/setlocale.o		:= CERRWARN += -erroff=E_INTEGER_OVERFLOW_DETECTED
diff --git a/usr/src/lib/libc/amd64/Makefile b/usr/src/lib/libc/amd64/Makefile
index f5c4224338..2e5b58e349 100644
--- a/usr/src/lib/libc/amd64/Makefile
+++ b/usr/src/lib/libc/amd64/Makefile
@@ -24,7 +24,7 @@
 # Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved.
 # Copyright 2013 Garrett D'Amore <garrett@damore.org>
 # Copyright 2018 Nexenta Systems, Inc.
-# Copyright 2018 Joyent, Inc.
+# Copyright (c) 2019, Joyent, Inc.
 #
 
 LIBCBASE=	.
@@ -1036,6 +1036,9 @@ CERRWARN += -_gcc=-Wno-clobbered
 CERRWARN += -_gcc=-Wno-unused-function
 CERRWARN += -_gcc=-Wno-address
 
+# not linted
+SMATCH=off
+
 # Setting THREAD_DEBUG = -DTHREAD_DEBUG (make THREAD_DEBUG=-DTHREAD_DEBUG ...)
 # enables ASSERT() checking in the threads portion of the library.
 # This is automatically enabled for DEBUG builds, not for non-debug builds.
diff --git a/usr/src/lib/libc/i386/Makefile b/usr/src/lib/libc/i386/Makefile
index 00376a40a1..178a2c216f 100644
--- a/usr/src/lib/libc/i386/Makefile
+++ b/usr/src/lib/libc/i386/Makefile
@@ -22,10 +22,7 @@
 # Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
-# lib/libc/i386/Makefile
-#
+# Copyright (c) 2019, Joyent, Inc.
 
 LIBCBASE=../i386
 
diff --git a/usr/src/lib/libc/i386/Makefile.com b/usr/src/lib/libc/i386/Makefile.com
index e9343c2f15..69f45567b2 100644
--- a/usr/src/lib/libc/i386/Makefile.com
+++ b/usr/src/lib/libc/i386/Makefile.com
@@ -21,10 +21,10 @@
 
 #
 # Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright 2019 Joyent, Inc.
 # Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved.
 # Copyright 2013 Garrett D'Amore <garrett@damore.org>
 # Copyright 2018 Nexenta Systems, Inc.
-# Copyright 2018 Joyent, Inc.
 #
 
 LIBCDIR=	$(SRC)/lib/libc
@@ -1085,6 +1085,9 @@ CERRWARN += -_gcc=-Wno-clobbered
 CERRWARN += -_gcc=-Wno-unused-function
 CERRWARN += -_gcc=-Wno-address
 
+# not linted
+SMATCH=off
+
 # Setting THREAD_DEBUG = -DTHREAD_DEBUG (make THREAD_DEBUG=-DTHREAD_DEBUG ...)
 # enables ASSERT() checking in the threads portion of the library.
 # This is automatically enabled for DEBUG builds, not for non-debug builds.
@@ -1317,7 +1320,7 @@ $(LIB_PIC): pics $$(PICS)
 	$(POST_PROCESS_A)
 
 $(LIBCBASE)/crt/_rtbootld.s: $(LIBCBASE)/crt/_rtboot.s $(LIBCBASE)/crt/_rtld.c
-	$(CC) $(CPPFLAGS) $(CTF_FLAGS) -O -S $(C_PICFLAGS) \
+	$(CC) $(CPPFLAGS) -_smatch=off $(CTF_FLAGS) -O -S $(C_PICFLAGS) \
 	    $(LIBCBASE)/crt/_rtld.c -o $(LIBCBASE)/crt/_rtld.s
 	$(CAT) $(LIBCBASE)/crt/_rtboot.s $(LIBCBASE)/crt/_rtld.s > $@
 	$(RM) $(LIBCBASE)/crt/_rtld.s
diff --git a/usr/src/lib/libc/inc/libc_int.h b/usr/src/lib/libc/inc/libc_int.h
index 940636b49c..0bc8a16fa0 100644
--- a/usr/src/lib/libc/inc/libc_int.h
+++ b/usr/src/lib/libc/inc/libc_int.h
@@ -74,7 +74,7 @@ extern "C" {
 typedef struct {
 	int	ci_tag;
 	union {
-		int	(*ci_func)();
+		void	*ci_func;
 		long	ci_val;
 		char	*ci_ptr;
 	} ci_un;
diff --git a/usr/src/lib/libc/port/gen/ssignal.c b/usr/src/lib/libc/port/gen/ssignal.c
index 6030626b17..ce74eb2a07 100644
--- a/usr/src/lib/libc/port/gen/ssignal.c
+++ b/usr/src/lib/libc/port/gen/ssignal.c
@@ -25,9 +25,7 @@
  */
 
 /*	Copyright (c) 1988 AT&T	*/
-/*	  All Rights Reserved  	*/
-
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
+/*	All Rights Reserved	*/
 
 /*
  *	ssignal, gsignal: software signals
@@ -54,8 +52,9 @@ ssignal(int sig, int (*action)(int)))(int)
 	if (sig >= MINSIG && sig <= MAXSIGNUM) {
 		savefn = sigs[sig-MINSIG];
 		sigs[sig-MINSIG] = action;
-	} else
-		savefn = (int(*)(int))SIG_DFL;
+	} else {
+		savefn = (int(*)(int))(uintptr_t)SIG_DFL;
+	}
 
 	return (savefn);
 }
@@ -66,12 +65,14 @@ gsignal(int sig)
 	int (*sigfn)(int);
 
 	if (sig < MINSIG || sig > MAXSIGNUM ||
-	    (sigfn = sigs[sig-MINSIG]) == (int(*)(int))SIG_DFL)
+	    (sigfn = sigs[sig-MINSIG]) == (int(*)(int))(uintptr_t)SIG_DFL) {
 		return (0);
-	else if (sigfn == (int(*)(int))SIG_IGN)
-		return (1);
-	else {
-		sigs[sig-MINSIG] = (int(*)(int))SIG_DFL;
-		return ((*sigfn)(sig));
+	} else {
+		if (sigfn == (int(*)(int))(uintptr_t)SIG_IGN) {
+			return (1);
+		} else {
+			sigs[sig-MINSIG] = (int(*)(int))(uintptr_t)SIG_DFL;
+			return ((*sigfn)(sig));
+		}
 	}
 }
diff --git a/usr/src/lib/libc/port/threads/c11_thr.c b/usr/src/lib/libc/port/threads/c11_thr.c
index a33fa12743..98e72c9b04 100644
--- a/usr/src/lib/libc/port/threads/c11_thr.c
+++ b/usr/src/lib/libc/port/threads/c11_thr.c
@@ -195,7 +195,8 @@ thrd_create(thrd_t *thr, thrd_start_t func, void *arg)
 {
 	int ret;
 
-	ret = pthread_create(thr, NULL, (void *(*)(void *))func, arg);
+	ret = pthread_create(thr, NULL,
+	    (void *(*)(void *))(uintptr_t)func, arg);
 	if (ret == 0)
 		return (thrd_success);
 	else if (ret == -1 && errno == EAGAIN)
diff --git a/usr/src/lib/libc/port/threads/pthread.c b/usr/src/lib/libc/port/threads/pthread.c
index 34b4b4c73c..dc0123361d 100644
--- a/usr/src/lib/libc/port/threads/pthread.c
+++ b/usr/src/lib/libc/port/threads/pthread.c
@@ -177,6 +177,14 @@ pthread_create(pthread_t *thread, const pthread_attr_t *attr,
 	return (error);
 }
 
+static void
+_mutex_unlock_wrap(void *ptr)
+{
+	mutex_t *mp = ptr;
+
+	(void) mutex_unlock(mp);
+}
+
 /*
  * pthread_once: calls given function only once.
  * it synchronizes via mutex in pthread_once_t structure
@@ -192,7 +200,7 @@ pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
 	if (once->once_flag == PTHREAD_ONCE_NOTDONE) {
 		(void) mutex_lock(&once->mlock);
 		if (once->once_flag == PTHREAD_ONCE_NOTDONE) {
-			pthread_cleanup_push(mutex_unlock, &once->mlock);
+			pthread_cleanup_push(_mutex_unlock_wrap, &once->mlock);
 			(*init_routine)();
 			pthread_cleanup_pop(0);
 			membar_producer();
diff --git a/usr/src/lib/libc/port/threads/tls.c b/usr/src/lib/libc/port/threads/tls.c
index 9822cc5367..31fd1c5368 100644
--- a/usr/src/lib/libc/port/threads/tls.c
+++ b/usr/src/lib/libc/port/threads/tls.c
@@ -199,13 +199,13 @@ extern	int	_preexec_exit_handlers();
 extern	void	libc_init();
 
 const Lc_interface tls_rtldinfo[] = {
-	{CI_VERSION,	(int(*)())CI_V_CURRENT},
-	{CI_ATEXIT,	(int(*)())_preexec_exit_handlers},
-	{CI_TLS_MODADD,	(int(*)())__tls_mod_add},
-	{CI_TLS_MODREM,	(int(*)())__tls_mod_remove},
-	{CI_TLS_STATMOD, (int(*)())__tls_static_mods},
-	{CI_THRINIT,	(int(*)())libc_init},
-	{CI_NULL,	(int(*)())NULL}
+	{ .ci_tag = CI_VERSION,	.ci_un.ci_val = CI_V_CURRENT },
+	{ .ci_tag = CI_ATEXIT, .ci_un.ci_func = _preexec_exit_handlers },
+	{ .ci_tag = CI_TLS_MODADD, .ci_un.ci_func = __tls_mod_add },
+	{ .ci_tag = CI_TLS_MODREM, .ci_un.ci_func = __tls_mod_remove },
+	{ .ci_tag = CI_TLS_STATMOD, .ci_un.ci_func = __tls_static_mods },
+	{ .ci_tag = CI_THRINIT,	.ci_un.ci_func = libc_init },
+	{ .ci_tag = CI_NULL, .ci_un.ci_func = NULL }
 };
 
 /*
diff --git a/usr/src/lib/libficl/Makefile.com b/usr/src/lib/libficl/Makefile.com
index a7f4a3f63f..b4532d2ed9 100644
--- a/usr/src/lib/libficl/Makefile.com
+++ b/usr/src/lib/libficl/Makefile.com
@@ -21,7 +21,7 @@ VERS=.$(MAJOR).$(MINOR)
 OBJECTS= dictionary.o system.o fileaccess.o float.o double.o prefix.o search.o \
 	softcore.o stack.o tools.o vm.o primitives.o unix.o utility.o \
 	hash.o callback.o word.o loader.o pager.o extras.o \
-	loader_emu.o lz4.o
+	loader_emu.o pnglite.o lz4.o
 
 include $(SRC)/lib/Makefile.lib
 
@@ -29,17 +29,19 @@ LIBS=	$(DYNLIB) $(LINTLIB)
 
 FICLDIR=	$(SRC)/common/ficl
 CSTD=	$(CSTD_GNU99)
+PNGLITE=	$(SRC)/common/pnglite
 CPPFLAGS +=	-I.. -I$(FICLDIR) -D_LARGEFILE64_SOURCE=1
+CPPFLAGS +=	-I$(PNGLITE)
 
 # As variable "count" is marked volatile, gcc 4.4.4 will complain about
 # function argument. So we switch this warning off
 # for time being, till gcc 4.4.4 will be replaced.
 pics/vm.o := CERRWARN += -_gcc=-Wno-clobbered
 
-LDLIBS +=	-luuid -lc -lm -lumem
+LDLIBS +=	-luuid -lz -lc -lm -lumem
 
 HEADERS= $(FICLDIR)/ficl.h $(FICLDIR)/ficltokens.h ../ficllocal.h \
-	$(FICLDIR)/ficlplatform/unix.h
+	$(FICLDIR)/ficlplatform/unix.h $(PNGLITE)/pnglite.h
 
 pics/%.o:	../softcore/%.c $(HEADERS)
 	$(COMPILE.c) -o $@ $<
@@ -61,6 +63,10 @@ pics/%.o:	$(FICLDIR)/softcore/%.c $(HEADERS)
 	$(COMPILE.c) -o $@ $<
 	$(POST_PROCESS_O)
 
+pics/%.o:	$(PNGLITE)/%.c $(HEADERS)
+	$(COMPILE.c) -o $@ $<
+	$(POST_PROCESS_O)
+
 $(LINTLIB) := SRCS=	../$(LINTSRC)
 
 all: $(LIBS)
diff --git a/usr/src/lib/libm/Makefile.libm.com b/usr/src/lib/libm/Makefile.libm.com
index 93d071c377..dc7a353d97 100644
--- a/usr/src/lib/libm/Makefile.libm.com
+++ b/usr/src/lib/libm/Makefile.libm.com
@@ -11,6 +11,7 @@
 
 #
 # Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
+# Copyright (c) 2019, Joyent, Inc.
 #
 
 LIBMDIR		= $(SRC)/lib/libm
@@ -63,6 +64,10 @@ CFLAGS64	+= -_gcc=-D__C99FEATURES__
 CFLAGS		+= -_gcc=-fno-strict-overflow
 CFLAGS64	+= -_gcc=-fno-strict-overflow
 
+# sparse currently has no _Complex support
+CFLAGS		+= -_smatch=off
+CFLAGS64	+= -_smatch=off
+
 $(DYNLIB) 	:= LDLIBS += -lc
 
 $(LINTLIB) 	:= SRCS = $(LIBMSRC)/$(LINTSRC)
diff --git a/usr/src/lib/libpp/Makefile.com b/usr/src/lib/libpp/Makefile.com
index 26bd897ec8..2710fe8873 100644
--- a/usr/src/lib/libpp/Makefile.com
+++ b/usr/src/lib/libpp/Makefile.com
@@ -22,6 +22,7 @@
 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 SHELL=/usr/bin/ksh93
 
@@ -104,6 +105,9 @@ CERRWARN	+= -_gcc=-Wno-char-subscripts
 CERRWARN	+= -_gcc=-Wno-empty-body
 CERRWARN	+= -_gcc=-Wno-unused-value
 
+# "pplex() parse error: turning off implications after 60 seconds"
+SMATCH		= off
+
 pics/ppcall.o 		:= CERRWARN += -erroff=E_INTEGER_OVERFLOW_DETECTED
 pics/ppcontrol.o 	:= CERRWARN += -erroff=E_INTEGER_OVERFLOW_DETECTED
 pics/ppcpp.o		:= CERRWARN += -erroff=E_INTEGER_OVERFLOW_DETECTED
diff --git a/usr/src/lib/libshell/Makefile.com b/usr/src/lib/libshell/Makefile.com
index 8dd5057867..b904c0fe5f 100644
--- a/usr/src/lib/libshell/Makefile.com
+++ b/usr/src/lib/libshell/Makefile.com
@@ -21,6 +21,7 @@
 
 #
 # Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2019, Joyent, Inc.
 #
 
 SHELL=/usr/bin/ksh93
@@ -161,6 +162,9 @@ CERRWARN	+= -_gcc=-Wno-uninitialized
 CERRWARN	+= -_gcc=-Wno-clobbered
 CERRWARN	+= -_gcc=-Wno-char-subscripts
 
+# smatch gets out of memory on common/sh/macro.c
+SMATCH		= off
+
 pics/sh/macro.o		:= CERRWARN += -erroff=E_NO_IMPLICIT_DECL_ALLOWED
 pics/sh/nvdisc.o	:= CERRWARN += -erroff=E_END_OF_LOOP_CODE_NOT_REACHED
 
diff --git a/usr/src/man/man1/Makefile b/usr/src/man/man1/Makefile
index 50fcbfc385..a4d59dadcc 100644
--- a/usr/src/man/man1/Makefile
+++ b/usr/src/man/man1/Makefile
@@ -17,7 +17,7 @@
 
 include		$(SRC)/Makefile.master
 
-MANSECT= 	1
+MANSECT=	1
 
 MANFILES=	acctcom.1			\
 		adb.1				\
@@ -123,6 +123,7 @@ MANFILES=	acctcom.1			\
 		enhance.1			\
 		env.1				\
 		eqn.1				\
+		etdump.1			\
 		exec.1				\
 		exit.1				\
 		expand.1			\
diff --git a/usr/src/man/man1/etdump.1 b/usr/src/man/man1/etdump.1
new file mode 100644
index 0000000000..a806eccc8b
--- /dev/null
+++ b/usr/src/man/man1/etdump.1
@@ -0,0 +1,97 @@
+.\" Copyright (c) 2018 iXsystems, Inc
+.\" 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.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\"
+.Dd April 3, 2018
+.Dt ETDUMP 1
+.Os
+.Sh NAME
+.Nm etdump
+.Nd Dump El Torito boot catalog information from ISO images
+.Sh SYNOPSIS
+.Nm
+.Op Fl f Ar format
+.Op Fl o Ar file
+.Ar
+.Sh DESCRIPTION
+This program reads El Torito boot catalog information from an ISO image and
+outputs it in various formats.
+It can be used to check the catalog in an image or to output catalog data in
+a format that can be used by other tools such as shell scripts.
+.Pp
+Supported options are:
+.Bl -tag -width flag
+.It Fl f Ar format Fl -format Ar format
+Select the output format.
+Supported output formats are:
+.Bl -tag -width shell -offset indent
+.It Sy text
+Human-readable text (default)
+.It Sy shell
+Each boot entry is emitted as a string suitable for passing to a sh-compatible
+eval command.
+The variables emitted are:
+.Bl -tag -width et_platform -offset indent
+.It et_platform
+The platform ID from the section header.
+Set to 'default' for the initial (default) entry.
+.It et_system
+The system ID from the boot entry.
+.It et_lba
+The starting LBA (2048-byte blocks) of the boot image.
+.It et_sectors
+The number of sectors (512-byte sectors) that comprise the boot image.
+.El
+.El
+.It Fl o Ar file Fl -output Ar file
+Write output to
+.Ar file .
+If '-' is specified then standard out is used.
+.El
+.Sh EXAMPLES
+To see what entries are in a given boot catalog run
+.Nm
+passing the filename of the image as an argument like so:
+.Bd -literal -offset indent
+% etdump bootonly.iso
+Image in bootonly.iso
+Default entry
+	System i386
+	Start LBA 420 (0x1a4), sector count 4 (0x4)
+	Media type: no emulation
+
+Section header: efi, final
+	Section entry
+		System i386
+		Start LBA 20 (0x14), sector count 1600 (0x640)
+		Media type: no emulation
+.Ed
+.Pp
+To use the output in a shell script a for loop can be used to iterate over the
+entries returned using eval:
+.Bd -literal -offset indent
+for entry in `etdump --format shell bootonly.iso`; do
+	eval $entry
+	echo $et_platform $et_system $et_lba $et_sectors
+done
+.Ed
diff --git a/usr/src/man/man5/loader.5 b/usr/src/man/man5/loader.5
index 0b0a2b123a..69a9261747 100644
--- a/usr/src/man/man5/loader.5
+++ b/usr/src/man/man5/loader.5
@@ -95,8 +95,8 @@ Then, devices are probed,
 and
 .Va loaddev
 are set, and
-.Va COLUMNS ,
-.Va LINES ,
+.Va screen-#cols ,
+.Va screen-#rows ,
 and
 .Va ISADIR
 are set.
@@ -274,7 +274,7 @@ as the pool.
 .Pp
 .It Ic more Ar file Op Ar
 Display the files specified, with a pause at each
-.Va LINES
+.Va screen-#rows
 displayed.
 .Pp
 .It Ic read Xo
@@ -452,7 +452,7 @@ Syntax for devices is odd.
 Has the value
 .Dq Li ok
 if the Forth's current state is interpreting.
-.It Va LINES
+.It Va screen-#rows
 Define the number of lines on the screen, to be used by the pager.
 .It Va module_path
 Sets the list of directories which will be searched for modules
diff --git a/usr/src/pkg/manifests/SUNWcs.man1.inc b/usr/src/pkg/manifests/SUNWcs.man1.inc
index f42294f4cd..381f383b88 100644
--- a/usr/src/pkg/manifests/SUNWcs.man1.inc
+++ b/usr/src/pkg/manifests/SUNWcs.man1.inc
@@ -71,6 +71,7 @@ file path=usr/share/man/man1/ed.1
 file path=usr/share/man/man1/eject.1
 file path=usr/share/man/man1/encrypt.1
 file path=usr/share/man/man1/env.1
+file path=usr/share/man/man1/etdump.1
 file path=usr/share/man/man1/exec.1
 file path=usr/share/man/man1/exit.1
 file path=usr/share/man/man1/expr.1
diff --git a/usr/src/pkg/manifests/system-boot-loader.mf b/usr/src/pkg/manifests/system-boot-loader.mf
index 22d5337392..d4508edfbc 100644
--- a/usr/src/pkg/manifests/system-boot-loader.mf
+++ b/usr/src/pkg/manifests/system-boot-loader.mf
@@ -71,6 +71,7 @@ $(i386_ONLY)file path=boot/forth/shortcuts.4th group=sys mode=0444
 $(i386_ONLY)file path=boot/forth/support.4th group=sys mode=0444
 $(i386_ONLY)file path=boot/forth/version.4th group=sys mode=0444
 $(i386_ONLY)file path=boot/gptzfsboot group=sys mode=0444
+$(i386_ONLY)file path=boot/illumos.png group=sys mode=0444
 $(i386_ONLY)file path=boot/loader group=sys mode=0444
 $(i386_ONLY)file path=boot/loader.help group=sys mode=0444
 $(i386_ONLY)file path=boot/loader.rc group=sys mode=0444
@@ -94,3 +95,5 @@ license lic_CDDL license=lic_CDDL
 license usr/src/boot/COPYRIGHT license=usr/src/boot/COPYRIGHT
 license usr/src/boot/sys/boot/common/linenoise/LICENSE \
     license=usr/src/boot/sys/boot/common/linenoise/LICENSE
+license usr/src/common/pnglite/THIRDPARTYLICENSE \
+    license=usr/src/common/pnglite/THIRDPARTYLICENSE
diff --git a/usr/src/pkg/manifests/system-extended-system-utilities.mf b/usr/src/pkg/manifests/system-extended-system-utilities.mf
index 546da82239..f9fa79d5ed 100644
--- a/usr/src/pkg/manifests/system-extended-system-utilities.mf
+++ b/usr/src/pkg/manifests/system-extended-system-utilities.mf
@@ -107,6 +107,7 @@ file path=usr/bin/diff mode=0555
 file path=usr/bin/diff3 mode=0555
 file path=usr/bin/dircmp mode=0555
 file path=usr/bin/dos2unix mode=0555
+file path=usr/bin/etdump mode=0555
 file path=usr/bin/expand mode=0555
 file path=usr/bin/factor mode=0555
 file path=usr/bin/kstat mode=0555
@@ -247,6 +248,8 @@ license cr_Sun license=cr_Sun
 license lic_CDDL license=lic_CDDL
 license usr/src/cmd/compress/THIRDPARTYLICENSE \
     license=usr/src/cmd/compress/THIRDPARTYLICENSE
+license usr/src/cmd/etdump/THIRDPARTYLICENSE \
+    license=usr/src/cmd/etdump/THIRDPARTYLICENSE
 license usr/src/cmd/lastcomm/THIRDPARTYLICENSE \
     license=usr/src/cmd/lastcomm/THIRDPARTYLICENSE
 license usr/src/cmd/look/THIRDPARTYLICENSE \
diff --git a/usr/src/tools/Makefile b/usr/src/tools/Makefile
index 81fbbaf30c..1ddff5d388 100644
--- a/usr/src/tools/Makefile
+++ b/usr/src/tools/Makefile
@@ -24,6 +24,7 @@
 # Copyright 2014 Garrett D'Amore <garrett@damore.org>
 # Copyright 2016 Toomas Soome <tsoome@me.com>
 # Copyright (c) 2016, Chris Fraire <cfraire@me.com>.
+# Copyright (c) 2019, Joyent, Inc.
 #
 
 include ../Makefile.master
@@ -35,6 +36,8 @@ include ../Makefile.master
 # Because of somewhat cyclic dependency between them, both cw and install.bin
 # override the way we install binaries in their Makefiles.
 BOOT_SUBDIRS= \
+	smatch \
+	.WAIT \
 	cw \
 	.WAIT \
 	install.bin \
diff --git a/usr/src/tools/cw/cw.c b/usr/src/tools/cw/cw.c
index c68ace9848..7806b50626 100644
--- a/usr/src/tools/cw/cw.c
+++ b/usr/src/tools/cw/cw.c
@@ -26,6 +26,8 @@
 /*
  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright 2019 Joyent, Inc.
  */
 
 /*
@@ -291,7 +293,8 @@ struct aelist {
 
 typedef enum {
 	GNU,
-	SUN
+	SUN,
+	SMATCH
 } compiler_style_t;
 
 typedef struct {
@@ -1271,6 +1274,32 @@ do_gcc(cw_ictx_t *ctx)
 }
 
 static void
+do_smatch(cw_ictx_t *ctx)
+{
+	if (ctx->i_flags & CW_F_PROG) {
+		newae(ctx->i_ae, "--version");
+		return;
+	}
+
+	/*
+	 * Some sources shouldn't run smatch at all.
+	 */
+	for (int i = 0; i < ctx->i_oldargc; i++) {
+		char *arg = ctx->i_oldargv[i];
+
+		if (strcmp(arg, "-_smatch=off") == 0) {
+			ctx->i_flags &= ~ (CW_F_EXEC | CW_F_ECHO);
+			return;
+		}
+	}
+
+	/*
+	 * smatch can handle gcc's options.
+	 */
+	do_gcc(ctx);
+}
+
+static void
 do_cc(cw_ictx_t *ctx)
 {
 	int in_output = 0, seen_o = 0;
@@ -1376,6 +1405,9 @@ prepctx(cw_ictx_t *ctx)
 	case GNU:
 		do_gcc(ctx);
 		break;
+	case SMATCH:
+		do_smatch(ctx);
+		break;
 	}
 }
 
@@ -1560,13 +1592,16 @@ parse_compiler(const char *spec, cw_compiler_t *compiler)
 		errx(1, "Compiler is missing a style: %s", spec);
 
 	if ((strcasecmp(token, "gnu") == 0) ||
-	    (strcasecmp(token, "gcc") == 0))
+	    (strcasecmp(token, "gcc") == 0)) {
 		compiler->c_style = GNU;
-	else if ((strcasecmp(token, "sun") == 0) ||
-	    (strcasecmp(token, "cc") == 0))
+	} else if ((strcasecmp(token, "sun") == 0) ||
+	    (strcasecmp(token, "cc") == 0)) {
 		compiler->c_style = SUN;
-	else
+	} else if ((strcasecmp(token, "smatch") == 0)) {
+		compiler->c_style = SMATCH;
+	} else {
 		errx(1, "unknown compiler style: %s", token);
+	}
 
 	if (tspec != NULL)
 		errx(1, "Excess tokens in compiler: %s", spec);
diff --git a/usr/src/tools/env/illumos.sh b/usr/src/tools/env/illumos.sh
index a47b711347..db38b367e7 100644
--- a/usr/src/tools/env/illumos.sh
+++ b/usr/src/tools/env/illumos.sh
@@ -23,7 +23,7 @@
 # Copyright 2012 Joshua M. Clulow <josh@sysmgr.org>
 # Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved.
 # Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
-# Copyright (c) 2018, Joyent, Inc.
+# Copyright (c) 2019, Joyent, Inc.
 #
 # - This file is sourced by "bldenv.sh" and "nightly.sh" and should not
 #   be executed directly.
@@ -81,6 +81,9 @@ export CODEMGR_WS="`git rev-parse --show-toplevel`"
 export SHADOW_CCS=gcc7,/usr/gcc/7/bin/gcc,gnu
 export SHADOW_CCCS=gcc7,/usr/gcc/7/bin/g++,gnu
 
+# uncomment to enable smatch
+#export ENABLE_SMATCH=1
+
 # Comment this out to disable support for SMB printing, i.e. if you
 # don't want to bother providing the CUPS headers this needs.
 export ENABLE_SMB_PRINTING=
@@ -279,3 +282,8 @@ export SPRO_VROOT="$SPRO_ROOT"
 # proto area, that we then fail the build.
 #
 export LD_TOXIC_PATH="$ROOT/lib:$ROOT/usr/lib"
+
+if [[ "$ENABLE_SMATCH" = "1" ]]; then
+	SMATCHBIN=$CODEMGR_WS/usr/src/tools/proto/root_$MACH-nd/opt/onbld/bin/$MACH/smatch
+	export SHADOW_CCS="$SHADOW_CCS smatch,$SMATCHBIN,smatch"
+fi
diff --git a/usr/src/tools/scripts/checkpaths.sh b/usr/src/tools/scripts/checkpaths.sh
index 5a897deb45..e4a9b21b61 100644
--- a/usr/src/tools/scripts/checkpaths.sh
+++ b/usr/src/tools/scripts/checkpaths.sh
@@ -19,11 +19,10 @@
 #
 # CDDL HEADER END
 #
-
-#
 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 # Quis custodiet ipsos custodies?
 
@@ -73,27 +72,6 @@ do
 		exit 1
 		;;
 	esac
-	if [ -d $ROOT ]; then
-		#
-		# This is the old-style packaging exception list, from
-		# the svr4-specific usr/src/pkgdefs
-		#
-		[ -f $SRC/pkgdefs/etc/exception_list_$arch ] && \
-			validate_paths '-s/\s*'$arch'$//'  \
-			    -e ^usr/include/ike/ -b $ROOT \
-			    $args $SRC/pkgdefs/etc/exception_list_$arch
-		#
-		# These are the new-style packaging exception lists,
-		# from the repository-wide exception_lists/ directory.
-		#
-		e="$CODEMGR_WS/exception_lists/packaging"
-		for f in $e; do
-			if [ -f $f ]; then
-				nawk 'NF == 1 || /[ 	]\+'$arch'$/ { print; }' \
-				    < $f | validate_paths -b $ROOT -n $f
-			fi
-		done
-	fi
 done
 
 # Two entries in the findunref exception_list deal with things created
diff --git a/usr/src/tools/scripts/nightly.sh b/usr/src/tools/scripts/nightly.sh
index f28d37dd87..09a2b151cb 100644
--- a/usr/src/tools/scripts/nightly.sh
+++ b/usr/src/tools/scripts/nightly.sh
@@ -27,7 +27,7 @@
 # Copyright 2012 Joshua M. Clulow <josh@sysmgr.org>
 # Copyright 2018 (c) Joyent, Inc.  All rights reserved.
 # Copyright (c) 2017 by Delphix. All rights reserved.
-# Copyright 2018 Joyent, Inc.
+# Copyright 2019 Joyent, Inc.
 # Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
 #
 # Based on the nightly script from the integration folks,
@@ -219,7 +219,7 @@ function build {
 	fi
 
 	echo "\n==== Build warnings ($LABEL) ====\n" >>$mail_msg_file
-	egrep -i warning: $SRC/${INSTALLOG}.out \
+	egrep -i 'warn:|warning:' $SRC/${INSTALLOG}.out \
 		| egrep -v '^tic:' \
 		| egrep -v "symbol (\`|')timezone' has differing types:" \
 		| egrep -v "parameter <PSTAMP> set to" \
diff --git a/usr/src/tools/smatch/Makefile b/usr/src/tools/smatch/Makefile
new file mode 100644
index 0000000000..7bd184d273
--- /dev/null
+++ b/usr/src/tools/smatch/Makefile
@@ -0,0 +1,167 @@
+#
+# This file and its contents are supplied under the terms of the
+# Common Development and Distribution License ("CDDL"), version 1.0.
+# You may only use this file in accordance with the terms of version
+# 1.0 of the CDDL.
+#
+# A full copy of the text of the CDDL should have accompanied this
+# source.  A copy of the CDDL is also available via the Internet at
+# http://www.illumos.org/license/CDDL.
+#
+# Copyright (c) 2019, Joyent, Inc.
+#
+
+#
+# The src/ sub-directory is un-modified copy of
+# https://github.com/illumos/smatch/tree/0.5.1-il-1
+#
+# This Makefile installs just enough for us to be able to run smatch
+# locally.
+#
+
+PROG = smatch
+SPARSE_VERSION = 0.5.1-il-1
+
+include ../Makefile.tools
+
+# We have to build smatch before we can use cw
+i386_CC = $(GNUC_ROOT)/bin/gcc
+sparc_CC = $(GNUC_ROOT)/bin/gcc
+
+CFLAGS = -O -D__sun -Wall -Wno-unknown-pragmas -std=gnu99 -nodefaultlibs
+
+SMATCHDATADIR = $(ROOTONBLDSHARE)/smatch
+
+CFLAGS += -DSMATCHDATADIR='"$(SMATCHDATADIR)"'
+CFLAGS += -DGCC_BASE='"/no/such/dir"'
+CFLAGS += -DMULTIARCH_TRIPLET=NULL
+
+LDLIBS += -lsqlite3 -lcrypto -lm -lgcc -lc
+LDFLAGS = $(MAPFILE.NES:%=-Wl,-M%)
+LDFLAGS += -L$(NATIVE_ADJUNCT)/lib -R$(NATIVE_ADJUNCT)/lib
+
+CPPFLAGS += -nostdinc
+CPPFLAGS += -Isrc/
+CPPFLAGS += -I$(NATIVE_ADJUNCT)/include
+
+# no install.bin
+INS.file = $(RM) $@; $(CP) $< $(@D); $(CHMOD) $(FILEMODE) $@
+INS.dir = mkdir -p $@; $(CHMOD) $(DIRMODE) $@
+
+SMATCH_CHECK_OBJS:sh=ls src/check_*.c | sed -e 's+\.c+.o+;s+src/++;'
+
+OBJS = smatch.o $(SMATCH_CHECK_OBJS)
+
+OBJS += smatch_flow.o smatch_conditions.o smatch_slist.o smatch_states.o \
+	smatch_helper.o smatch_type.o smatch_hooks.o smatch_function_hooks.o \
+	smatch_modification_hooks.o smatch_extra.o smatch_estate.o smatch_math.o \
+	smatch_sval.o smatch_ranges.o smatch_implied.o smatch_ignore.o smatch_project.o \
+	smatch_var_sym.o smatch_tracker.o smatch_files.o smatch_expression_stacks.o \
+	smatch_equiv.o smatch_buf_size.o smatch_strlen.o smatch_capped.o smatch_db.o \
+	smatch_expressions.o smatch_returns.o smatch_parse_call_math.o \
+	smatch_param_limit.o smatch_param_filter.o \
+	smatch_param_set.o smatch_comparison.o smatch_param_compare_limit.o smatch_local_values.o \
+	smatch_function_ptrs.o smatch_annotate.o smatch_string_list.o \
+	smatch_param_cleared.o smatch_start_states.o \
+	smatch_recurse.o smatch_data_source.o smatch_type_val.o \
+	smatch_common_functions.o smatch_struct_assignment.o \
+	smatch_unknown_value.o smatch_stored_conditions.o avl.o \
+	smatch_function_info.o smatch_links.o smatch_auto_copy.o \
+	smatch_type_links.o smatch_untracked_param.o smatch_impossible.o \
+	smatch_strings.o smatch_param_used.o smatch_container_of.o smatch_address.o \
+	smatch_buf_comparison.o smatch_real_absolute.o smatch_scope.o \
+	smatch_imaginary_absolute.o smatch_parameter_names.o \
+	smatch_return_to_param.o smatch_passes_array_size.o \
+	smatch_constraints.o smatch_constraints_required.o \
+	smatch_fn_arg_link.o smatch_about_fn_ptr_arg.o smatch_mtag.o \
+	smatch_mtag_map.o smatch_mtag_data.o \
+	smatch_param_to_mtag_data.o smatch_mem_tracker.o smatch_array_values.o \
+	smatch_nul_terminator.o smatch_assigned_expr.o smatch_kernel_user_data.o \
+	smatch_statement_count.o
+
+OBJS += target.o parse.o tokenize.o pre-process.o symbol.o lib.o scope.o \
+	expression.o show-parse.o evaluate.o expand.o inline.o linearize.o \
+	char.o sort.o allocate.o compat-linux.o ptrlist.o \
+	builtin.o \
+	stats.o \
+	flow.o cse.o simplify.o memops.o liveness.o storage.o unssa.o \
+	dissect.o \
+	macro_table.o token_store.o hashtable.o
+
+SMATCH_DATA = \
+	illumos_kernel.no_return_funcs \
+	illumos_kernel.skipped_functions \
+	illumos_user.no_return_funcs \
+	illumos_user.skipped_functions
+
+SMATCH_DB_DATA = \
+	return_states.schema \
+	call_implies.schema \
+	type_value.schema \
+	param_map.schema \
+	function_type_size.schema \
+	parameter_name.schema \
+	fn_ptr_data_link.schema \
+	constraints.schema \
+	mtag_about.schema \
+	type_info.schema \
+	function_type_info.schema \
+	caller_info.schema \
+	function_type_value.schema \
+	return_implies.schema \
+	type_size.schema \
+	constraints_required.schema \
+	fn_data_link.schema \
+	mtag_alias.schema \
+	common_caller_info.schema \
+	data_info.schema \
+	function_type.schema \
+	db.schema \
+	mtag_data.schema \
+	function_ptr.schema \
+	sink_info.schema \
+	local_values.schema \
+	mtag_map.schema
+
+ROOTONBLDDATAFILES = $(SMATCH_DATA:%=$(SMATCHDATADIR)/smatch_data/%)
+ROOTONBLDDATAFILES += $(SMATCH_DB_DATA:%=$(SMATCHDATADIR)/smatch_data/db/%)
+
+BUILT_HEADERS = src/version.h src/check_list_local.h
+
+.KEEP_STATE:
+
+all: $(PROG)
+
+install: all .WAIT $(ROOTONBLDMACHPROG) $(ROOTONBLDDATAFILES)
+
+clean:
+	rm -f $(OBJS) $(BUILT_HEADERS)
+
+$(ROOTONBLDDATAFILES): $(SMATCHDATADIR)/smatch_data/db
+
+$(SMATCHDATADIR)/smatch_data/%: src/smatch_data/%
+	$(INS.file)
+
+$(SMATCHDATADIR)/smatch_data/db:
+	$(INS.dir)
+
+$(SMATCHDATADIR)/smatch_data:
+	$(INS.dir)
+
+$(PROG): $(OBJS)
+	$(LINK.c) $(OBJS) -o $@ $(LDLIBS)
+	$(POST_PROCESS)
+
+%.o: src/%.c $(BUILT_HEADERS)
+	$(COMPILE.c) -o $@ $<
+
+%.o: src/cwchash/%.c
+	$(COMPILE.c) -o $@ $<
+
+src/check_list_local.h:
+	touch src/check_list_local.h
+
+src/version.h:
+	echo '#define SPARSE_VERSION "$(SPARSE_VERSION)"' > src/version.h
+
+include ../Makefile.targ
diff --git a/usr/src/tools/smatch/src/Documentation/data-structures.txt b/usr/src/tools/smatch/src/Documentation/data-structures.txt
new file mode 100644
index 0000000000..1441926375
--- /dev/null
+++ b/usr/src/tools/smatch/src/Documentation/data-structures.txt
@@ -0,0 +1,55 @@
+- A slightly edited irc discussion with Josh Triplett.
+- Describes most data structures used in sparse.
+
+As far as the parsing structures go...
+The C parser exists in two main files: parse.c, which parses statements, and expression.c, which parses expressions.
+parse.h contains the definition of struct statement, which represents a C statement.
+That includes only those things which can't appear as an expression, which primarily includes control flow statements such as if, loops, switch/case, and goto.
+expression.h contains the definition of struct expression, which represents a C expression.  That has a lot more content, since most C constructs can appear in expressions.
+A series of statements forms a compound statement (STMT_COMPOUND).
+That appears as another struct statement which has a statement_list member.
+A function body consists of a compound statement.
+When you look at a loop body, if or else body, or case body, you'll notice that they just have a struct statement, not a statement_list; they can have multiple statements by using a compound statement.
+Also note that all loops get turned into a single "iterator" statement.
+for, while, and do-while.
+A symbol, then, represents a name in a C file.  A symbol might represent a variable, a function, a label, or various other things.
+See symbol.h.
+"struct symbol" represents one symbol.
+As with the various other structures, it has some common data and a union of sub-structures for the parts that differ between different types.
+Most of the interesting bits come in the NS_SYMBOL case.
+Among other things, it has a struct statement for the body of a function (if any), a list of symbols for the arguments, an expression for a variable initializer, and so on.
+Together, struct symbol, struct statement, and struct expression represent most of the abstract syntax tree for C.
+So, that represents most of the "front-end" of Sparse: parsing C and generating that abstract syntax tree.
+That much occurs in pretty much any program using the Sparse frontend.
+The backend varies among programs.
+For instance, the c2xml backend goes that far, then outputs XML.
+The sparse static analysis backend has a few steps: it generates linearized bytecode, does some evaluation on that, and outputs some warnings.
+Several other backends run that linearized bytecode stage.
+The linearized bytecode itself has a set of nested structures.
+linearize.h defines all of them.
+At the top level, it has struct entrypoint.
+That represents an entrypoint to the code, which would normally mean a function.
+An entrypoint has a list of basic blocks.
+struct basic_block.
+A basic block represents a series of instructions with no branches.
+Straight-line code.
+A branch only occurs at the end of a basic block, and branches can only target the beginning of a basic block.
+Typically, a conditional will consist of a basic block leading up to the branch, a basic block for the true case, a basic block for the false case, and a basic block where the two paths merge back together.
+Either the true or the false case may not exist.
+A loop will normally have a basic block for the loop body, which can branch to the top at the end or continue to the next basic block.
+So basic blocks represent a node in the control flow graph.
+The edges in that graph lead from one basic block to a basic block which can follow it in the execution of the program.
+Each basic block has a series of instructions, "struct instruction".
+"enum opcode" lists all the instructions.
+Fairly high-level instruction set, corresponding directly to bits of C.
+So you have an entrypoint, which has a graph of basic blocks, each of which has a list of instructions.
+An entrypoint also has a pointer to the first instruction.
+One last bit of trickiness: struct pseudo.
+Have you ever heard of "static single assignment" or SSA form?
+struct pseudo represents one of those single-assignment variables.
+Each one has a pointer to the symbol it represents (which may have many pseudos referencing it).
+Each one also has a pointer to the instruction that defines it.
+That covers most of the major data structures in Sparse.
+Now, given all that, some of the top-level stuff in sparse.c may make more sense.
+For instance, the context checking works in terms of basic blocks.
+Hopefully some of that helped you understand Sparse better.
diff --git a/usr/src/tools/smatch/src/Documentation/project-ideas.md b/usr/src/tools/smatch/src/Documentation/project-ideas.md
new file mode 100644
index 0000000000..380f850b77
--- /dev/null
+++ b/usr/src/tools/smatch/src/Documentation/project-ideas.md
@@ -0,0 +1,52 @@
+Why hacking on sparse
+=====================
+
+1. sparse is small.  
+   The full project compiles in less than 10 seconds on old and not performing laptop.
+2. sparse is fast.  
+   Typically, sparse can check a C file 1/10 of time it takes for gcc to generate object files.
+3. sparse can digest the full kernel source files.  
+   With sparse-llvm, sparse uses llvm as back end to emit real machine code.
+
+New developer hacking on sparse
+==============================
+
+
+* All sparse warning messages should include the option how
+   to disable it.  
+       e.g. "pre-process.c:20*:28: warning: Variable length array is used."
+       should be something like   
+        "pre-process.c:20*:28: warning: Variable length array is
+used. (-Wno-vla)"
+* extend test-inspect to inspect more AST fields.
+* extend test-inspect to inspect instructions.
+* adding architecture handling in sparse similar to cgcc
+* parallel processing of test-suite
+* Howto: fix the kernel rcu related checker warnings
+* option to disable AST level inline.
+* debug: debug version of sparse do all the verification double check
+* test suite: verify and compare IR (suggested by Dibyendu Majumdar)
+* checker error output database
+
+For experienced developers
+==========================
+
+* merge C type on incremental declare of C type and function prototype.
+* move attribute out of ctype to allow easier to add new attribute.
+* serialize, general object walking driven by data structures.
+* serialize, write sparse byte code into file
+* serialize, load sparse byte code from file.
+* symbol index/linker, know which symbol in which byte code file.
+* inline function in instruction level
+* cross function checking
+* debug: optimization step by step log
+* debug: fancy animation of CFG
+* phi node location (Luc has patch)
+* revisit crazy programmer warning, invalid SSA form.
+* ptrlist, looping while modify inside the loop.
+* dead code elimination using ssa
+* constant propagation using ssa.
+* x86/arm back end instruction set define
+* register allocation.
+* emit x86/arm machine level code
+
diff --git a/usr/src/tools/smatch/src/Documentation/smatch.txt b/usr/src/tools/smatch/src/Documentation/smatch.txt
new file mode 100644
index 0000000000..ae9a454dd0
--- /dev/null
+++ b/usr/src/tools/smatch/src/Documentation/smatch.txt
@@ -0,0 +1,77 @@
+Smatch
+
+1.  Building Smatch
+2.  Using Smatch
+3.  Smatch vs Sparse
+
+
+Section 1:  Building Smatch
+---------------------------
+
+Smatch requires sqlite3.  It requires the binaries and the C, Perl and
+Python libraries for sqlite3.
+
+apt-get install sqlite3 libsqlite3-dev libdbd-sqlite3-perl
+
+Smatch is easy to build.  Just type `make`.  There isn't an install process
+right now so just run it from the build directory.
+
+
+Section 2:  Using Smatch
+------------------------
+
+Smatch can be used with a cross function database. It's not mandatory to
+build the database but it's a useful thing to do.  Building the database
+for the kernel takes 2-3 hours on my computer.  For the kernel you build
+the database with:
+
+	cd ~/path/to/kernel_dir
+	~/path/to/smatch_dir/smatch_scripts/build_kernel_data.sh
+
+For projects other than the kernel you run Smatch with the options
+"--call-tree --info --param-mapper --spammy" and finish building the
+database by running the script:
+
+	~/progs/smatch/devel/smatch_data/db/create_db.sh
+
+Each time you rebuild the cross function database it becomes more accurate. I
+normally rebuild the database every morning.
+
+If you are running Smatch over the whole kernel you can use the following
+command:
+
+	~/progs/smatch/devel/smatch_scripts/test_kernel.sh
+
+The test_kernel.sh script will create a .c.smatch file for every file it tests
+and a combined smatch_warns.txt file with all the warnings.
+
+If you are running Smatch just over one kernel file:
+
+	~/progs/smatch/devel/smatch_scripts/kchecker drivers/whatever/file.c
+
+You can also build a directory like this:
+
+	~/progs/smatch/devel/smatch_scripts/kchecker drivers/whatever/
+
+The kchecker script prints its warnings to stdout.
+
+If you are building something else (which is not the Linux kernel) then use
+something like:
+
+	make CHECK="~/progs/smatch/devel/smatch --full-path" \
+		CC=~/progs/smatch/devel/smatch/cgcc | tee smatch_warns.txt
+
+The makefile has to let people set the CC with an environment variable for that
+to work, of course.
+
+
+Section 3:  Smatch vs Sparse
+----------------------------
+
+Smatch uses Sparse as a C parser.  I have made a few hacks to Sparse so I
+have to distribute the two together.  Sparse is released under the MIT license
+and Smatch is GPLv2+.  If you make changes to Sparse please send those to the
+Sparse mailing list linux-sparse@vger.kernel.org and I will pick them up from
+there.  Partly I do that for licensing reasons because I don't want to pull GPL
+changes into the Sparse code I re-distribute.
+
diff --git a/usr/src/tools/smatch/src/Documentation/sparse-README.txt b/usr/src/tools/smatch/src/Documentation/sparse-README.txt
new file mode 100644
index 0000000000..144d27459d
--- /dev/null
+++ b/usr/src/tools/smatch/src/Documentation/sparse-README.txt
@@ -0,0 +1,71 @@
+
+  sparse (spärs), adj,., spars-er, spars-est.
+	1. thinly scattered or distributed; "a sparse population"
+	2. thin; not thick or dense: "sparse hair"
+	3. scanty; meager.
+	4. semantic parse
+  	[ from Latin: spars(us) scattered, past participle of
+	  spargere 'to sparge' ]
+
+	Antonym: abundant
+
+Sparse is a semantic parser of source files: it's neither a compiler
+(although it could be used as a front-end for one) nor is it a
+preprocessor (although it contains as a part of it a preprocessing
+phase). 
+
+It is meant to be a small - and simple - library.  Scanty and meager,
+and partly because of that easy to use.  It has one mission in life:
+create a semantic parse tree for some arbitrary user for further
+analysis.  It's not a tokenizer, nor is it some generic context-free
+parser.  In fact, context (semantics) is what it's all about - figuring
+out not just what the grouping of tokens are, but what the _types_ are
+that the grouping implies.
+
+And no, it doesn't use lex and yacc (or flex and bison).  In my personal
+opinion, the result of using lex/yacc tends to end up just having to
+fight the assumptions the tools make. 
+
+The parsing is done in five phases:
+
+ - full-file tokenization
+ - pre-processing (which can cause another tokenization phase of another
+   file)
+ - semantic parsing.
+ - lazy type evaluation
+ - inline function expansion and tree simplification
+
+Note the "full file" part. Partly for efficiency, but mostly for ease of
+use, there are no "partial results". The library completely parses one
+whole source file, and builds up the _complete_ parse tree in memory.
+
+Also note the "lazy" in the type evaluation.  The semantic parsing
+itself will know which symbols are typedefines (required for parsing C
+correctly), but it will not have calculated what the details of the
+different types are.  That will be done only on demand, as the back-end
+requires the information. 
+
+This means that a user of the library will literally just need to do
+
+  struct string_list *filelist = NULL;
+  char *file;
+
+  action(sparse_initialize(argc, argv, filelist));
+
+  FOR_EACH_PTR_NOTAG(filelist, file) {
+    action(sparse(file));
+  } END_FOR_EACH_PTR_NOTAG(file);
+
+and he is now done - having a full C parse of the file he opened.  The
+library doesn't need any more setup, and once done does not impose any
+more requirements.  The user is free to do whatever he wants with the
+parse tree that got built up, and needs not worry about the library ever
+again.  There is no extra state, there are no parser callbacks, there is
+only the parse tree that is described by the header files. The action
+funtion takes a pointer to a symbol_list and does whatever it likes with it.
+
+The library also contains (as an example user) a few clients that do the
+preprocessing, parsing and type evaluation and just print out the
+results.  These clients were done to verify and debug the library, and
+also as trivial examples of what you can do with the parse tree once it
+is formed, so that users can see how the tree is organized. 
diff --git a/usr/src/tools/smatch/src/Documentation/sparse.txt b/usr/src/tools/smatch/src/Documentation/sparse.txt
new file mode 100644
index 0000000000..383376c04f
--- /dev/null
+++ b/usr/src/tools/smatch/src/Documentation/sparse.txt
@@ -0,0 +1,45 @@
+Sparse
+~~~~~~
+
+__nocast vs __bitwise:
+
+__nocast warns about explicit or implicit casting to different types.
+
+HOWEVER, it doesn't consider two 32-bit integers to be different
+types, so a __nocast 'int' type may be returned as a regular 'int'
+type and then the __nocast is lost.
+
+So "__nocast" on integer types is usually not that powerful. It just
+gets lost too easily. It's more useful for things like pointers. It
+also doesn't warn about the mixing: you can add integers to __nocast
+integer types, and it's not really considered anything wrong.
+
+__bitwise ends up being a "stronger integer separation". That one
+doesn't allow you to mix with non-bitwise integers, so now it's much
+harder to lose the type by mistake.
+
+So the basic rule is:
+
+ - "__nocast" on its own tends to be more useful for *big* integers
+that still need to act like integers, but you want to make it much
+less likely that they get truncated by mistake. So a 64-bit integer
+that you don't want to mistakenly/silently be returned as "int", for
+example. But they mix well with random integer types, so you can add
+to them etc without using anything special. However, that mixing also
+means that the __nocast really gets lost fairly easily.
+
+ - "__bitwise" is for *unique types* that cannot be mixed with other
+types, and that you'd never want to just use as a random integer (the
+integer 0 is special, though, and gets silently accepted iirc - it's
+kind of like "NULL" for pointers). So "gfp_t" or the "safe endianness"
+types would be __bitwise: you can only operate on them by doing
+specific operations that know about *that* particular type.
+
+Generally, you want __bitwise if you are looking for type safety.
+"__nocast" really is pretty weak.
+
+Reference:
+
+* Linus' e-mail about __nocast vs __bitwise:
+
+  http://marc.info/?l=linux-mm&m=133245421127324&w=2
diff --git a/usr/src/tools/smatch/src/Documentation/submitting-patches.md b/usr/src/tools/smatch/src/Documentation/submitting-patches.md
new file mode 100644
index 0000000000..fb176ce51d
--- /dev/null
+++ b/usr/src/tools/smatch/src/Documentation/submitting-patches.md
@@ -0,0 +1,21 @@
+Submitting patches: the sparse version
+======================================
+
+Sparse uses a patch submit process similar to the Linux Kernel
+[Submitting Patches](https://www.kernel.org/doc/html/v4.12/process/submitting-patches.html)
+
+This document mostly focuses on the parts that might be different from the Linux
+Kernel submitting process.
+
+1. Git clone a sparse repository:
+
+        git clone git://git.kernel.org/pub/scm/devel/sparse/sparse.git
+
+2. [Coding Style](https://www.kernel.org/doc/html/v4.12/process/coding-style.html) remains the same.
+
+3. Sign off the patch.
+
+   The usage of the Signed-off-by tag is the same as [Linux Kernel Sign your work](https://www.kernel.org/doc/html/v4.12/process/submitting-patches.html#sign-your-work-the-developer-s-certificate-of-origin).
+
+   Notice that sparse uses the MIT License.
+
diff --git a/usr/src/tools/smatch/src/Documentation/test-suite b/usr/src/tools/smatch/src/Documentation/test-suite
new file mode 100644
index 0000000000..b0c8f134b3
--- /dev/null
+++ b/usr/src/tools/smatch/src/Documentation/test-suite
@@ -0,0 +1,136 @@
+
+
+	Sparse test suite
+	~~~~~~~~~~~~~~~~~
+
+Sparse has a number of test cases in its validation directory. The test-suite
+script aims at making automated checking of these tests possible. It works by
+embedding tags in C comments in the test cases.
+
+check-name: (mandatory)
+	Name of the test.
+
+check-description: (optional)
+	A description of what the test checks.
+
+check-command: (optional)
+	There are different kinds of tests. Some can validate the sparse
+	preprocessor, while others will use sparse, cgcc, or even other backends
+	of the library. check-command allows you to give a custom command to
+	run the test-case.
+	The '$file' string is special. It will be expanded to the file name at
+	run time.
+	It defaults to "sparse $file".
+
+check-exit-value: (optional)
+	The expected exit value of check-command. It defaults to 0.
+
+check-timeout: (optional)
+	The maximum expected duration of check-command, in seconds.
+	It defaults to 1.
+
+check-output-start / check-output-end (optional)
+	The expected output (stdout and stderr) of check-command lies between
+	those two tags. It defaults to no output.
+
+check-output-ignore / check-error-ignore (optional)
+	Don't check the expected output (stdout or stderr) of check-command
+	(useful when this output is not comparable or if you're only interested
+	in the exit value).
+	By default this check is done.
+
+check-known-to-fail (optional)
+	Mark the test as being known to fail.
+
+check-output-contains: <pattern> (optional)
+	Check that the output (stdout) contains the given pattern.
+	Several such tags can be given, in which case the output
+	must contains all the patterns.
+
+check-output-excludes: <pattern> (optional)
+	Similar than the above one, but with opposite logic.
+	Check that the output (stdout) doesn't contain the given pattern.
+	Several such tags can be given, in which case the output
+	must contains none of the patterns.
+
+check-output-pattern-<nbr>-times: <pattern> (optional)
+	Similar to the contains/excludes above, but with full control
+	of the number of times the pattern should occur in the output.
+
+	Using test-suite
+	~~~~~~~~~~~~~~~~
+
+The test-suite script is called through the check target of the Makefile. It
+will try to check every test case it finds (find validation -name '*.c').
+
+It can be called to check a single test with:
+$ cd validation
+$ ./test-suite single preprocessor/preprocessor1.c
+     TEST     Preprocessor #1 (preprocessor/preprocessor1.c)
+preprocessor/preprocessor1.c passed !
+
+
+	Writing a test
+	~~~~~~~~~~~~~~
+
+test-suite comes with a format command to make a test easier to write:
+
+	test-suite format file [name [cmd]]
+
+name:
+	check-name value. If no name is provided, it defaults to the file name.
+cmd:
+	check-command value. If no cmd is provided, it defaults to
+	"sparse $file".
+
+The output of the test-suite format command can be redirected into the
+test case to create a test-suite formatted file.
+
+$ ./test-suite format bad-assignment.c Assignment >> bad-assignment.c
+$ cat !$
+cat bad-assignment.c
+/*
+ * check-name: bad assignment
+ *
+ * check-command: sparse $file
+ * check-exit-value: 1
+ *
+ * check-output-start
+bad-assignment.c:3:6: error: Expected ; at end of statement
+bad-assignment.c:3:6: error: got \
+ * check-output-end
+ */
+
+You can define the check-command you want to use for the test. $file will be
+extended to the file name at run time.
+
+$ ./test-suite format validation/preprocessor2.c "Preprocessor #2" \
+		"sparse -E \$file" >> validation/preprocessor2.c
+$ cat !$
+cat validation/preprocessor2.c
+/*
+ * This one we happen to get right.
+ *
+ * It should result in a simple
+ *
+ *	a + b
+ *
+ * for a proper preprocessor.
+ */
+#define TWO a, b
+
+#define UNARY(x) BINARY(x)
+#define BINARY(x, y) x + y
+
+UNARY(TWO)
+/*
+ * check-name: Preprocessor #2
+ *
+ * check-command: sparse -E $file
+ * check-exit-value: 0
+ *
+ * check-output-start
+
+a + b
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/FAQ b/usr/src/tools/smatch/src/FAQ
new file mode 100644
index 0000000000..8ef6e84f6a
--- /dev/null
+++ b/usr/src/tools/smatch/src/FAQ
@@ -0,0 +1,74 @@
+	FAQ - Why sparse?
+
+Q.  Why not just use gcc?
+
+A.  Gcc is big, complex, and the gcc maintainers are not interested in
+    other uses of the gcc front-end.  In fact, gcc has explicitly
+    resisted splitting up the front and back ends and having some common
+    intermediate language because of religious license issues - you can
+    have multiple front ends and back ends, but they all have to be part
+    of gcc and licensed under the GPL. 
+
+    This all (in my opinion) makes gcc development harder than it should
+    be, and makes the end result very ungainly.  With "sparse", the
+    front-end is very explicitly separated into its own independent
+    project, and is totally independent from the users.  I don't want to
+    know what you do in the back-end, because I don't think I _should_
+    know or care. 
+
+
+Q.  Why not GPL?
+
+A.  See the previous question: I personally think that the front end
+    must be a totally separate project from the back end: any other
+    approach just leads to insanity.  However, at the same time clearly
+    we cannot write intermediate files etc crud (since then the back end
+    would have to re-parse the whole thing and would have to have its
+    own front end and just do a lot of things that do not make any sense
+    from a technical standpoint).
+
+    I like the GPL, but as rms says, "Linus is just an engineer". I
+    refuse to use a license if that license causes bad engineering
+    decisions.  I want the front-end to be considered a separate
+    project, yet the GPL considers the required linking to make the
+    combined thing a derived work. Which is against the whole point
+    of 'sparse'.
+
+    I'm not interested in code generation. I'm not interested in what
+    other people do with their back-ends.  I _am_ interested in making a
+    good front-end, and "good" means that people find it usable. And
+    they shouldn't be scared away by politics or licenses. If they want
+    to make their back-end be BSD/MIT licensed, that's great. And if
+    they want to have a proprietary back-end, that's ok by me too. It's
+    their loss, not mine.
+
+
+Q.  Does it really parse C?
+
+A.  Yeah, well...  It parses a fairly complete subset of "extended C" as
+    defined by gcc.  HOWEVER, since I don't believe in K&R syntax for
+    function declarations or in giving automatic integer types, it
+    doesn't do that.  If you don't give types to your variables, they
+    won't have any types, and you can't use them.
+
+    Similarly, it will be very unhappy about undeclared functions,
+    rather than just assuming they have type "int". 
+
+    Note that a large rationale for me doing this project is for type
+    following, which to some degree explains why the thing is type-anal
+    and refuses to touch the old-style pre-ANSI non-typed (or weakly
+    typed) constructs. Maybe somebody else who is working on projects
+    where pre-ANSI C makes sense might be more inclined to care about
+    ancient C.  It's open source, after all. Go wild.
+
+
+Q.  What other sparse resources are available?
+
+A.  Wiki: http://sparse.wiki.kernel.org/index.php/Main_Page
+
+    Mailing list: linux-sparse@vger.kernel.org
+    See http://vger.kernel.org/vger-lists.html#linux-sparse for subscription
+    instructions and links to archives
+
+    Git repo: git://git.kernel.org/pub/scm/devel/sparse/sparse.git
+    gitweb: http://git.kernel.org/?p=devel/sparse/sparse.git
diff --git a/usr/src/tools/smatch/src/GPL-2 b/usr/src/tools/smatch/src/GPL-2
new file mode 100644
index 0000000000..d159169d10
--- /dev/null
+++ b/usr/src/tools/smatch/src/GPL-2
@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/usr/src/tools/smatch/src/LICENSE b/usr/src/tools/smatch/src/LICENSE
new file mode 100644
index 0000000000..b29873c2d1
--- /dev/null
+++ b/usr/src/tools/smatch/src/LICENSE
@@ -0,0 +1,70 @@
+Smatch is released under the GPLv2+ license however Smatch includes the Sparse
+source as well which is licensed under the MIT license and cwchash which is
+licensed under the three clause BSD license and avl.[ch] which are MIT licensed.
+
+The line between which files are a part of Sparse and which are a part of Smatch
+is normally pretty clear.  The one thing I will clarify is that there are some
+modifications to Sparse files in the Smatch repository which have not been
+pushed to the Sparse repository.  These are released under the MIT license.  The
+token_store.c file is a Sparse feature and thus released under the MIT license
+despite that it has not been pushed to the Sparse repository.
+
+I will not accept additional Sparse features except under the MIT license.
+
+------  Smatch
+
+License: GPLv2+
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+See GPL-2, or <http://www.gnu.org/copyleft/gpl.txt> for the terms of the latest
+version of the GNU General Public License.
+
+------  Sparse
+
+The 'sparse' C parser front-end library is copyrighted by Transmeta Corp
+and other authors and licensed under the "MIT License" as
+obtained from www.opensource.org (and included here-in for easy
+reference).
+
+[ This copy of the license is the flat-text version of original,
+  available in its full glory at
+
+	 http://opensource.org/licenses/MIT
+
+  please refer to there for the authoritative and slightly more
+  pretty-printed version ]
+
+------
+
+			The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/usr/src/tools/smatch/src/Makefile b/usr/src/tools/smatch/src/Makefile
new file mode 100644
index 0000000000..d77fd2b2da
--- /dev/null
+++ b/usr/src/tools/smatch/src/Makefile
@@ -0,0 +1,318 @@
+VERSION=0.5.1
+
+# Generating file version.h if current version has changed
+SPARSE_VERSION:=$(shell git describe 2>/dev/null || echo '$(VERSION)')
+VERSION_H := $(shell cat version.h 2>/dev/null)
+ifneq ($(lastword $(VERSION_H)),"$(SPARSE_VERSION)")
+$(info $(shell echo '     GEN      'version.h))
+$(shell echo '#define SPARSE_VERSION "$(SPARSE_VERSION)"' > version.h)
+endif
+
+OS = linux
+
+ifeq ($(CC),"")
+CC = gcc
+endif
+
+CFLAGS += -O2 -finline-functions -fno-strict-aliasing -g
+CFLAGS += -Wall -Wwrite-strings -Wno-switch
+LDFLAGS += -g -lm -lsqlite3 -lssl -lcrypto
+LD = gcc
+AR = ar
+PKG_CONFIG = pkg-config
+COMMON_CFLAGS = -O2 -finline-functions -fno-strict-aliasing -g
+COMMON_CFLAGS += -Wall -Wwrite-strings
+
+ALL_CFLAGS = $(COMMON_CFLAGS) $(PKG_CFLAGS) $(CFLAGS)
+#
+# For debugging, put this in local.mk:
+#
+#     CFLAGS += -O0 -DDEBUG -g3 -gdwarf-2
+#
+
+HAVE_LIBXML:=$(shell $(PKG_CONFIG) --exists libxml-2.0 2>/dev/null && echo 'yes')
+HAVE_GCC_DEP:=$(shell touch .gcc-test.c && 				\
+		$(CC) -c -Wp,-MD,.gcc-test.d .gcc-test.c 2>/dev/null && \
+		echo 'yes'; rm -f .gcc-test.d .gcc-test.o .gcc-test.c)
+
+GTK_VERSION:=3.0
+HAVE_GTK:=$(shell $(PKG_CONFIG) --exists gtk+-$(GTK_VERSION) 2>/dev/null && echo 'yes')
+ifneq ($(HAVE_GTK),yes)
+	GTK_VERSION:=2.0
+	HAVE_GTK:=$(shell $(PKG_CONFIG) --exists gtk+-$(GTK_VERSION) 2>/dev/null && echo 'yes')
+endif
+
+LLVM_CONFIG:=llvm-config
+HAVE_LLVM:=$(shell $(LLVM_CONFIG) --version >/dev/null 2>&1 && echo 'yes')
+
+GCC_BASE := $(shell $(CC) --print-file-name=)
+COMMON_CFLAGS += -DGCC_BASE=\"$(GCC_BASE)\"
+
+MULTIARCH_TRIPLET := $(shell $(CC) -print-multiarch 2>/dev/null)
+COMMON_CFLAGS += -DMULTIARCH_TRIPLET=\"$(MULTIARCH_TRIPLET)\"
+
+ifeq ($(HAVE_GCC_DEP),yes)
+COMMON_CFLAGS += -Wp,-MD,$(@D)/.$(@F).d
+endif
+
+DESTDIR=
+INSTALL_PREFIX ?=$(HOME)
+BINDIR=$(INSTALL_PREFIX)/bin
+LIBDIR=$(INSTALL_PREFIX)/lib
+MANDIR=$(INSTALL_PREFIX)/share/man
+MAN1DIR=$(MANDIR)/man1
+INCLUDEDIR=$(INSTALL_PREFIX)/include
+PKGCONFIGDIR=$(LIBDIR)/pkgconfig
+SMATCHDATADIR=$(INSTALL_PREFIX)/share/smatch
+
+SMATCH_FILES=smatch_flow.o smatch_conditions.o smatch_slist.o smatch_states.o \
+	smatch_helper.o smatch_type.o smatch_hooks.o smatch_function_hooks.o \
+	smatch_modification_hooks.o smatch_extra.o smatch_estate.o smatch_math.o \
+	smatch_sval.o smatch_ranges.o smatch_implied.o smatch_ignore.o smatch_project.o \
+	smatch_var_sym.o smatch_tracker.o smatch_files.o smatch_expression_stacks.o \
+	smatch_equiv.o smatch_buf_size.o smatch_strlen.o smatch_capped.o smatch_db.o \
+	smatch_expressions.o smatch_returns.o smatch_parse_call_math.o \
+	smatch_param_limit.o smatch_param_filter.o \
+	smatch_param_set.o smatch_comparison.o smatch_param_compare_limit.o smatch_local_values.o \
+	smatch_function_ptrs.o smatch_annotate.o smatch_string_list.o \
+	smatch_param_cleared.o smatch_start_states.o \
+	smatch_recurse.o smatch_data_source.o smatch_type_val.o \
+	smatch_common_functions.o smatch_struct_assignment.o \
+	smatch_unknown_value.o smatch_stored_conditions.o avl.o \
+	smatch_function_info.o smatch_links.o smatch_auto_copy.o \
+	smatch_type_links.o smatch_untracked_param.o smatch_impossible.o \
+	smatch_strings.o smatch_param_used.o smatch_container_of.o smatch_address.o \
+	smatch_buf_comparison.o smatch_real_absolute.o smatch_scope.o \
+	smatch_imaginary_absolute.o smatch_parameter_names.o \
+	smatch_return_to_param.o smatch_passes_array_size.o \
+	smatch_constraints.o smatch_constraints_required.o \
+	smatch_fn_arg_link.o smatch_about_fn_ptr_arg.o smatch_mtag.o \
+	smatch_mtag_map.o smatch_mtag_data.o \
+	smatch_param_to_mtag_data.o smatch_mem_tracker.o smatch_array_values.o \
+	smatch_nul_terminator.o smatch_assigned_expr.o smatch_kernel_user_data.o \
+	smatch_statement_count.o
+
+SMATCH_CHECKS=$(shell ls check_*.c | sed -e 's/\.c/.o/')
+SMATCH_DATA=smatch_data/kernel.allocation_funcs \
+	smatch_data/kernel.frees_argument smatch_data/kernel.puts_argument \
+	smatch_data/kernel.dev_queue_xmit smatch_data/kernel.returns_err_ptr \
+	smatch_data/kernel.dma_funcs smatch_data/kernel.returns_held_funcs \
+	smatch_data/kernel.no_return_funcs
+
+SMATCH_SCRIPTS=smatch_scripts/add_gfp_to_allocations.sh \
+	smatch_scripts/build_kernel_data.sh \
+	smatch_scripts/call_tree.pl smatch_scripts/filter_kernel_deref_check.sh \
+	smatch_scripts/find_expanded_holes.pl smatch_scripts/find_null_params.sh \
+	smatch_scripts/follow_params.pl smatch_scripts/gen_allocation_list.sh \
+	smatch_scripts/gen_bit_shifters.sh smatch_scripts/gen_dma_funcs.sh \
+	smatch_scripts/generisize.pl smatch_scripts/gen_err_ptr_list.sh \
+	smatch_scripts/gen_expects_err_ptr.sh smatch_scripts/gen_frees_list.sh \
+	smatch_scripts/gen_gfp_flags.sh smatch_scripts/gen_no_return_funcs.sh \
+	smatch_scripts/gen_puts_list.sh smatch_scripts/gen_returns_held.sh \
+	smatch_scripts/gen_rosenberg_funcs.sh smatch_scripts/gen_sizeof_param.sh \
+	smatch_scripts/gen_unwind_functions.sh smatch_scripts/kchecker \
+	smatch_scripts/kpatch.sh smatch_scripts/new_bugs.sh \
+	smatch_scripts/show_errs.sh smatch_scripts/show_ifs.sh \
+	smatch_scripts/show_unreachable.sh smatch_scripts/strip_whitespace.pl \
+	smatch_scripts/summarize_errs.sh smatch_scripts/test_kernel.sh \
+	smatch_scripts/trace_params.pl smatch_scripts/unlocked_paths.pl \
+	smatch_scripts/whitespace_only.sh smatch_scripts/wine_checker.sh \
+
+PROGRAMS=test-lexing test-parsing obfuscate compile graph sparse \
+	 test-linearize example test-unssa test-dissect ctags
+INST_PROGRAMS=smatch cgcc
+
+INST_MAN1=sparse.1 cgcc.1
+
+ifeq ($(HAVE_LIBXML),yes)
+PROGRAMS+=c2xml
+INST_PROGRAMS+=c2xml
+c2xml_EXTRA_OBJS = `$(PKG_CONFIG) --libs libxml-2.0`
+LIBXML_CFLAGS := $(shell $(PKG_CONFIG) --cflags libxml-2.0)
+else
+$(warning Your system does not have libxml, disabling c2xml)
+endif
+
+ifeq ($(HAVE_GTK),yes)
+GTK_CFLAGS := $(shell $(PKG_CONFIG) --cflags gtk+-$(GTK_VERSION))
+GTK_LIBS := $(shell $(PKG_CONFIG) --libs gtk+-$(GTK_VERSION))
+PROGRAMS += test-inspect
+INST_PROGRAMS += test-inspect
+test-inspect_EXTRA_DEPS := ast-model.o ast-view.o ast-inspect.o
+test-inspect_OBJS := test-inspect.o $(test-inspect_EXTRA_DEPS)
+$(test-inspect_OBJS) $(test-inspect_OBJS:.o=.sc): PKG_CFLAGS += $(GTK_CFLAGS)
+test-inspect_EXTRA_OBJS := $(GTK_LIBS)
+else
+$(warning Your system does not have gtk3/gtk2, disabling test-inspect)
+endif
+
+ifeq ($(HAVE_LLVM),yes)
+ifeq ($(shell uname -m | grep -q '\(i386\|x86\)' && echo ok),ok)
+LLVM_VERSION:=$(shell $(LLVM_CONFIG) --version)
+ifeq ($(shell expr "$(LLVM_VERSION)" : '[3-9]\.'),2)
+LLVM_PROGS := sparse-llvm
+$(LLVM_PROGS): LD := g++
+LLVM_LDFLAGS := $(shell $(LLVM_CONFIG) --ldflags)
+LLVM_CFLAGS := $(shell $(LLVM_CONFIG) --cflags | sed -e "s/-DNDEBUG//g" | sed -e "s/-pedantic//g")
+LLVM_LIBS := $(shell $(LLVM_CONFIG) --libs)
+LLVM_LIBS += $(shell $(LLVM_CONFIG) --system-libs 2>/dev/null)
+PROGRAMS += $(LLVM_PROGS)
+INST_PROGRAMS += sparse-llvm sparsec
+sparse-llvm.o sparse-llvm.sc: PKG_CFLAGS += $(LLVM_CFLAGS)
+sparse-llvm_EXTRA_OBJS := $(LLVM_LIBS) $(LLVM_LDFLAGS)
+else
+$(warning LLVM 3.0 or later required. Your system has version $(LLVM_VERSION) installed.)
+endif
+else
+$(warning sparse-llvm disabled on $(shell uname -m))
+endif
+else
+$(warning Your system does not have llvm, disabling sparse-llvm)
+endif
+
+LIB_H=    token.h parse.h lib.h symbol.h scope.h expression.h target.h \
+	  linearize.h bitmap.h ident-list.h compat.h flow.h allocate.h \
+	  storage.h ptrlist.h dissect.h
+
+LIB_OBJS= target.o parse.o tokenize.o pre-process.o symbol.o lib.o scope.o \
+	  expression.o show-parse.o evaluate.o expand.o inline.o linearize.o \
+	  char.o sort.o allocate.o compat-$(OS).o ptrlist.o \
+	  builtin.o \
+	  stats.o \
+	  flow.o cse.o simplify.o memops.o liveness.o storage.o unssa.o \
+	  dissect.o \
+	  macro_table.o token_store.o cwchash/hashtable.o
+
+LIB_FILE= libsparse.a
+SLIB_FILE= libsparse.so
+
+# If you add $(SLIB_FILE) to this, you also need to add -fpic to BASIC_CFLAGS above.
+# Doing so incurs a noticeable performance hit, and Sparse does not have a
+# stable shared library interface, so this does not occur by default.  If you
+# really want a shared library, you may want to build Sparse twice: once
+# without -fpic to get all the Sparse tools, and again with -fpic to get the
+# shared library.
+LIBS=$(LIB_FILE)
+
+#
+# Pretty print
+#
+V	      = @
+Q	      = $(V:1=)
+QUIET_CC      = $(Q:@=@echo    '     CC       '$@;)
+QUIET_CHECK   = $(Q:@=@echo    '     CHECK    '$<;)
+QUIET_AR      = $(Q:@=@echo    '     AR       '$@;)
+QUIET_GEN     = $(Q:@=@echo    '     GEN      '$@;)
+QUIET_LINK    = $(Q:@=@echo    '     LINK     '$@;)
+# We rely on the -v switch of install to print 'file -> $install_dir/file'
+QUIET_INST_SH = $(Q:@=echo -n  '     INSTALL  ';)
+QUIET_INST    = $(Q:@=@echo -n '     INSTALL  ';)
+
+define INSTALL_EXEC
+	$(QUIET_INST)install -v $1 $(DESTDIR)$2/$1 || exit 1;
+
+endef
+
+define INSTALL_FILE
+	$(QUIET_INST)install -v -m 644 $1 $(DESTDIR)$2/$1 || exit 1;
+
+endef
+
+SED_PC_CMD = 's|@version@|$(VERSION)|g;		\
+	      s|@prefix@|$(INSTALL_PREFIX)|g;		\
+	      s|@libdir@|$(LIBDIR)|g;		\
+	      s|@includedir@|$(INCLUDEDIR)|g'
+
+
+
+# Allow users to override build settings without dirtying their trees
+-include local.mk
+
+
+all: $(PROGRAMS) sparse.pc smatch
+
+all-installable: $(INST_PROGRAMS) $(LIBS) $(LIB_H) sparse.pc
+
+install: all-installable
+	$(Q)install -d $(DESTDIR)$(BINDIR)
+	$(Q)install -d $(DESTDIR)$(LIBDIR)
+	$(Q)install -d $(DESTDIR)$(MAN1DIR)
+	$(Q)install -d $(DESTDIR)$(INCLUDEDIR)/sparse
+	$(Q)install -d $(DESTDIR)$(PKGCONFIGDIR)
+	$(Q)install -d $(DESTDIR)$(SMATCHDATADIR)/smatch_data
+	$(Q)install -d $(DESTDIR)$(SMATCHDATADIR)/smatch_scripts
+	$(foreach f,$(INST_PROGRAMS),$(call INSTALL_EXEC,$f,$(BINDIR)))
+	$(foreach f,$(INST_MAN1),$(call INSTALL_FILE,$f,$(MAN1DIR)))
+	$(foreach f,$(LIBS),$(call INSTALL_FILE,$f,$(LIBDIR)))
+	$(foreach f,$(LIB_H),$(call INSTALL_FILE,$f,$(INCLUDEDIR)/sparse))
+	$(call INSTALL_FILE,sparse.pc,$(PKGCONFIGDIR))
+	$(foreach f,$(SMATCH_DATA),$(call INSTALL_FILE,$f,$(SMATCHDATADIR)))
+	$(foreach f,$(SMATCH_SCRIPTS),$(call INSTALL_EXEC,$f,$(SMATCHDATADIR)))
+
+sparse.pc: sparse.pc.in
+	$(QUIET_GEN)sed $(SED_PC_CMD) sparse.pc.in > sparse.pc
+
+
+compile_EXTRA_DEPS = compile-i386.o
+
+$(foreach p,$(PROGRAMS),$(eval $(p): $($(p)_EXTRA_DEPS) $(LIBS)))
+$(PROGRAMS): % : %.o 
+	$(QUIET_LINK)$(LD) -o $@ $^ $($@_EXTRA_OBJS) $(LDFLAGS)
+
+smatch: smatch.o $(SMATCH_FILES) $(SMATCH_CHECKS) $(LIBS) 
+	$(QUIET_LINK)$(LD) -o $@ $< $(SMATCH_FILES) $(SMATCH_CHECKS) $(LIBS) $(LDFLAGS)
+
+$(LIB_FILE): $(LIB_OBJS)
+	$(QUIET_AR)$(AR) rcs $@ $(LIB_OBJS)
+
+$(SLIB_FILE): $(LIB_OBJS)
+	$(QUIET_LINK)$(CC) -Wl,-soname,$@ -shared -o $@ $(LIB_OBJS) $(LDFLAGS)
+
+check_list_local.h:
+	touch check_list_local.h
+
+smatch.o: smatch.c $(LIB_H) smatch.h check_list.h check_list_local.h
+	$(CC) $(CFLAGS) -c smatch.c -DSMATCHDATADIR='"$(SMATCHDATADIR)"'
+$(SMATCH_CHECKS): smatch.h smatch_slist.h smatch_extra.h avl.h
+DEP_FILES := $(wildcard .*.o.d)
+
+ifneq ($(DEP_FILES),)
+include $(DEP_FILES)
+endif
+
+c2xml.o c2xml.sc: PKG_CFLAGS += $(LIBXML_CFLAGS)
+
+pre-process.sc: CHECKER_FLAGS += -Wno-vla
+
+%.o: %.c $(LIB_H)
+	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
+
+%.sc: %.c sparse
+	$(QUIET_CHECK) $(CHECKER) $(CHECKER_FLAGS) -c $(ALL_CFLAGS) $<
+
+ALL_OBJS :=  $(LIB_OBJS) $(foreach p,$(PROGRAMS),$(p).o $($(p)_EXTRA_DEPS))
+selfcheck: $(ALL_OBJS:.o=.sc)
+
+
+clean: clean-check
+	rm -f *.[oa] .*.d *.so cwchash/*.o cwchash/.*.d cwchash/tester \
+		$(PROGRAMS) $(SLIB_FILE) pre-process.h sparse.pc version.h
+
+dist:
+	@if test "$(SPARSE_VERSION)" != "v$(VERSION)" ; then \
+		echo 'Update VERSION in the Makefile before running "make dist".' ; \
+		exit 1 ; \
+	fi
+	git archive --format=tar --prefix=sparse-$(VERSION)/ HEAD^{tree} | gzip -9 > sparse-$(VERSION).tar.gz
+
+check: all
+	$(Q)cd validation && ./test-suite
+
+clean-check:
+	find validation/ \( -name "*.c.output.expected" \
+	                 -o -name "*.c.output.got" \
+	                 -o -name "*.c.output.diff" \
+	                 -o -name "*.c.error.expected" \
+	                 -o -name "*.c.error.got" \
+	                 -o -name "*.c.error.diff" \
+	                 \) -exec rm {} \;
diff --git a/usr/src/tools/smatch/src/README b/usr/src/tools/smatch/src/README
new file mode 100644
index 0000000000..e350c6c997
--- /dev/null
+++ b/usr/src/tools/smatch/src/README
@@ -0,0 +1,3 @@
+There are some documents under the Documentation/ directory.
+
+For parsing implicit dependencies, see smatch_scripts/implicit_dependencies.
diff --git a/usr/src/tools/smatch/src/allocate.c b/usr/src/tools/smatch/src/allocate.c
new file mode 100644
index 0000000000..502095ef2e
--- /dev/null
+++ b/usr/src/tools/smatch/src/allocate.c
@@ -0,0 +1,153 @@
+/*
+ * allocate.c - simple space-efficient blob allocator.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Simple allocator for data that doesn't get partially free'd.
+ * The tokenizer and parser allocate a _lot_ of small data structures
+ * (often just two-three bytes for things like small integers),
+ * and since they all depend on each other you can't free them
+ * individually _anyway_. So do something that is very space-
+ * efficient: allocate larger "blobs", and give out individual
+ * small bits and pieces of it with no maintenance overhead.
+ */
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "compat.h"
+#include "token.h"
+#include "symbol.h"
+#include "scope.h"
+#include "expression.h"
+#include "linearize.h"
+
+void protect_allocations(struct allocator_struct *desc)
+{
+	desc->blobs = NULL;
+}
+
+void drop_all_allocations(struct allocator_struct *desc)
+{
+	struct allocation_blob *blob = desc->blobs;
+
+	desc->blobs = NULL;
+	desc->allocations = 0;
+	desc->total_bytes = 0;
+	desc->useful_bytes = 0;
+	desc->freelist = NULL;
+	while (blob) {
+		struct allocation_blob *next = blob->next;
+		blob_free(blob, desc->chunking);
+		blob = next;
+	}
+}
+
+void free_one_entry(struct allocator_struct *desc, void *entry)
+{
+	void **p = entry;
+	*p = desc->freelist;
+	desc->freelist = p;
+}
+
+void *allocate(struct allocator_struct *desc, unsigned int size)
+{
+	unsigned long alignment = desc->alignment;
+	struct allocation_blob *blob = desc->blobs;
+	void *retval;
+
+	/*
+	 * NOTE! The freelist only works with things that are
+	 *  (a) sufficiently aligned
+	 *  (b) use a constant size
+	 * Don't try to free allocators that don't follow
+	 * these rules.
+	 */
+	if (desc->freelist) {
+		void **p = desc->freelist;
+		retval = p;
+		desc->freelist = *p;
+		do {
+			*p = NULL;
+			p++;
+		} while ((size -= sizeof(void *)) > 0);
+		return retval;
+	}
+
+	desc->allocations++;
+	desc->useful_bytes += size;
+	size = (size + alignment - 1) & ~(alignment-1);
+	if (!blob || blob->left < size) {
+		unsigned int offset, chunking = desc->chunking;
+		struct allocation_blob *newblob = blob_alloc(chunking);
+		if (!newblob)
+			die("out of memory");
+		desc->total_bytes += chunking;
+		newblob->next = blob;
+		blob = newblob;
+		desc->blobs = newblob;
+		offset = offsetof(struct allocation_blob, data);
+		offset = (offset + alignment - 1) & ~(alignment-1);
+		blob->left = chunking - offset;
+		blob->offset = offset - offsetof(struct allocation_blob, data);
+	}
+	retval = blob->data + blob->offset;
+	blob->offset += size;
+	blob->left -= size;
+	return retval;
+}
+
+void show_allocations(struct allocator_struct *x)
+{
+	fprintf(stderr, "%s: %lu allocations, %lu bytes (%lu total bytes, "
+			"%6.2f%% usage, %6.2f average size)\n",
+		x->name, x->allocations, x->useful_bytes, x->total_bytes,
+		100 * (double) x->useful_bytes / x->total_bytes,
+		(double) x->useful_bytes / x->allocations);
+}
+
+void get_allocator_stats(struct allocator_struct *x, struct allocator_stats *s)
+{
+	s->name = x->name;
+	s->allocations = x->allocations;
+	s->useful_bytes = x->useful_bytes;
+	s->total_bytes = x->total_bytes;
+}
+
+ALLOCATOR(ident, "identifiers");
+ALLOCATOR(token, "tokens");
+ALLOCATOR(context, "contexts");
+ALLOCATOR(symbol, "symbols");
+ALLOCATOR(expression, "expressions");
+ALLOCATOR(statement, "statements");
+ALLOCATOR(string, "strings");
+ALLOCATOR(scope, "scopes");
+__DO_ALLOCATOR(void, 0, 1, "bytes", bytes);
+ALLOCATOR(basic_block, "basic_block");
+ALLOCATOR(entrypoint, "entrypoint");
+ALLOCATOR(instruction, "instruction");
+ALLOCATOR(multijmp, "multijmp");
+ALLOCATOR(pseudo, "pseudo");
+
+
diff --git a/usr/src/tools/smatch/src/allocate.h b/usr/src/tools/smatch/src/allocate.h
new file mode 100644
index 0000000000..32987b0800
--- /dev/null
+++ b/usr/src/tools/smatch/src/allocate.h
@@ -0,0 +1,94 @@
+#ifndef ALLOCATE_H
+#define ALLOCATE_H
+
+struct allocation_blob {
+	struct allocation_blob *next;
+	unsigned int left, offset;
+	unsigned char data[];
+};
+
+struct allocator_struct {
+	const char *name;
+	struct allocation_blob *blobs;
+	unsigned int alignment;
+	unsigned int chunking;
+	void *freelist;
+	/* statistics */
+	unsigned long allocations, total_bytes, useful_bytes;
+};
+
+struct allocator_stats {
+	const char *name;
+	unsigned int allocations;
+	unsigned long total_bytes, useful_bytes;
+};
+
+extern void protect_allocations(struct allocator_struct *desc);
+extern void drop_all_allocations(struct allocator_struct *desc);
+extern void *allocate(struct allocator_struct *desc, unsigned int size);
+extern void free_one_entry(struct allocator_struct *desc, void *entry);
+extern void show_allocations(struct allocator_struct *);
+extern void get_allocator_stats(struct allocator_struct *, struct allocator_stats *);
+extern void show_allocation_stats(void);
+
+#define __DECLARE_ALLOCATOR(type, x)		\
+	extern type *__alloc_##x(int);		\
+	extern void __free_##x(type *);		\
+	extern void show_##x##_alloc(void);	\
+	extern void get_##x##_stats(struct allocator_stats *);		\
+	extern void clear_##x##_alloc(void);	\
+	extern void protect_##x##_alloc(void);
+#define DECLARE_ALLOCATOR(x) __DECLARE_ALLOCATOR(struct x, x)
+
+#define __DO_ALLOCATOR(type, objsize, objalign, objname, x)	\
+	static struct allocator_struct x##_allocator = {	\
+		.name = objname,				\
+		.alignment = objalign,				\
+		.chunking = CHUNK };				\
+	type *__alloc_##x(int extra)				\
+	{							\
+		return allocate(&x##_allocator, objsize+extra);	\
+	}							\
+	void __free_##x(type *entry)				\
+	{							\
+		free_one_entry(&x##_allocator, entry);		\
+	}							\
+	void show_##x##_alloc(void)				\
+	{							\
+		show_allocations(&x##_allocator);		\
+	}							\
+	void get_##x##_stats(struct allocator_stats *s)		\
+	{							\
+		get_allocator_stats(&x##_allocator, s);		\
+	}							\
+	void clear_##x##_alloc(void)				\
+	{							\
+		drop_all_allocations(&x##_allocator);		\
+	}							\
+	void protect_##x##_alloc(void)				\
+	{							\
+		protect_allocations(&x##_allocator);		\
+	}
+
+#define __ALLOCATOR(t, n, x) 					\
+	__DO_ALLOCATOR(t, sizeof(t), __alignof__(t), n, x)
+
+#define ALLOCATOR(x, n) __ALLOCATOR(struct x, n, x)
+
+DECLARE_ALLOCATOR(ident);
+DECLARE_ALLOCATOR(token);
+DECLARE_ALLOCATOR(context);
+DECLARE_ALLOCATOR(symbol);
+DECLARE_ALLOCATOR(expression);
+DECLARE_ALLOCATOR(statement);
+DECLARE_ALLOCATOR(string);
+DECLARE_ALLOCATOR(scope);
+__DECLARE_ALLOCATOR(void, bytes);
+DECLARE_ALLOCATOR(basic_block);
+DECLARE_ALLOCATOR(entrypoint);
+DECLARE_ALLOCATOR(instruction);
+DECLARE_ALLOCATOR(multijmp);
+DECLARE_ALLOCATOR(pseudo);
+DECLARE_ALLOCATOR(attribute);
+
+#endif
diff --git a/usr/src/tools/smatch/src/ast-inspect.c b/usr/src/tools/smatch/src/ast-inspect.c
new file mode 100644
index 0000000000..24d4a4a650
--- /dev/null
+++ b/usr/src/tools/smatch/src/ast-inspect.c
@@ -0,0 +1,222 @@
+
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "ast-inspect.h"
+#include "expression.h"
+
+static inline void inspect_ptr_list(AstNode *node, const char *name, void (*inspect)(AstNode *))
+{
+	struct ptr_list *ptrlist = node->ptr;
+	void *ptr;
+	int i = 0;
+
+	node->text = g_strdup_printf("%s %s:", node->text, name);
+	FOR_EACH_PTR(ptrlist, ptr) {
+		char *index = g_strdup_printf("%d: ", i++);
+		ast_append_child(node, index, ptr, inspect);
+	} END_FOR_EACH_PTR(ptr);
+}
+
+
+static const char *statement_type_name(enum statement_type type)
+{
+	static const char *statement_type_name[] = {
+		[STMT_NONE] = "STMT_NONE",
+		[STMT_DECLARATION] = "STMT_DECLARATION",
+		[STMT_EXPRESSION] = "STMT_EXPRESSION",
+		[STMT_COMPOUND] = "STMT_COMPOUND",
+		[STMT_IF] = "STMT_IF",
+		[STMT_RETURN] = "STMT_RETURN",
+		[STMT_CASE] = "STMT_CASE",
+		[STMT_SWITCH] = "STMT_SWITCH",
+		[STMT_ITERATOR] = "STMT_ITERATOR",
+		[STMT_LABEL] = "STMT_LABEL",
+		[STMT_GOTO] = "STMT_GOTO",
+		[STMT_ASM] = "STMT_ASM",
+		[STMT_CONTEXT] = "STMT_CONTEXT",
+		[STMT_RANGE] = "STMT_RANGE",
+	};
+	return statement_type_name[type] ?: "UNKNOWN_STATEMENT_TYPE";
+}
+
+void inspect_statement(AstNode *node)
+{
+	struct statement *stmt = node->ptr;
+	node->text = g_strdup_printf("%s %s:", node->text, statement_type_name(stmt->type));
+	switch (stmt->type) {
+		case STMT_COMPOUND:
+			ast_append_child(node, "stmts:", stmt->stmts, inspect_statement_list);
+			break;
+		case STMT_EXPRESSION:
+			ast_append_child(node, "expression:", stmt->expression, inspect_expression);
+			break;
+		case STMT_IF:
+			ast_append_child(node, "conditional:", stmt->if_conditional, inspect_expression);
+			ast_append_child(node, "if_true:", stmt->if_true, inspect_statement);
+			ast_append_child(node, "if_false:", stmt->if_false, inspect_statement);
+			break;
+		case STMT_ITERATOR:
+			ast_append_child(node, "break:", stmt->iterator_break, inspect_symbol);
+			ast_append_child(node, "continue:", stmt->iterator_continue, inspect_symbol);
+			ast_append_child(node, "pre_statement:", stmt->iterator_pre_statement,
+					 inspect_statement);
+			ast_append_child(node, "statement:", stmt->iterator_statement,
+					 inspect_statement);
+			ast_append_child(node, "post_statement:", stmt->iterator_post_statement,
+					 inspect_statement);
+			break;
+
+		case STMT_SWITCH:
+			ast_append_child(node, "switch_expression:", stmt->switch_expression, inspect_expression);
+			ast_append_child(node, "switch_statement:", stmt->switch_statement, inspect_statement);
+			ast_append_child(node, "switch_break:", stmt->switch_break, inspect_symbol);
+			ast_append_child(node, "switch_case:", stmt->switch_case, inspect_symbol);
+			break;
+		case STMT_CASE:
+			ast_append_child(node, "case_expression:", stmt->case_expression, inspect_expression);
+			ast_append_child(node, "case_to:", stmt->case_to, inspect_expression);
+			ast_append_child(node, "case_statement:", stmt->case_statement, inspect_statement);
+			ast_append_child(node, "case_label:", stmt->case_label, inspect_symbol);
+			break;
+		case STMT_RETURN:
+			ast_append_child(node, "ret_value:", stmt->ret_value, inspect_expression);
+			ast_append_child(node, "ret_target:", stmt->ret_target, inspect_symbol);
+			break;
+
+		default:
+			break;
+	}
+}
+
+
+void inspect_statement_list(AstNode *node)
+{
+	inspect_ptr_list(node, "statement_list", inspect_statement);
+}
+
+
+static const char *symbol_type_name(enum type type)
+{
+	static const char *type_name[] = {
+		[SYM_UNINITIALIZED] = "SYM_UNINITIALIZED",
+		[SYM_PREPROCESSOR] = "SYM_PREPROCESSOR",
+		[SYM_BASETYPE] = "SYM_BASETYPE",
+		[SYM_NODE] = "SYM_NODE",
+		[SYM_PTR] = "SYM_PTR",
+		[SYM_FN] = "SYM_FN",
+		[SYM_ARRAY] = "SYM_ARRAY",
+		[SYM_STRUCT] = "SYM_STRUCT",
+		[SYM_UNION] = "SYM_UNION",
+		[SYM_ENUM] = "SYM_ENUM",
+		[SYM_TYPEDEF] = "SYM_TYPEDEF",
+		[SYM_TYPEOF] = "SYM_TYPEOF",
+		[SYM_MEMBER] = "SYM_MEMBER",
+		[SYM_BITFIELD] = "SYM_BITFIELD",
+		[SYM_LABEL] = "SYM_LABEL",
+		[SYM_RESTRICT] = "SYM_RESTRICT",
+		[SYM_FOULED] = "SYM_FOULED",
+		[SYM_KEYWORD] = "SYM_KEYWORD",
+		[SYM_BAD] = "SYM_BAD",
+	};
+	return type_name[type] ?: "UNKNOWN_TYPE";
+}
+
+
+void inspect_symbol(AstNode *node)
+{
+	struct symbol *sym = node->ptr;
+	node->text = g_strdup_printf("%s %s: %s", node->text, symbol_type_name(sym->type),
+				      builtin_typename(sym) ?: show_ident(sym->ident));
+	ast_append_child(node, "ctype.base_type:", sym->ctype.base_type,inspect_symbol);
+
+	switch (sym->namespace) {
+		case NS_PREPROCESSOR:
+			break;
+		default:
+			ast_append_child(node, "arguments:", sym->arguments, inspect_symbol_list);
+			ast_append_child(node, "symbol_list:", sym->symbol_list, inspect_symbol_list);
+			ast_append_child(node, "stmt:", sym->stmt, inspect_statement);
+			break;
+	}
+}
+
+
+void inspect_symbol_list(AstNode *node)
+{
+	inspect_ptr_list(node, "symbol_list", inspect_symbol);
+}
+
+
+static const char *expression_type_name(enum expression_type type)
+{
+	static const char *expression_type_name[] = {
+		[EXPR_VALUE] = "EXPR_VALUE",
+		[EXPR_STRING] = "EXPR_STRING",
+		[EXPR_SYMBOL] = "EXPR_SYMBOL",
+		[EXPR_TYPE] = "EXPR_TYPE",
+		[EXPR_BINOP] = "EXPR_BINOP",
+		[EXPR_ASSIGNMENT] = "EXPR_ASSIGNMENT",
+		[EXPR_LOGICAL] = "EXPR_LOGICAL",
+		[EXPR_DEREF] = "EXPR_DEREF",
+		[EXPR_PREOP] = "EXPR_PREOP",
+		[EXPR_POSTOP] = "EXPR_POSTOP",
+		[EXPR_CAST] = "EXPR_CAST",
+		[EXPR_FORCE_CAST] = "EXPR_FORCE_CAST",
+		[EXPR_IMPLIED_CAST] = "EXPR_IMPLIED_CAST",
+		[EXPR_SIZEOF] = "EXPR_SIZEOF",
+		[EXPR_ALIGNOF] = "EXPR_ALIGNOF",
+		[EXPR_PTRSIZEOF] = "EXPR_PTRSIZEOF",
+		[EXPR_CONDITIONAL] = "EXPR_CONDITIONAL",
+		[EXPR_SELECT] = "EXPR_SELECT",
+		[EXPR_STATEMENT] = "EXPR_STATEMENT",
+		[EXPR_CALL] = "EXPR_CALL",
+		[EXPR_COMMA] = "EXPR_COMMA",
+		[EXPR_COMPARE] = "EXPR_COMPARE",
+		[EXPR_LABEL] = "EXPR_LABEL",
+		[EXPR_INITIALIZER] = "EXPR_INITIALIZER",
+		[EXPR_IDENTIFIER] = "EXPR_IDENTIFIER",
+		[EXPR_INDEX] = "EXPR_INDEX",
+		[EXPR_POS] = "EXPR_POS",
+		[EXPR_FVALUE] = "EXPR_FVALUE",
+		[EXPR_SLICE] = "EXPR_SLICE",
+		[EXPR_OFFSETOF] = "EXPR_OFFSETOF",
+	};
+	return expression_type_name[type] ?: "UNKNOWN_EXPRESSION_TYPE";
+}
+
+void inspect_expression(AstNode *node)
+{
+	struct expression *expr = node->ptr;
+	node->text = g_strdup_printf("%s %s", node->text, expression_type_name(expr->type));
+	switch (expr->type) {
+		case EXPR_STATEMENT:
+			ast_append_child(node, "statement:", expr->statement, inspect_statement);
+			break;
+		case EXPR_BINOP:
+		case EXPR_COMMA:
+		case EXPR_COMPARE:
+		case EXPR_LOGICAL:
+		case EXPR_ASSIGNMENT:
+			ast_append_child(node, "left:", expr->left, inspect_expression);
+			ast_append_child(node, "right:", expr->right, inspect_expression);
+			break;
+
+		case EXPR_CAST:
+		case EXPR_FORCE_CAST:
+		case EXPR_IMPLIED_CAST:
+			ast_append_child(node, "cast_type:", expr->cast_type, inspect_symbol);
+			ast_append_child(node, "cast_expression:", expr->cast_expression, inspect_expression);
+			break;
+
+		case EXPR_PREOP:
+			ast_append_child(node, "unop:", expr->unop, inspect_expression);
+			break;
+		
+		default:
+			break;
+	}
+}
+
+
+
diff --git a/usr/src/tools/smatch/src/ast-inspect.h b/usr/src/tools/smatch/src/ast-inspect.h
new file mode 100644
index 0000000000..6e15c91b13
--- /dev/null
+++ b/usr/src/tools/smatch/src/ast-inspect.h
@@ -0,0 +1,17 @@
+
+#ifndef _AST_INSPECT_H_
+#define _AST_INSPECT_H_
+
+#include "ast-model.h"
+
+void inspect_symbol(AstNode *node);
+void inspect_symbol_list(AstNode *node);
+
+void inspect_statement(AstNode *node);
+void inspect_statement_list(AstNode *node);
+
+void inspect_expression(AstNode *node);
+void inspect_expression_list(AstNode *node);
+
+
+#endif
diff --git a/usr/src/tools/smatch/src/ast-model.c b/usr/src/tools/smatch/src/ast-model.c
new file mode 100644
index 0000000000..cbd82dbb3b
--- /dev/null
+++ b/usr/src/tools/smatch/src/ast-model.c
@@ -0,0 +1,469 @@
+/*
+ *   ast-model.c 
+ *
+ *   A custom tree model to simplify viewing of AST objects.
+ *   Modify from the Gtk+ tree view tutorial, custom-list.c
+ *   by Tim-Philipp Mueller < tim at centricular dot net >
+ *
+ *   Copyright (C) 2010 Christopher Li
+ */
+
+
+#include "ast-model.h"
+#include "stdint.h"
+
+/* boring declarations of local functions */
+
+static void ast_init(AstNode *pkg_tree);
+static void ast_class_init(AstNodeClass *klass);
+static void ast_tree_model_init(GtkTreeModelIface *iface);
+static void ast_finalize(GObject *object);
+static GtkTreeModelFlags ast_get_flags(GtkTreeModel *tree_model);
+static gint ast_get_n_columns(GtkTreeModel *tree_model);
+static GType ast_get_column_type(GtkTreeModel *tree_model, gint index);
+static gboolean ast_get_iter(GtkTreeModel *tree_model, GtkTreeIter *iter,
+				  GtkTreePath *path);
+static GtkTreePath *ast_get_path(GtkTreeModel *tree_model, GtkTreeIter *iter); 
+static void ast_get_value(GtkTreeModel *tree_model, GtkTreeIter *iter,
+			       gint column, GValue *value);
+static gboolean ast_iter_next(GtkTreeModel *tree_model, GtkTreeIter *iter);
+static gboolean ast_iter_children(GtkTreeModel *tree_model,
+                                       GtkTreeIter *iter,
+                                       GtkTreeIter *parent);
+static gboolean ast_iter_has_child(GtkTreeModel *tree_model, GtkTreeIter *iter);
+static gint ast_iter_n_children (GtkTreeModel *tree_model, GtkTreeIter *iter);
+static gboolean ast_iter_nth_child(GtkTreeModel *tree_model, GtkTreeIter *iter,
+                                        GtkTreeIter *parent, gint n);
+static gboolean ast_iter_parent(GtkTreeModel *tree_model,
+                                     GtkTreeIter *iter,
+                                     GtkTreeIter *child);
+
+static GObjectClass *parent_class = NULL;  /* GObject stuff - nothing to worry about */
+
+static inline
+void inspect_child_node(AstNode *node)
+{
+	if (node->inspect) {
+		node->inspect(node);
+		node->inspect = NULL;
+	}
+}
+
+
+static inline
+AstNode* ast_nth_child(AstNode *node, int n)
+{
+	if (!node)
+		return NULL;
+
+	inspect_child_node(node);
+
+	if (n >= node->childnodes->len)
+		return NULL;
+	return g_array_index(node->childnodes, AstNode *, n);
+}
+
+
+static inline
+gboolean ast_set_iter(GtkTreeIter *iter, AstNode *node)
+{
+	iter->user_data = node;
+	iter->user_data2 = iter->user_data3 = NULL;
+	return node != NULL;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_get_type: here we register our new type and its interfaces
+ *                with the type system. If you want to implement
+ *                additional interfaces like GtkTreeSortable, you
+ *                will need to do it here.
+ *
+ *****************************************************************************/
+
+GType
+ast_get_type (void)
+{
+	static GType ast_type = 0;
+	static const GTypeInfo ast_info = {
+		sizeof (AstNodeClass),
+		NULL,                                         /* base_init */
+		NULL,                                         /* base_finalize */
+		(GClassInitFunc) ast_class_init,
+		NULL,                                         /* class finalize */
+		NULL,                                         /* class_data */
+		sizeof (AstNode),
+		0,                                           /* n_preallocs */
+		(GInstanceInitFunc) ast_init
+	};
+	static const GInterfaceInfo tree_model_info = {
+		(GInterfaceInitFunc) ast_tree_model_init,
+		NULL,
+		NULL
+	};
+
+
+
+	if (ast_type)
+		return ast_type;
+
+	/* Some boilerplate type registration stuff */
+	ast_type = g_type_register_static(G_TYPE_OBJECT, "AstNode",
+						&ast_info, (GTypeFlags)0);
+
+	/* Here we register our GtkTreeModel interface with the type system */
+	g_type_add_interface_static(ast_type, GTK_TYPE_TREE_MODEL, &tree_model_info);
+
+	return ast_type;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_class_init: more boilerplate GObject/GType stuff.
+ *                  Init callback for the type system,
+ *                  called once when our new class is created.
+ *
+ *****************************************************************************/
+
+static void
+ast_class_init (AstNodeClass *klass)
+{
+	GObjectClass *object_class;
+
+	parent_class = (GObjectClass*) g_type_class_peek_parent (klass);
+	object_class = (GObjectClass*) klass;
+
+	object_class->finalize = ast_finalize;
+}
+
+/*****************************************************************************
+ *
+ *  ast_tree_model_init: init callback for the interface registration
+ *                       in ast_get_type. Here we override
+ *                       the GtkTreeModel interface functions that
+ *                       we implement.
+ *
+ *****************************************************************************/
+
+static void
+ast_tree_model_init (GtkTreeModelIface *iface)
+{
+	iface->get_flags       = ast_get_flags;
+	iface->get_n_columns   = ast_get_n_columns;
+	iface->get_column_type = ast_get_column_type;
+	iface->get_iter        = ast_get_iter;
+	iface->get_path        = ast_get_path;
+	iface->get_value       = ast_get_value;
+	iface->iter_next       = ast_iter_next;
+	iface->iter_children   = ast_iter_children;
+	iface->iter_has_child  = ast_iter_has_child;
+	iface->iter_n_children = ast_iter_n_children;
+	iface->iter_nth_child  = ast_iter_nth_child;
+	iface->iter_parent     = ast_iter_parent;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_init: this is called every time a new ast node object
+ *            instance is created (we do that in ast_new).
+ *            Initialise the list structure's fields here.
+ *
+ *****************************************************************************/
+
+static void
+ast_init (AstNode *node)
+{
+	node->childnodes = g_array_new(FALSE, TRUE, sizeof(AstNode *));
+	node->stamp    = g_random_int(); /* Random int to check whether iters belong to out model */
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_finalize: this is called just before an ast node is
+ *                destroyed. Free dynamically allocated memory here.
+ *
+ *****************************************************************************/
+
+static void
+ast_finalize (GObject *object)
+{
+	/*  AstNode *node = AST_NODE(object); */
+
+	/* FIXME: free all node memory */
+
+	/* must chain up - finalize parent */
+	(* parent_class->finalize) (object);
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_get_flags: tells the rest of the world whether our tree model
+ *                 has any special characteristics. In our case,
+ *                 we have a list model (instead of a tree), and each
+ *                 tree iter is valid as long as the row in question
+ *                 exists, as it only contains a pointer to our struct.
+ *
+ *****************************************************************************/
+
+static GtkTreeModelFlags
+ast_get_flags(GtkTreeModel *tree_model)
+{
+	return (GTK_TREE_MODEL_ITERS_PERSIST);
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_get_n_columns: tells the rest of the world how many data
+ *                          columns we export via the tree model interface
+ *
+ *****************************************************************************/
+
+static gint
+ast_get_n_columns(GtkTreeModel *tree_model)
+{
+	return 1;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_get_column_type: tells the rest of the world which type of
+ *                       data an exported model column contains
+ *
+ *****************************************************************************/
+
+static GType
+ast_get_column_type(GtkTreeModel *tree_model,
+                         gint index)
+{
+	return G_TYPE_STRING;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_get_iter: converts a tree path (physical position) into a
+ *                tree iter structure (the content of the iter
+ *                fields will only be used internally by our model).
+ *                We simply store a pointer to our AstNodeItem
+ *                structure that represents that row in the tree iter.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_get_iter(GtkTreeModel *tree_model,
+                  GtkTreeIter  *iter,
+                  GtkTreePath  *path)
+{
+	AstNode    *node;
+	gint          *indices, depth;
+	int i;
+
+	node = AST_NODE(tree_model);
+	indices = gtk_tree_path_get_indices(path);
+	depth   = gtk_tree_path_get_depth(path);
+
+	for (i = 0; i < depth; i++)
+		node = ast_nth_child(node, indices[i]);
+
+	return ast_set_iter(iter, node);
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_get_path: converts a tree iter into a tree path (ie. the
+ *                physical position of that row in the list).
+ *
+ *****************************************************************************/
+
+static GtkTreePath *
+ast_get_path(GtkTreeModel *tree_model,
+                  GtkTreeIter  *iter)
+{
+	GtkTreePath  *path;
+	AstNode   *root = AST_NODE(tree_model);
+	AstNode   *node = AST_NODE(iter->user_data);
+
+	path = gtk_tree_path_new();
+	while (node != root) {
+		gtk_tree_path_prepend_index(path, node->index);
+		node = node->parent;
+	}
+	return path;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_get_value: Returns a row's exported data columns
+ *                 (_get_value is what gtk_tree_model_get uses)
+ *
+ *****************************************************************************/
+
+static void
+ast_get_value(GtkTreeModel *tree_model,
+                   GtkTreeIter  *iter,
+                   gint          column,
+                   GValue       *value)
+{
+	AstNode    *node = iter->user_data;
+
+	g_assert(AST_IS_NODE(tree_model));
+	if (column != 1)
+		return;
+
+	inspect_child_node(node);
+
+	g_value_init(value, G_TYPE_STRING);
+	g_value_set_string(value, node->text);
+	return;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_iter_next: Takes an iter structure and sets it to point
+ *                 to the next row.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_next(GtkTreeModel  *tree_model,
+                   GtkTreeIter   *iter)
+{
+	AstNode    *node = iter->user_data;
+	
+	g_assert(AST_IS_NODE (tree_model));
+
+	node = ast_nth_child(node->parent, node->index + 1);
+	return ast_set_iter(iter, node);
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_iter_children: Returns TRUE or FALSE depending on whether
+ *                     the row specified by 'parent' has any children.
+ *                     If it has children, then 'iter' is set to
+ *                     point to the first child. Special case: if
+ *                     'parent' is NULL, then the first top-level
+ *                     row should be returned if it exists.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_children(GtkTreeModel *tree_model,
+                       GtkTreeIter  *iter,
+                       GtkTreeIter  *parent)
+{
+	return ast_iter_nth_child(tree_model, iter, parent, 0);
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_iter_has_child: Returns TRUE or FALSE depending on whether
+ *                      the row specified by 'iter' has any children.
+ *                      We only have a list and thus no children.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_has_child (GtkTreeModel *tree_model,
+                         GtkTreeIter  *iter)
+{
+	AstNode    *node = iter->user_data;
+	inspect_child_node(node);
+	return node->childnodes->len > 0;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_iter_n_children: Returns the number of children the row
+ *                       specified by 'iter' has. This is usually 0,
+ *                       as we only have a list and thus do not have
+ *                       any children to any rows. A special case is
+ *                       when 'iter' is NULL, in which case we need
+ *                       to return the number of top-level node,
+ *                       ie. the number of rows in our list.
+ *
+ *****************************************************************************/
+
+static gint
+ast_iter_n_children (GtkTreeModel *tree_model,
+                          GtkTreeIter  *iter)
+{
+	AstNode  *node = iter ? iter->user_data
+				: AST_NODE(tree_model);
+
+	inspect_child_node(node);
+	return node->childnodes->len;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_iter_nth_child: If the row specified by 'parent' has any
+ *                      children, set 'iter' to the n-th child and
+ *                      return TRUE if it exists, otherwise FALSE.
+ *                      A special case is when 'parent' is NULL, in
+ *                      which case we need to set 'iter' to the n-th
+ *                      row if it exists.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_nth_child(GtkTreeModel *tree_model,
+                        GtkTreeIter  *iter,
+                        GtkTreeIter  *parent,
+                        gint          n)
+{
+	AstNode    *node = parent ? parent->user_data : (AstNode*) tree_model;
+	GArray *array = node->childnodes;
+	if (n >= array->len)
+		return FALSE;
+	iter->user_data = g_array_index(array, AstNode *, n);
+	return TRUE;
+}
+
+
+/*****************************************************************************
+ *
+ *  ast_iter_parent: Point 'iter' to the parent node of 'child'. As
+ *                   we have a list and thus no children and no
+ *                   parents of children, we can just return FALSE.
+ *
+ *****************************************************************************/
+
+static gboolean
+ast_iter_parent (GtkTreeModel *tree_model,
+                      GtkTreeIter  *iter,
+                      GtkTreeIter  *child)
+{
+	AstNode *node = (AstNode *) child->user_data;
+	iter->user_data = node->parent;
+	return node->parent != NULL;
+}
+
+
+AstNode *
+ast_new (AstNode *parent, int index, const char *text, void *ptr, void (*inspect)(AstNode*))
+{
+	AstNode *node = (AstNode*) g_object_new (AST_TYPE_NODE, NULL);
+	g_assert(node != NULL);
+	node->parent = parent;
+	node->index = index;
+	node->text = text;
+	node->inspect = inspect;
+	node->ptr = ptr;
+	return node;
+}
+
diff --git a/usr/src/tools/smatch/src/ast-model.h b/usr/src/tools/smatch/src/ast-model.h
new file mode 100644
index 0000000000..650053d291
--- /dev/null
+++ b/usr/src/tools/smatch/src/ast-model.h
@@ -0,0 +1,90 @@
+
+/*
+ * ast-model.h
+ *
+ * Copyright (C) 2010 Christopher Li.
+ *
+ */
+
+#ifndef _ast_model_h_
+#define _ast_model_h_
+
+#include <stdint.h>
+#include <gtk/gtk.h>
+#include "lib.h"
+
+#define AST_TYPE_NODE                  (ast_get_type ())
+#define AST_NODE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), AST_TYPE_NODE, AstNode))
+#define AST_NODE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass),  AST_TYPE_NODE, AstNodeClass))
+#define AST_IS_NODE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), AST_TYPE_NODE))
+#define AST_IS_NODE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass),  AST_TYPE_NODE))
+#define AST_NODE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj),  AST_TYPE_NODE, AstNodeClass))
+
+enum
+{
+	AST_COL_RECORD = 0,
+	AST_COL_NAME,
+	AST_N_COLUMNS,
+} ;
+
+
+typedef struct AstNode AstNode;
+typedef struct AstNodeClass AstNodeClass;
+
+
+
+/* AstNode: this structure contains everything we need for our
+ *             model implementation. You can add extra fields to
+ *             this structure, e.g. hashtables to quickly lookup
+ *             rows or whatever else you might need, but it is
+ *             crucial that 'parent' is the first member of the
+ *             structure.                                          */
+
+struct AstNode
+{
+	GObject         base;      /* this MUST be the first member */
+
+	AstNode	*parent;
+	int index;
+	const gchar *text;
+	void (*inspect)(struct AstNode* node);
+	void *ptr;
+	GArray *childnodes;
+	gint stamp;
+};
+
+
+
+/* AstNodeClass: more boilerplate GObject stuff */
+
+struct AstNodeClass
+{
+	GObjectClass base_class;
+};
+
+
+GType ast_get_type(void);
+AstNode* ast_new(AstNode *parent, int index, const char *prefix, void *ptr, void (*expand)(AstNode*));
+
+
+static inline
+AstNode* ast_append_child(AstNode *parent, const char *text,
+			   void *ptr, void (*inspect)(AstNode*))
+{
+	if (ptr) {
+		AstNode *child = ast_new(parent, parent->childnodes->len,
+						text, ptr, inspect);
+		g_array_append_val(parent->childnodes, child);
+		return child;
+	}
+	return NULL;
+}
+
+static inline
+void ast_append_attribute(AstNode *parent, const char *text)
+{
+	AstNode *child = ast_new(parent, parent->childnodes->len, text, NULL, NULL);
+	g_array_append_val(parent->childnodes, child);
+}
+
+#endif /* _ast_h_*/
diff --git a/usr/src/tools/smatch/src/ast-view.c b/usr/src/tools/smatch/src/ast-view.c
new file mode 100644
index 0000000000..22aba115b2
--- /dev/null
+++ b/usr/src/tools/smatch/src/ast-view.c
@@ -0,0 +1,49 @@
+
+#include <stdlib.h>
+#include "ast-model.h"
+#include "ast-inspect.h"
+#include "ast-view.h"
+
+static GtkWidget *
+create_view_and_model (void *ptr)
+{
+	GtkTreeViewColumn   *text;
+	GtkCellRenderer *renderer;
+	AstNode *root;
+	GtkWidget *view;
+
+	root = ast_new(NULL, 0, "", ptr, inspect_symbol_list);
+
+	view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(root));
+
+	g_object_unref(root); /* destroy store automatically with view */
+
+	renderer = gtk_cell_renderer_text_new();
+	text = gtk_tree_view_column_new_with_attributes("Node", renderer,
+						       "text", AST_COL_NAME,
+						       NULL);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(view), text);
+
+	return view;
+}
+
+void
+treeview_main (struct symbol_list *syms)
+{
+	GtkWidget *window, *view, *scrollwin;
+
+	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+	gtk_window_set_default_size (GTK_WINDOW(window), 600, 800);
+	g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
+
+	scrollwin = gtk_scrolled_window_new(NULL,NULL);
+
+	view = create_view_and_model(syms);
+
+	gtk_container_add(GTK_CONTAINER(scrollwin), view);
+	gtk_container_add(GTK_CONTAINER(window), scrollwin);
+
+	gtk_widget_show_all(window);
+
+	gtk_main();
+}
diff --git a/usr/src/tools/smatch/src/ast-view.h b/usr/src/tools/smatch/src/ast-view.h
new file mode 100644
index 0000000000..da8f5f500e
--- /dev/null
+++ b/usr/src/tools/smatch/src/ast-view.h
@@ -0,0 +1,7 @@
+
+#include <gtk/gtk.h>
+#include "lib.h"
+
+extern void treeview_main(struct symbol_list *syms);
+
+
diff --git a/usr/src/tools/smatch/src/avl.c b/usr/src/tools/smatch/src/avl.c
new file mode 100644
index 0000000000..e6bd620cf4
--- /dev/null
+++ b/usr/src/tools/smatch/src/avl.c
@@ -0,0 +1,524 @@
+/*
+ * Copyright (C) 2010 Joseph Adams <joeyadams3.14159@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static AvlNode *mkNode(const struct sm_state *sm);
+static void freeNode(AvlNode *node);
+
+static AvlNode *lookup(const struct stree *avl, AvlNode *node, const struct sm_state *sm);
+
+static bool insert_sm(struct stree *avl, AvlNode **p, const struct sm_state *sm);
+static bool remove_sm(struct stree *avl, AvlNode **p, const struct sm_state *sm, AvlNode **ret);
+static bool removeExtremum(AvlNode **p, int side, AvlNode **ret);
+
+static int sway(AvlNode **p, int sway);
+static void balance(AvlNode **p, int side);
+
+static bool checkBalances(AvlNode *node, int *height);
+static bool checkOrder(struct stree *avl);
+static size_t countNode(AvlNode *node);
+
+int unfree_stree;
+
+/*
+ * Utility macros for converting between
+ * "balance" values (-1 or 1) and "side" values (0 or 1).
+ *
+ * bal(0)   == -1
+ * bal(1)   == +1
+ * side(-1) == 0
+ * side(+1) == 1
+ */
+#define bal(side) ((side) == 0 ? -1 : 1)
+#define side(bal) ((bal)  == 1 ?  1 : 0)
+
+static struct stree *avl_new(void)
+{
+	struct stree *avl = malloc(sizeof(*avl));
+
+	unfree_stree++;
+	assert(avl != NULL);
+
+	avl->root = NULL;
+	avl->base_stree = NULL;
+	avl->has_states = calloc(num_checks + 1, sizeof(char));
+	avl->count = 0;
+	avl->stree_id = 0;
+	avl->references = 1;
+	return avl;
+}
+
+void free_stree(struct stree **avl)
+{
+	if (!*avl)
+		return;
+
+	assert((*avl)->references > 0);
+
+	(*avl)->references--;
+	if ((*avl)->references != 0) {
+		*avl = NULL;
+		return;
+	}
+
+	unfree_stree--;
+
+	freeNode((*avl)->root);
+	free(*avl);
+	*avl = NULL;
+}
+
+struct sm_state *avl_lookup(const struct stree *avl, const struct sm_state *sm)
+{
+	AvlNode *found;
+
+	if (!avl)
+		return NULL;
+	if (sm->owner != USHRT_MAX &&
+	    !avl->has_states[sm->owner])
+		return NULL;
+	found = lookup(avl, avl->root, sm);
+	if (!found)
+		return NULL;
+	return (struct sm_state *)found->sm;
+}
+
+AvlNode *avl_lookup_node(const struct stree *avl, const struct sm_state *sm)
+{
+	return lookup(avl, avl->root, sm);
+}
+
+size_t stree_count(const struct stree *avl)
+{
+	if (!avl)
+		return 0;
+	return avl->count;
+}
+
+static struct stree *clone_stree_real(struct stree *orig)
+{
+	struct stree *new = avl_new();
+	AvlIter i;
+
+	avl_foreach(i, orig)
+		avl_insert(&new, i.sm);
+
+	new->base_stree = orig->base_stree;
+	return new;
+}
+
+bool avl_insert(struct stree **avl, const struct sm_state *sm)
+{
+	size_t old_count;
+
+	if (!*avl)
+		*avl = avl_new();
+	if ((*avl)->references > 1) {
+		(*avl)->references--;
+		*avl = clone_stree_real(*avl);
+	}
+	old_count = (*avl)->count;
+	/* fortunately we never call get_state() on "unnull_path" */
+	if (sm->owner != USHRT_MAX)
+		(*avl)->has_states[sm->owner] = 1;
+	insert_sm(*avl, &(*avl)->root, sm);
+	return (*avl)->count != old_count;
+}
+
+bool avl_remove(struct stree **avl, const struct sm_state *sm)
+{
+	AvlNode *node = NULL;
+
+	if (!*avl)
+		return false;
+	/* it's fairly rare for smatch to call avl_remove */
+	if ((*avl)->references > 1) {
+		(*avl)->references--;
+		*avl = clone_stree_real(*avl);
+	}
+
+	remove_sm(*avl, &(*avl)->root, sm, &node);
+
+	if ((*avl)->count == 0)
+		free_stree(avl);
+
+	if (node == NULL) {
+		return false;
+	} else {
+		free(node);
+		return true;
+	}
+}
+
+static AvlNode *mkNode(const struct sm_state *sm)
+{
+	AvlNode *node = malloc(sizeof(*node));
+
+	assert(node != NULL);
+
+	node->sm = sm;
+	node->lr[0] = NULL;
+	node->lr[1] = NULL;
+	node->balance = 0;
+	return node;
+}
+
+static void freeNode(AvlNode *node)
+{
+	if (node) {
+		freeNode(node->lr[0]);
+		freeNode(node->lr[1]);
+		free(node);
+	}
+}
+
+static AvlNode *lookup(const struct stree *avl, AvlNode *node, const struct sm_state *sm)
+{
+	int cmp;
+
+	if (node == NULL)
+		return NULL;
+
+	cmp = cmp_tracker(sm, node->sm);
+
+	if (cmp < 0)
+		return lookup(avl, node->lr[0], sm);
+	if (cmp > 0)
+		return lookup(avl, node->lr[1], sm);
+	return node;
+}
+
+/*
+ * Insert an sm into a subtree, rebalancing if necessary.
+ *
+ * Return true if the subtree's height increased.
+ */
+static bool insert_sm(struct stree *avl, AvlNode **p, const struct sm_state *sm)
+{
+	if (*p == NULL) {
+		*p = mkNode(sm);
+		avl->count++;
+		return true;
+	} else {
+		AvlNode *node = *p;
+		int      cmp  = cmp_tracker(sm, node->sm);
+
+		if (cmp == 0) {
+			node->sm = sm;
+			return false;
+		}
+
+		if (!insert_sm(avl, &node->lr[side(cmp)], sm))
+			return false;
+
+		/* If tree's balance became -1 or 1, it means the tree's height grew due to insertion. */
+		return sway(p, cmp) != 0;
+	}
+}
+
+/*
+ * Remove the node matching the given sm.
+ * If present, return the removed node through *ret .
+ * The returned node's lr and balance are meaningless.
+ *
+ * Return true if the subtree's height decreased.
+ */
+static bool remove_sm(struct stree *avl, AvlNode **p, const struct sm_state *sm, AvlNode **ret)
+{
+	if (p == NULL || *p == NULL) {
+		return false;
+	} else {
+		AvlNode *node = *p;
+		int      cmp  = cmp_tracker(sm, node->sm);
+
+		if (cmp == 0) {
+			*ret = node;
+			avl->count--;
+
+			if (node->lr[0] != NULL && node->lr[1] != NULL) {
+				AvlNode *replacement;
+				int      side;
+				bool     shrunk;
+
+				/* Pick a subtree to pull the replacement from such that
+				 * this node doesn't have to be rebalanced. */
+				side = node->balance <= 0 ? 0 : 1;
+
+				shrunk = removeExtremum(&node->lr[side], 1 - side, &replacement);
+
+				replacement->lr[0]   = node->lr[0];
+				replacement->lr[1]   = node->lr[1];
+				replacement->balance = node->balance;
+				*p = replacement;
+
+				if (!shrunk)
+					return false;
+
+				replacement->balance -= bal(side);
+
+				/* If tree's balance became 0, it means the tree's height shrank due to removal. */
+				return replacement->balance == 0;
+			}
+
+			if (node->lr[0] != NULL)
+				*p = node->lr[0];
+			else
+				*p = node->lr[1];
+
+			return true;
+
+		} else {
+			if (!remove_sm(avl, &node->lr[side(cmp)], sm, ret))
+				return false;
+
+			/* If tree's balance became 0, it means the tree's height shrank due to removal. */
+			return sway(p, -cmp) == 0;
+		}
+	}
+}
+
+/*
+ * Remove either the left-most (if side == 0) or right-most (if side == 1)
+ * node in a subtree, returning the removed node through *ret .
+ * The returned node's lr and balance are meaningless.
+ *
+ * The subtree must not be empty (i.e. *p must not be NULL).
+ *
+ * Return true if the subtree's height decreased.
+ */
+static bool removeExtremum(AvlNode **p, int side, AvlNode **ret)
+{
+	AvlNode *node = *p;
+
+	if (node->lr[side] == NULL) {
+		*ret = node;
+		*p = node->lr[1 - side];
+		return true;
+	}
+
+	if (!removeExtremum(&node->lr[side], side, ret))
+		return false;
+
+	/* If tree's balance became 0, it means the tree's height shrank due to removal. */
+	return sway(p, -bal(side)) == 0;
+}
+
+/*
+ * Rebalance a node if necessary.  Think of this function
+ * as a higher-level interface to balance().
+ *
+ * sway must be either -1 or 1, and indicates what was added to
+ * the balance of this node by a prior operation.
+ *
+ * Return the new balance of the subtree.
+ */
+static int sway(AvlNode **p, int sway)
+{
+	if ((*p)->balance != sway)
+		(*p)->balance += sway;
+	else
+		balance(p, side(sway));
+
+	return (*p)->balance;
+}
+
+/*
+ * Perform tree rotations on an unbalanced node.
+ *
+ * side == 0 means the node's balance is -2 .
+ * side == 1 means the node's balance is +2 .
+ */
+static void balance(AvlNode **p, int side)
+{
+	AvlNode  *node  = *p,
+	         *child = node->lr[side];
+	int opposite    = 1 - side;
+	int bal         = bal(side);
+
+	if (child->balance != -bal) {
+		/* Left-left (side == 0) or right-right (side == 1) */
+		node->lr[side]      = child->lr[opposite];
+		child->lr[opposite] = node;
+		*p = child;
+
+		child->balance -= bal;
+		node->balance = -child->balance;
+
+	} else {
+		/* Left-right (side == 0) or right-left (side == 1) */
+		AvlNode *grandchild = child->lr[opposite];
+
+		node->lr[side]           = grandchild->lr[opposite];
+		child->lr[opposite]      = grandchild->lr[side];
+		grandchild->lr[side]     = child;
+		grandchild->lr[opposite] = node;
+		*p = grandchild;
+
+		node->balance       = 0;
+		child->balance      = 0;
+
+		if (grandchild->balance == bal)
+			node->balance  = -bal;
+		else if (grandchild->balance == -bal)
+			child->balance = bal;
+
+		grandchild->balance = 0;
+	}
+}
+
+
+/************************* avl_check_invariants() *************************/
+
+bool avl_check_invariants(struct stree *avl)
+{
+	int    dummy;
+
+	return checkBalances(avl->root, &dummy)
+	    && checkOrder(avl)
+	    && countNode(avl->root) == avl->count;
+}
+
+static bool checkBalances(AvlNode *node, int *height)
+{
+	if (node) {
+		int h0, h1;
+
+		if (!checkBalances(node->lr[0], &h0))
+			return false;
+		if (!checkBalances(node->lr[1], &h1))
+			return false;
+
+		if (node->balance != h1 - h0 || node->balance < -1 || node->balance > 1)
+			return false;
+
+		*height = (h0 > h1 ? h0 : h1) + 1;
+		return true;
+	} else {
+		*height = 0;
+		return true;
+	}
+}
+
+static bool checkOrder(struct stree *avl)
+{
+	AvlIter     i;
+	const struct sm_state *last = NULL;
+	bool        last_set = false;
+
+	avl_foreach(i, avl) {
+		if (last_set && cmp_tracker(last, i.sm) >= 0)
+			return false;
+		last     = i.sm;
+		last_set = true;
+	}
+
+	return true;
+}
+
+static size_t countNode(AvlNode *node)
+{
+	if (node)
+		return 1 + countNode(node->lr[0]) + countNode(node->lr[1]);
+	else
+		return 0;
+}
+
+
+/************************* Traversal *************************/
+
+void avl_iter_begin(AvlIter *iter, struct stree *avl, AvlDirection dir)
+{
+	AvlNode *node;
+
+	iter->stack_index = 0;
+	iter->direction   = dir;
+
+	if (!avl || !avl->root) {
+		iter->sm      = NULL;
+		iter->node     = NULL;
+		return;
+	}
+	node = avl->root;
+
+	while (node->lr[dir] != NULL) {
+		iter->stack[iter->stack_index++] = node;
+		node = node->lr[dir];
+	}
+
+	iter->sm   = (struct sm_state *) node->sm;
+	iter->node  = node;
+}
+
+void avl_iter_next(AvlIter *iter)
+{
+	AvlNode     *node = iter->node;
+	AvlDirection dir  = iter->direction;
+
+	if (node == NULL)
+		return;
+
+	node = node->lr[1 - dir];
+	if (node != NULL) {
+		while (node->lr[dir] != NULL) {
+			iter->stack[iter->stack_index++] = node;
+			node = node->lr[dir];
+		}
+	} else if (iter->stack_index > 0) {
+		node = iter->stack[--iter->stack_index];
+	} else {
+		iter->sm      = NULL;
+		iter->node     = NULL;
+		return;
+	}
+
+	iter->node  = node;
+	iter->sm   = (struct sm_state *) node->sm;
+}
+
+struct stree *clone_stree(struct stree *orig)
+{
+	if (!orig)
+		return NULL;
+
+	orig->references++;
+	return orig;
+}
+
+void set_stree_id(struct stree **stree, int stree_id)
+{
+	if ((*stree)->stree_id != 0)
+		*stree = clone_stree_real(*stree);
+
+	(*stree)->stree_id = stree_id;
+}
+
+int get_stree_id(struct stree *stree)
+{
+	if (!stree)
+		return -1;
+	return stree->stree_id;
+}
diff --git a/usr/src/tools/smatch/src/avl.h b/usr/src/tools/smatch/src/avl.h
new file mode 100644
index 0000000000..50c90cdae8
--- /dev/null
+++ b/usr/src/tools/smatch/src/avl.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2010 Joseph Adams <joeyadams3.14159@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef CCAN_AVL_H
+#define CCAN_AVL_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+struct sm_state;
+
+typedef struct AvlNode       AvlNode;
+typedef struct AvlIter       AvlIter;
+
+struct stree {
+	AvlNode    *root;
+	struct stree *base_stree;
+	char *has_states;
+	size_t      count;
+	int stree_id;
+	int references;
+};
+
+void free_stree(struct stree **avl);
+	/* Free an stree tree. */
+
+struct sm_state *avl_lookup(const struct stree *avl, const struct sm_state *sm);
+	/* O(log n). Lookup a sm.  Return NULL if the sm is not present. */
+
+#define avl_member(avl, sm) (!!avl_lookup_node(avl, sm))
+	/* O(log n). See if a sm is present. */
+
+size_t stree_count(const struct stree *avl);
+	/* O(1). Return the number of elements in the tree. */
+
+bool avl_insert(struct stree **avl, const struct sm_state *sm);
+	/*
+	 * O(log n). Insert an sm or replace it if already present.
+	 *
+	 * Return false if the insertion replaced an existing sm.
+	 */
+
+bool avl_remove(struct stree **avl, const struct sm_state *sm);
+	/*
+	 * O(log n). Remove an sm (if present).
+	 *
+	 * Return true if it was removed.
+	 */
+
+bool avl_check_invariants(struct stree *avl);
+	/* For testing purposes.  This function will always return true :-) */
+
+
+/************************* Traversal *************************/
+
+#define avl_foreach(iter, avl)         avl_traverse(iter, avl, FORWARD)
+	/*
+	 * O(n). Traverse an stree tree in order.
+	 *
+	 * Example:
+	 *
+	 * AvlIter i;
+	 *
+	 * avl_foreach(i, avl)
+	 *     printf("%s -> %s\n", i.sm->name, i.sm->state->name);
+	 */
+
+#define FOR_EACH_SM(avl, _sm) {			\
+	AvlIter _i;				\
+	avl_foreach(_i, avl) {			\
+		_sm = _i.sm;
+
+#define END_FOR_EACH_SM(_sm) }}
+
+#define FOR_EACH_MY_SM(_owner, avl, _sm) {	\
+	AvlIter _i;				\
+	avl_foreach(_i, avl) {			\
+		_sm = _i.sm;			\
+		if (_sm->owner != _owner)	\
+			continue;		\
+
+#define avl_foreach_reverse(iter, avl) avl_traverse(iter, avl, BACKWARD)
+	/* O(n). Traverse an stree tree in reverse order. */
+
+typedef enum AvlDirection {FORWARD = 0, BACKWARD = 1} AvlDirection;
+
+struct AvlIter {
+	struct sm_state *sm;
+	AvlNode      *node;
+
+	/* private */
+	AvlNode      *stack[100];
+	int           stack_index;
+	AvlDirection  direction;
+};
+
+void avl_iter_begin(AvlIter *iter, struct stree *avl, AvlDirection dir);
+void avl_iter_next(AvlIter *iter);
+#define avl_traverse(iter, avl, direction)        \
+	for (avl_iter_begin(&(iter), avl, direction); \
+	     (iter).node != NULL;                     \
+	     avl_iter_next(&iter))
+
+
+/***************** Internal data structures ******************/
+
+struct AvlNode {
+	const struct sm_state *sm;
+
+	AvlNode    *lr[2];
+	int         balance; /* -1, 0, or 1 */
+};
+
+AvlNode *avl_lookup_node(const struct stree *avl, const struct sm_state *sm);
+	/* O(log n). Lookup an stree node by sm.  Return NULL if not present. */
+
+struct stree *clone_stree(struct stree *orig);
+
+void set_stree_id(struct stree **stree, int id);
+int get_stree_id(struct stree *stree);
+
+#endif
diff --git a/usr/src/tools/smatch/src/bitmap.h b/usr/src/tools/smatch/src/bitmap.h
new file mode 100644
index 0000000000..4d81ffc075
--- /dev/null
+++ b/usr/src/tools/smatch/src/bitmap.h
@@ -0,0 +1,51 @@
+#ifndef BITMAP_H
+#define BITMAP_H
+
+#define BITS_IN_LONG	(sizeof(unsigned long)*8)
+#define LONGS(x)	((x + BITS_IN_LONG - 1) & -BITS_IN_LONG)
+
+/* Every bitmap gets its own type */
+#define DECLARE_BITMAP(name, x) unsigned long name[LONGS(x)]
+
+static inline int test_bit(unsigned int nr, unsigned long *bitmap)
+{
+	unsigned long offset = nr / BITS_IN_LONG;
+	unsigned long bit = nr & (BITS_IN_LONG-1);
+	return (bitmap[offset] >> bit) & 1;
+}
+
+static inline void set_bit(unsigned int nr, unsigned long *bitmap)
+{
+	unsigned long offset = nr / BITS_IN_LONG;
+	unsigned long bit = nr & (BITS_IN_LONG-1);
+	bitmap[offset] |= 1UL << bit;
+}
+
+static inline void clear_bit(unsigned int nr, unsigned long *bitmap)
+{
+	unsigned long offset = nr / BITS_IN_LONG;
+	unsigned long bit = nr & (BITS_IN_LONG-1);
+	bitmap[offset] &= ~(1UL << bit);
+}
+
+static inline int test_and_set_bit(unsigned int nr, unsigned long *bitmap)
+{
+	unsigned long offset = nr / BITS_IN_LONG;
+	unsigned long bit = nr & (BITS_IN_LONG-1);
+	unsigned long old = bitmap[offset];
+	unsigned long mask = 1UL << bit;
+	bitmap[offset] = old | mask;
+	return (old & mask) != 0;
+}
+
+static inline int test_and_clear_bit(unsigned int nr, unsigned long *bitmap)
+{
+	unsigned long offset = nr / BITS_IN_LONG;
+	unsigned long bit = nr & (BITS_IN_LONG-1);
+	unsigned long old = bitmap[offset];
+	unsigned long mask = 1UL << bit;
+	bitmap[offset] = old & ~mask;
+	return (old & mask) != 0;
+}
+
+#endif /* BITMAP_H */
diff --git a/usr/src/tools/smatch/src/builtin.c b/usr/src/tools/smatch/src/builtin.c
new file mode 100644
index 0000000000..9f90926cb0
--- /dev/null
+++ b/usr/src/tools/smatch/src/builtin.c
@@ -0,0 +1,261 @@
+/*
+ * builtin evaluation & expansion.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "expression.h"
+#include "expand.h"
+#include "symbol.h"
+#include "compat/bswap.h"
+
+static int evaluate_to_int_const_expr(struct expression *expr)
+{
+	expr->ctype = &int_ctype;
+	expr->flags |= CEF_SET_ICE;
+	return 1;
+}
+
+static int evaluate_pure_unop(struct expression *expr)
+{
+	struct expression *arg = first_expression(expr->args);
+	int flags = arg->flags;
+
+	/*
+	 * Allow such functions with a constant integer expression
+	 * argument to be treated as a *constant* integer.
+	 * This allow us to use them in switch() { case ...:
+	 */
+	flags |= (flags & CEF_ICE) ? CEF_SET_INT : 0;
+	expr->flags = flags;
+	return 1;
+}
+
+
+static int evaluate_expect(struct expression *expr)
+{
+	/* Should we evaluate it to return the type of the first argument? */
+	expr->ctype = &int_ctype;
+	return 1;
+}
+
+static int arguments_choose(struct expression *expr)
+{
+	struct expression_list *arglist = expr->args;
+	struct expression *arg;
+	int i = 0;
+
+	FOR_EACH_PTR (arglist, arg) {
+		if (!evaluate_expression(arg))
+			return 0;
+		i++;
+	} END_FOR_EACH_PTR(arg);
+	if (i < 3) {
+		sparse_error(expr->pos,
+			     "not enough arguments for __builtin_choose_expr");
+		return 0;
+	} if (i > 3) {
+		sparse_error(expr->pos,
+			     "too many arguments for __builtin_choose_expr");
+		return 0;
+	}
+	return 1;
+}
+
+static int evaluate_choose(struct expression *expr)
+{
+	struct expression_list *list = expr->args;
+	struct expression *arg, *args[3];
+	int n = 0;
+
+	/* there will be exactly 3; we'd already verified that */
+	FOR_EACH_PTR(list, arg) {
+		args[n++] = arg;
+	} END_FOR_EACH_PTR(arg);
+
+	*expr = get_expression_value(args[0]) ? *args[1] : *args[2];
+
+	return 1;
+}
+
+static int expand_expect(struct expression *expr, int cost)
+{
+	struct expression *arg = first_ptr_list((struct ptr_list *) expr->args);
+
+	if (arg)
+		*expr = *arg;
+	return 0;
+}
+
+/*
+ * __builtin_warning() has type "int" and always returns 1,
+ * so that you can use it in conditionals or whatever
+ */
+static int expand_warning(struct expression *expr, int cost)
+{
+	struct expression *arg;
+	struct expression_list *arglist = expr->args;
+
+	FOR_EACH_PTR (arglist, arg) {
+		/*
+		 * Constant strings get printed out as a warning. By the
+		 * time we get here, the EXPR_STRING has been fully 
+		 * evaluated, so by now it's an anonymous symbol with a
+		 * string initializer.
+		 *
+		 * Just for the heck of it, allow any constant string
+		 * symbol.
+		 */
+		if (arg->type == EXPR_SYMBOL) {
+			struct symbol *sym = arg->symbol;
+			if (sym->initializer && sym->initializer->type == EXPR_STRING) {
+				struct string *string = sym->initializer->string;
+				warning(expr->pos, "%*s", string->length-1, string->data);
+			}
+			continue;
+		}
+
+		/*
+		 * Any other argument is a conditional. If it's
+		 * non-constant, or it is false, we exit and do
+		 * not print any warning.
+		 */
+		if (arg->type != EXPR_VALUE)
+			goto out;
+		if (!arg->value)
+			goto out;
+	} END_FOR_EACH_PTR(arg);
+out:
+	expr->type = EXPR_VALUE;
+	expr->value = 1;
+	expr->taint = 0;
+	return 0;
+}
+
+/* The arguments are constant if the cost of all of them is zero */
+static int expand_constant_p(struct expression *expr, int cost)
+{
+	expr->type = EXPR_VALUE;
+	expr->value = !cost;
+	expr->taint = 0;
+	return 0;
+}
+
+/* The arguments are safe, if their cost is less than SIDE_EFFECTS */
+static int expand_safe_p(struct expression *expr, int cost)
+{
+	expr->type = EXPR_VALUE;
+	expr->value = (cost < SIDE_EFFECTS);
+	expr->taint = 0;
+	return 0;
+}
+
+static struct symbol_op constant_p_op = {
+	.evaluate = evaluate_to_int_const_expr,
+	.expand = expand_constant_p
+};
+
+static struct symbol_op safe_p_op = {
+	.evaluate = evaluate_to_int_const_expr,
+	.expand = expand_safe_p
+};
+
+static struct symbol_op warning_op = {
+	.evaluate = evaluate_to_int_const_expr,
+	.expand = expand_warning
+};
+
+static struct symbol_op expect_op = {
+	.evaluate = evaluate_expect,
+	.expand = expand_expect
+};
+
+static struct symbol_op choose_op = {
+	.evaluate = evaluate_choose,
+	.args = arguments_choose,
+};
+
+/* The argument is constant and valid if the cost is zero */
+static int expand_bswap(struct expression *expr, int cost)
+{
+	struct expression *arg;
+	long long val;
+
+	if (cost)
+		return cost;
+
+	/* the arguments number & type have already been checked */
+	arg = first_expression(expr->args);
+	val = get_expression_value_silent(arg);
+	switch (expr->ctype->bit_size) {
+	case 16: expr->value = bswap16(val); break;
+	case 32: expr->value = bswap32(val); break;
+	case 64: expr->value = bswap64(val); break;
+	default: /* impossible error */
+		return SIDE_EFFECTS;
+	}
+
+	expr->type = EXPR_VALUE;
+	expr->taint = 0;
+	return 0;
+}
+
+static struct symbol_op bswap_op = {
+	.evaluate = evaluate_pure_unop,
+	.expand = expand_bswap,
+};
+
+
+/*
+ * Builtin functions
+ */
+static struct symbol builtin_fn_type = { .type = SYM_FN /* , .variadic =1 */ };
+static struct sym_init {
+	const char *name;
+	struct symbol *base_type;
+	unsigned int modifiers;
+	struct symbol_op *op;
+} builtins_table[] = {
+	{ "__builtin_constant_p", &builtin_fn_type, MOD_TOPLEVEL, &constant_p_op },
+	{ "__builtin_safe_p", &builtin_fn_type, MOD_TOPLEVEL, &safe_p_op },
+	{ "__builtin_warning", &builtin_fn_type, MOD_TOPLEVEL, &warning_op },
+	{ "__builtin_expect", &builtin_fn_type, MOD_TOPLEVEL, &expect_op },
+	{ "__builtin_choose_expr", &builtin_fn_type, MOD_TOPLEVEL, &choose_op },
+	{ "__builtin_bswap16", NULL, MOD_TOPLEVEL, &bswap_op },
+	{ "__builtin_bswap32", NULL, MOD_TOPLEVEL, &bswap_op },
+	{ "__builtin_bswap64", NULL, MOD_TOPLEVEL, &bswap_op },
+	{ NULL,		NULL,		0 }
+};
+
+void init_builtins(int stream)
+{
+	struct sym_init *ptr;
+
+	builtin_fn_type.variadic = 1;
+	for (ptr = builtins_table; ptr->name; ptr++) {
+		struct symbol *sym;
+		sym = create_symbol(stream, ptr->name, SYM_NODE, NS_SYMBOL);
+		sym->ctype.base_type = ptr->base_type;
+		sym->ctype.modifiers = ptr->modifiers;
+		sym->op = ptr->op;
+	}
+}
diff --git a/usr/src/tools/smatch/src/c2xml.c b/usr/src/tools/smatch/src/c2xml.c
new file mode 100644
index 0000000000..c45d5818a9
--- /dev/null
+++ b/usr/src/tools/smatch/src/c2xml.c
@@ -0,0 +1,334 @@
+/*
+ * Sparse c2xml
+ *
+ * Dumps the parse tree as an xml document
+ *
+ * Copyright (C) 2007 Rob Taylor
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+
+#include "expression.h"
+#include "parse.h"
+#include "scope.h"
+#include "symbol.h"
+
+static xmlDocPtr doc = NULL;       /* document pointer */
+static xmlNodePtr root_node = NULL;/* root node pointer */
+static int idcount = 0;
+
+static void examine_symbol(struct symbol *sym, xmlNodePtr node);
+
+static xmlAttrPtr newProp(xmlNodePtr node, const char *name, const char *value)
+{
+	return xmlNewProp(node, BAD_CAST name, BAD_CAST value);
+}
+
+static xmlAttrPtr newNumProp(xmlNodePtr node, const char *name, int value)
+{
+	char buf[256];
+	snprintf(buf, 256, "%d", value);
+	return newProp(node, name, buf);
+}
+
+static xmlAttrPtr newIdProp(xmlNodePtr node, const char *name, unsigned int id)
+{
+	char buf[256];
+	snprintf(buf, 256, "_%d", id);
+	return newProp(node, name, buf);
+}
+
+static xmlNodePtr new_sym_node(struct symbol *sym, const char *name, xmlNodePtr parent)
+{
+	xmlNodePtr node;
+	const char *ident = show_ident(sym->ident);
+
+	assert(name != NULL);
+	assert(sym != NULL);
+	assert(parent != NULL);
+
+	node = xmlNewChild(parent, NULL, BAD_CAST "symbol", NULL);
+
+	newProp(node, "type", name);
+
+	newIdProp(node, "id", idcount);
+
+	if (sym->ident && ident)
+		newProp(node, "ident", ident);
+	newProp(node, "file", stream_name(sym->pos.stream));
+
+	newNumProp(node, "start-line", sym->pos.line);
+	newNumProp(node, "start-col", sym->pos.pos);
+
+	if (sym->endpos.type) {
+		newNumProp(node, "end-line", sym->endpos.line);
+		newNumProp(node, "end-col", sym->endpos.pos);
+		if (sym->pos.stream != sym->endpos.stream)
+			newProp(node, "end-file", stream_name(sym->endpos.stream));
+        }
+	sym->aux = node;
+
+	idcount++;
+
+	return node;
+}
+
+static inline void examine_members(struct symbol_list *list, xmlNodePtr node)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		examine_symbol(sym, node);
+	} END_FOR_EACH_PTR(sym);
+}
+
+static void examine_modifiers(struct symbol *sym, xmlNodePtr node)
+{
+	const char *modifiers[] = {
+			"auto",
+			"register",
+			"static",
+			"extern",
+			"const",
+			"volatile",
+			"signed",
+			"unsigned",
+			"char",
+			"short",
+			"long",
+			"long-long",
+			"typedef",
+			NULL,
+			NULL,
+			NULL,
+			NULL,
+			NULL,
+			"inline",
+			"addressable",
+			"nocast",
+			"noderef",
+			"accessed",
+			"toplevel",
+			"label",
+			"assigned",
+			"type-type",
+			"safe",
+			"user-type",
+			"force",
+			"explicitly-signed",
+			"bitwise"};
+
+	int i;
+
+	if (sym->namespace != NS_SYMBOL)
+		return;
+
+	/*iterate over the 32 bit bitfield*/
+	for (i=0; i < 32; i++) {
+		if ((sym->ctype.modifiers & 1<<i) && modifiers[i])
+			newProp(node, modifiers[i], "1");
+	}
+}
+
+static void
+examine_layout(struct symbol *sym, xmlNodePtr node)
+{
+	examine_symbol_type(sym);
+
+	newNumProp(node, "bit-size", sym->bit_size);
+	newNumProp(node, "alignment", sym->ctype.alignment);
+	newNumProp(node, "offset", sym->offset);
+	if (is_bitfield_type(sym)) {
+		newNumProp(node, "bit-offset", sym->bit_offset);
+	}
+}
+
+static void examine_symbol(struct symbol *sym, xmlNodePtr node)
+{
+	xmlNodePtr child = NULL;
+	const char *base;
+	int array_size;
+
+	if (!sym)
+		return;
+	if (sym->aux)		/*already visited */
+		return;
+
+	if (sym->ident && sym->ident->reserved)
+		return;
+
+	child = new_sym_node(sym, get_type_name(sym->type), node);
+	examine_modifiers(sym, child);
+	examine_layout(sym, child);
+
+	if (sym->ctype.base_type) {
+		if ((base = builtin_typename(sym->ctype.base_type)) == NULL) {
+			if (!sym->ctype.base_type->aux) {
+				examine_symbol(sym->ctype.base_type, root_node);
+			}
+			xmlNewProp(child, BAD_CAST "base-type",
+			           xmlGetProp((xmlNodePtr)sym->ctype.base_type->aux, BAD_CAST "id"));
+		} else {
+			newProp(child, "base-type-builtin", base);
+		}
+	}
+	if (sym->array_size) {
+		/* TODO: modify get_expression_value to give error return */
+		array_size = get_expression_value(sym->array_size);
+		newNumProp(child, "array-size", array_size);
+	}
+
+
+	switch (sym->type) {
+	case SYM_STRUCT:
+	case SYM_UNION:
+		examine_members(sym->symbol_list, child);
+		break;
+	case SYM_FN:
+		examine_members(sym->arguments, child);
+		break;
+	case SYM_UNINITIALIZED:
+		newProp(child, "base-type-builtin", builtin_typename(sym));
+		break;
+	default:
+		break;
+	}
+	return;
+}
+
+static struct position *get_expansion_end (struct token *token)
+{
+	struct token *p1, *p2;
+
+	for (p1=NULL, p2=NULL;
+	     !eof_token(token);
+	     p2 = p1, p1 = token, token = token->next);
+
+	if (p2)
+		return &(p2->pos);
+	else
+		return NULL;
+}
+
+static void examine_macro(struct symbol *sym, xmlNodePtr node)
+{
+	struct position *pos;
+
+	/* this should probably go in the main codebase*/
+	pos = get_expansion_end(sym->expansion);
+	if (pos)
+		sym->endpos = *pos;
+	else
+		sym->endpos = sym->pos;
+
+	new_sym_node(sym, "macro", node);
+}
+
+static void examine_namespace(struct symbol *sym)
+{
+	if (sym->ident && sym->ident->reserved)
+		return;
+
+	switch(sym->namespace) {
+	case NS_MACRO:
+		examine_macro(sym, root_node);
+		break;
+	case NS_TYPEDEF:
+	case NS_STRUCT:
+	case NS_SYMBOL:
+		examine_symbol(sym, root_node);
+		break;
+	case NS_NONE:
+	case NS_LABEL:
+	case NS_ITERATOR:
+	case NS_UNDEF:
+	case NS_PREPROCESSOR:
+	case NS_KEYWORD:
+		break;
+	default:
+		die("Unrecognised namespace type %d",sym->namespace);
+	}
+
+}
+
+static int get_stream_id (const char *name)
+{
+	int i;
+	for (i=0; i<input_stream_nr; i++) {
+		if (strcmp(name, stream_name(i))==0)
+			return i;
+	}
+	return -1;
+}
+
+static inline void examine_symbol_list(const char *file, struct symbol_list *list)
+{
+	struct symbol *sym;
+	int stream_id = get_stream_id (file);
+
+	if (!list)
+		return;
+	FOR_EACH_PTR(list, sym) {
+		if (sym->pos.stream == stream_id)
+			examine_namespace(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	struct symbol_list *symlist = NULL;
+	char *file;
+
+	doc = xmlNewDoc(BAD_CAST "1.0");
+	root_node = xmlNewNode(NULL, BAD_CAST "parse");
+	xmlDocSetRootElement(doc, root_node);
+
+/* - A DTD is probably unnecessary for something like this
+
+	dtd = xmlCreateIntSubset(doc, "parse", "http://www.kernel.org/pub/software/devel/sparse/parse.dtd" NULL, "parse.dtd");
+
+	ns = xmlNewNs (root_node, "http://www.kernel.org/pub/software/devel/sparse/parse.dtd", NULL);
+
+	xmlSetNs(root_node, ns);
+*/
+	symlist = sparse_initialize(argc, argv, &filelist);
+
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		examine_symbol_list(file, symlist);
+		sparse_keep_tokens(file);
+		examine_symbol_list(file, file_scope->symbols);
+		examine_symbol_list(file, global_scope->symbols);
+	} END_FOR_EACH_PTR_NOTAG(file);
+
+
+	xmlSaveFormatFileEnc("-", doc, "UTF-8", 1);
+	xmlFreeDoc(doc);
+	xmlCleanupParser();
+
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/cgcc b/usr/src/tools/smatch/src/cgcc
new file mode 100755
index 0000000000..554d1f2e71
--- /dev/null
+++ b/usr/src/tools/smatch/src/cgcc
@@ -0,0 +1,346 @@
+#!/usr/bin/perl -w
+# -----------------------------------------------------------------------------
+
+my $cc = $ENV{'REAL_CC'} || 'cc';
+my $check = $ENV{'CHECK'} || 'sparse';
+my $ccom = $cc;
+
+my $m32 = 0;
+my $m64 = 0;
+my $has_specs = 0;
+my $gendeps = 0;
+my $do_check = 0;
+my $do_compile = 1;
+my $gcc_base_dir;
+my $multiarch_dir;
+my $verbose = 0;
+
+while (@ARGV) {
+    $_ = shift(@ARGV);
+    # Look for a .c file.  We don't want to run the checker on .o or .so files
+    # in the link run.  (This simplistic check knows nothing about options
+    # with arguments, but it seems to do the job.)
+    $do_check = 1 if /^[^-].*\.c$/;
+
+    # Ditto for stdin.
+    $do_check = 1 if $_ eq '-';
+
+    $m32 = 1 if /^-m32$/;
+    $m64 = 1 if /^-m64$/;
+    $gendeps = 1 if /^-M$/;
+
+    if (/^-target=(.*)$/) {
+	$check .= &add_specs ($1);
+	$has_specs = 1;
+	next;
+    }
+
+    if ($_ eq '-no-compile') {
+	$do_compile = 0;
+	next;
+    }
+
+    if (/^-gcc-base-dir$/) {
+        $gcc_base_dir = shift @ARGV;
+        die ("$0: missing argument for -gcc-base-dir option") if !$gcc_base_dir;
+        next;
+    }
+
+    if (/^-multiarch-dir$/) {
+        $multiarch_dir = shift @ARGV;
+        die ("$0: missing argument for -multiarch-dir option") if !$multiarch_dir;
+        next;
+    }
+
+    # If someone adds "-E", don't pre-process twice.
+    $do_compile = 0 if $_ eq '-E';
+
+    $verbose = 1 if $_ eq '-v';
+
+    my $this_arg = ' ' . &quote_arg ($_);
+    $cc .= $this_arg unless &check_only_option ($_);
+    $check .= $this_arg;
+}
+
+if ($gendeps) {
+    $do_compile = 1;
+    $do_check = 0;
+}
+
+if ($do_check) {
+    if (!$has_specs) {
+	$check .= &add_specs ('host_arch_specs');
+	$check .= &add_specs ('host_os_specs');
+    }
+
+    $gcc_base_dir = qx($ccom -print-file-name=) if !$gcc_base_dir;
+    chomp($gcc_base_dir);  # possibly remove '\n' from compiler
+    $check .= " -gcc-base-dir " . $gcc_base_dir if $gcc_base_dir;
+
+    $multiarch_dir = qx($ccom -print-multiarch) if ! defined $multiarch_dir;
+    chomp($multiarch_dir);  # possibly remove '\n' from compiler
+    $check .= " -multiarch-dir " . $multiarch_dir if $multiarch_dir;
+
+    print "$check\n" if $verbose;
+    if ($do_compile) {
+	system ($check);
+    } else {
+	exec ($check);
+    }
+}
+
+if ($do_compile) {
+    print "$cc\n" if $verbose;
+    exec ($cc);
+}
+
+exit 0;
+
+# -----------------------------------------------------------------------------
+# Check if an option is for "check" only.
+
+sub check_only_option {
+    my ($arg) = @_;
+    return 1 if $arg =~ /^-W(no-?)?(address-space|bitwise|cast-to-as|cast-truncate|context|decl|default-bitfield-sign|designated-init|do-while|enum-mismatch|external-function-has-definition|init-cstring|memcpy-max-count|non-ansi-function-declaration|non-pointer-null|old-initializer|one-bit-signed-bitfield|override-init-all|paren-string|ptr-subtraction-blows|return-void|sizeof-bool|sparse-all|sparse-error|transparent-union|typesign|undef|unknown-attribute)$/;
+    return 1 if $arg =~ /^-v(no-?)?(entry|dead)$/;
+    return 1 if $arg =~ /^-f(dump-linearize|memcpy-max-count)(=\S*)?$/;
+    return 0;
+}
+
+# -----------------------------------------------------------------------------
+# Simple arg-quoting function.  Just adds backslashes when needed.
+
+sub quote_arg {
+    my ($arg) = @_;
+    return "''" if $arg eq '';
+    return join ('',
+		 map {
+		     m|^[-a-zA-Z0-9._/,=]+$| ? $_ : "\\" . $_;
+		 } (split (//, $arg)));
+}
+
+# -----------------------------------------------------------------------------
+
+sub integer_types {
+    my ($char,@dummy) = @_;
+
+    my %pow2m1 =
+	(8 => '127',
+	 16 => '32767',
+	 32 => '2147483647',
+	 64 => '9223372036854775807',
+	 128 => '170141183460469231731687303715884105727',
+	 );
+    my @types = (['SCHAR',''], ['SHRT',''], ['INT',''], ['LONG','L'], ['LONG_LONG','LL'], ['LONG_LONG_LONG','LLL']);
+
+    my $result = " -D__CHAR_BIT__=$char";
+    while (@types && @_) {
+	my $bits = shift @_;
+	my ($name,$suffix) = @{ shift @types };
+	die "$0: weird number of bits." unless exists $pow2m1{$bits};
+	$result .= " -D__${name}_MAX__=" . $pow2m1{$bits} . $suffix;
+    }
+    return $result;
+}
+
+# -----------------------------------------------------------------------------
+
+sub float_types {
+    my ($has_inf,$has_qnan,$dec_dig,@bitsizes) = @_;
+    my $result = " -D__FLT_RADIX__=2";
+    $result .= " -D__FINITE_MATH_ONLY__=" . ($has_inf || $has_qnan ? '0' : '1');
+    $result .= " -D__DECIMAL_DIG__=$dec_dig";
+
+    my %constants =
+	(24 =>
+	 {
+	     'MIN' => '1.17549435e-38',
+	     'MAX' => '3.40282347e+38',
+	     'EPSILON' => '1.19209290e-7',
+	     'DENORM_MIN' => '1.40129846e-45',
+	 },
+	 53 =>
+	 {
+	     'MIN' => '2.2250738585072014e-308',
+	     'MAX' => '1.7976931348623157e+308',
+	     'EPSILON' => '2.2204460492503131e-16',
+	     'DENORM_MIN' => '4.9406564584124654e-324',
+	 },
+	 64 =>
+	 {
+	     'MIN' => '3.36210314311209350626e-4932',
+	     'MAX' => '1.18973149535723176502e+4932',
+	     'EPSILON' => '1.08420217248550443401e-19',
+	     'DENORM_MIN' => '3.64519953188247460253e-4951',
+	 },
+	 113 =>
+	 {
+	     'MIN' => '3.36210314311209350626267781732175260e-4932',
+	     'MAX' => '1.18973149535723176508575932662800702e+4932',
+	     'EPSILON' => '1.92592994438723585305597794258492732e-34',
+	     'DENORM_MIN' => '6.47517511943802511092443895822764655e-4966',
+	 },
+	 );	     
+
+    my @types = (['FLT','F'], ['DBL',''], ['LDBL','L']);
+    while (@types) {
+	my ($mant_bits,$exp_bits) = @{ shift @bitsizes };
+	my ($name,$suffix) = @{ shift @types };
+
+	my $h = $constants{$mant_bits};
+	die "$0: weird number of mantissa bits." unless $h;
+
+	my $mant_dig = int (($mant_bits - 1) * log (2) / log (10));
+	my $max_exp = 1 << ($exp_bits - 1);
+	my $min_exp = 3 - $max_exp;
+	my $max_10_exp = int ($max_exp * log (2) / log (10));
+	my $min_10_exp = -int (-$min_exp * log (2) / log (10));
+
+	$result .= " -D__${name}_MANT_DIG__=$mant_bits";
+	$result .= " -D__${name}_DIG__=$mant_dig";
+	$result .= " -D__${name}_MIN_EXP__='($min_exp)'";
+	$result .= " -D__${name}_MAX_EXP__=$max_exp";
+	$result .= " -D__${name}_MIN_10_EXP__='($min_10_exp)'";
+	$result .= " -D__${name}_MAX_10_EXP__=$max_10_exp";
+	$result .= " -D__${name}_HAS_INFINITY__=" . ($has_inf ? '1' : '0');
+	$result .= " -D__${name}_HAS_QUIET_NAN__=" . ($has_qnan ? '1' : '0');;
+
+	foreach my $inf (sort keys %$h) {
+	    $result .= " -D__${name}_${inf}__=" . $h->{$inf} . $suffix;
+	}
+    }
+    return $result;
+}
+
+# -----------------------------------------------------------------------------
+
+sub define_size_t {
+    my ($text) = @_;
+    # We have to undef in order to override check's internal definition.
+    return ' -U__SIZE_TYPE__ ' . &quote_arg ("-D__SIZE_TYPE__=$text");
+}
+
+# -----------------------------------------------------------------------------
+
+sub add_specs {
+    my ($spec) = @_;
+    if ($spec eq 'sunos') {
+	return &add_specs ('unix') .
+	    ' -D__sun__=1 -D__sun=1 -Dsun=1' .
+	    ' -D__svr4__=1 -DSVR4=1' .
+	    ' -D__STDC__=0' .
+	    ' -D_REENTRANT' .
+	    ' -D_SOLARIS_THREADS' .
+	    ' -DNULL="((void *)0)"';
+    } elsif ($spec eq 'linux') {
+	return &add_specs ('unix') .
+	    ' -D__linux__=1 -D__linux=1 -Dlinux=linux';
+    } elsif ($spec eq 'gnu/kfreebsd') {
+	return &add_specs ('unix') .
+	    ' -D__FreeBSD_kernel__=1';
+    } elsif ($spec eq 'openbsd') {
+	return &add_specs ('unix') .
+	    ' -D__OpenBSD__=1';
+    } elsif ($spec eq 'darwin') {
+	return
+	    ' -D__APPLE__=1 -D__MACH__=1';
+    } elsif ($spec eq 'unix') {
+	return ' -Dunix=1 -D__unix=1 -D__unix__=1';
+    } elsif ( $spec =~ /^cygwin/) {
+	return &add_specs ('unix') .
+	    ' -D__CYGWIN__=1 -D__CYGWIN32__=1' .
+	    " -D'_cdecl=__attribute__((__cdecl__))'" .
+	    " -D'__cdecl=__attribute__((__cdecl__))'" .
+	    " -D'_stdcall=__attribute__((__stdcall__))'" .
+	    " -D'__stdcall=__attribute__((__stdcall__))'" .
+	    " -D'_fastcall=__attribute__((__fastcall__))'" .
+	    " -D'__fastcall=__attribute__((__fastcall__))'" .
+	    " -D'__declspec(x)=__attribute__((x))'";
+    } elsif ($spec eq 'i86') {
+	return (' -D__i386=1 -D__i386__=1' .
+		&integer_types (8, 16, 32, $m64 ? 64 : 32, 64) .
+		&float_types (1, 1, 21, [24,8], [53,11], [64,15]) .
+		&define_size_t ($m64 ? "long unsigned int" : "unsigned int") .
+		' -D__SIZEOF_POINTER__=' . ($m64 ? '8' : '4'));
+    } elsif ($spec eq 'sparc') {
+	return (' -D__sparc=1 -D__sparc__=1' .
+		&integer_types (8, 16, 32, $m64 ? 64 : 32, 64) .
+		&float_types (1, 1, 33, [24,8], [53,11], [113,15]) .
+		&define_size_t ($m64 ? "long unsigned int" : "unsigned int") .
+		' -D__SIZEOF_POINTER__=' . ($m64 ? '8' : '4'));
+    } elsif ($spec eq 'sparc64') {
+	return (' -D__sparc=1 -D__sparc__=1 -D__sparcv9__=1 -D__sparc64__=1 -D__arch64__=1 -D__LP64__=1' .
+		&integer_types (8, 16, 32, 64, 64, 128) .
+		&float_types (1, 1, 33, [24,8], [53,11], [113,15]) .
+		&define_size_t ("long unsigned int") .
+		' -D__SIZEOF_POINTER__=8');
+    } elsif ($spec eq 'x86_64') {
+	return (' -D__x86_64=1 -D__x86_64__=1' . ($m32 ? '' : ' -D__LP64__=1') .
+		&integer_types (8, 16, 32, $m32 ? 32 : 64, 64, 128) .
+		&float_types (1, 1, 33, [24,8], [53,11], [113,15]) .
+		&define_size_t ($m32 ? "unsigned int" : "long unsigned int") .
+		' -D__SIZEOF_POINTER__=' . ($m32 ? '4' : '8'));
+    } elsif ($spec eq 'ppc') {
+	return (' -D__powerpc__=1 -D_BIG_ENDIAN -D_STRING_ARCH_unaligned=1' .
+		&integer_types (8, 16, 32, $m64 ? 64 : 32, 64) .
+		&float_types (1, 1, 21, [24,8], [53,11], [113,15]) .
+		&define_size_t ($m64 ? "long unsigned int" : "unsigned int") .
+		' -D__SIZEOF_POINTER__=' . ($m64 ? '8' : '4'));
+    } elsif ($spec eq 'ppc64') {
+	return (' -D__powerpc__=1 -D__PPC__=1 -D_STRING_ARCH_unaligned=1' .
+		' -D__powerpc64__=1 -D__PPC64__=1' .
+		' -m64' .
+		&float_types (1, 1, 21, [24,8], [53,11], [113,15]));
+    } elsif ($spec eq 's390x') {
+	return (' -D__s390x__ -D__s390__ -D_BIG_ENDIAN' .
+		&integer_types (8, 16, 32, $m64 ? 64 : 32, 64) .
+		&float_types (1, 1, 36, [24,8], [53,11], [113,15]) .
+		&define_size_t ("long unsigned int") .
+		' -D__SIZEOF_POINTER__=' . ($m64 ? '8' : '4'));
+    } elsif ($spec eq 'arm') {
+	chomp (my $gccmachine = `$cc -dumpmachine`);
+	my $cppsymbols = ' -D__arm__=1 -m32';
+
+	if ($gccmachine eq 'arm-linux-gnueabihf') {
+	    $cppsymbols .= ' -D__ARM_PCS_VFP=1';
+	}
+
+	return ($cppsymbols .
+		&float_types (1, 1, 36, [24,8], [53,11], [53, 11]));
+    } elsif ($spec eq 'aarch64') {
+	return (' -D__aarch64__=1 -m64' .
+		&float_types (1, 1, 36, [24,8], [53,11], [113,15]));
+    } elsif ($spec eq 'host_os_specs') {
+	my $os = `uname -s`;
+	chomp $os;
+	return &add_specs (lc $os);
+    } elsif ($spec eq 'host_arch_specs') {
+	my $arch = `uname -m`;
+	chomp $arch;
+	if ($arch =~ /^(i.?86|athlon)$/i) {
+	    return &add_specs ('i86');
+	} elsif ($arch =~ /^(sun4u)$/i) {
+	    return &add_specs ('sparc');
+	} elsif ($arch =~ /^(x86_64)$/i) {
+	    return &add_specs ('x86_64');
+	} elsif ($arch =~ /^(ppc)$/i) {
+	    return &add_specs ('ppc');
+	} elsif ($arch =~ /^(ppc64)$/i) {
+	    return &add_specs ('ppc64') . ' -mbig-endian -D_CALL_ELF=1';
+	} elsif ($arch =~ /^(ppc64le)$/i) {
+	    return &add_specs ('ppc64') . ' -mlittle-endian -D_CALL_ELF=2';
+	} elsif ($arch =~ /^(s390x)$/i) {
+	    return &add_specs ('s390x');
+	} elsif ($arch =~ /^(sparc64)$/i) {
+	    return &add_specs ('sparc64');
+	} elsif ($arch =~ /^arm(?:v[78]l)?$/i) {
+	    return &add_specs ('arm');
+	} elsif ($arch =~ /^(aarch64)$/i) {
+	    return &add_specs ('aarch64');
+	}
+    } else {
+	die "$0: invalid specs: $spec\n";
+    }
+}
+
+# -----------------------------------------------------------------------------
diff --git a/usr/src/tools/smatch/src/cgcc.1 b/usr/src/tools/smatch/src/cgcc.1
new file mode 100644
index 0000000000..227c02ba46
--- /dev/null
+++ b/usr/src/tools/smatch/src/cgcc.1
@@ -0,0 +1,37 @@
+.\" cgcc manpage by Josh Triplett
+.TH cgcc "1"
+.
+.SH NAME
+cgcc \- Compiler wrapper to run Sparse after compiling
+.
+.SH SYNOPSIS
+.B cgcc
+[\fISPARSE OPTIONS\fR]... [\fICOMPILER OPTIONS\fR]... [\fIINPUT FILES\fR]...
+.br
+.B make CC=cgcc
+.
+.SH DESCRIPTION
+\fBcgcc\fR provides a wrapper around a C compiler (\fBcc\fR by
+default) which also invokes the Sparse static analysis tool.
+.P
+\fBcgcc\fR accepts all Sparse command-line options, such as warning
+options, and passes all other options through to the compiler.
+.P
+By providing the same interface as the C compiler, \fBcgcc\fR allows
+projects to run Sparse as part of their build without modifying their
+build system, by using \fBcgcc\fR as the compiler.  For many projects,
+setting \fBCC=cgcc\fR on the \fBmake\fR command-line will work.
+.
+.SH ENVIRONMENT
+.TP
+.B REAL_CC
+If set, \fBcgcc\fR will use this as the compiler to invoke, rather
+than the default \fBcc\fR.
+.
+.TP
+.B CHECK
+If set, \fBcgcc\fR will use this as the Sparse program to invoke,
+rather than the default \fBsparse\fR.
+.
+.SH SEE ALSO
+.BR sparse (1)
diff --git a/usr/src/tools/smatch/src/char.c b/usr/src/tools/smatch/src/char.c
new file mode 100644
index 0000000000..c52521bc83
--- /dev/null
+++ b/usr/src/tools/smatch/src/char.c
@@ -0,0 +1,146 @@
+#include <string.h>
+#include "target.h"
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "expression.h"
+#include "char.h"
+
+static const char *parse_escape(const char *p, unsigned *val, const char *end, int bits, struct position pos)
+{
+	unsigned c = *p++;
+	unsigned d;
+	if (c != '\\') {
+		*val = c;
+		return p;
+	}
+
+	c = *p++;
+	switch (c) {
+	case 'a': c = '\a'; break;
+	case 'b': c = '\b'; break;
+	case 't': c = '\t'; break;
+	case 'n': c = '\n'; break;
+	case 'v': c = '\v'; break;
+	case 'f': c = '\f'; break;
+	case 'r': c = '\r'; break;
+	case 'e': c = '\e'; break;
+	case 'x': {
+		unsigned mask = -(1U << (bits - 4));
+		for (c = 0; p < end; c = (c << 4) + d) {
+			d = hexval(*p);
+			if (d > 16)
+				break;
+			p++;
+			if (c & mask) {
+				warning(pos,
+					"hex escape sequence out of range");
+				mask = 0;
+			}
+		}
+		break;
+	}
+	case '0'...'7': {
+		if (p + 2 < end)
+			end = p + 2;
+		c -= '0';
+		while (p < end && (d = *p - '0') < 8) {
+			c = (c << 3) + d;
+			p++;
+		}
+		if ((c & 0400) && bits < 9)
+			warning(pos,
+				"octal escape sequence out of range");
+		break;
+	}
+	default:	/* everything else is left as is */
+		warning(pos, "unknown escape sequence: '\\%c'", c);
+		break;
+	case '\\':
+	case '\'':
+	case '"':
+	case '?':
+		break;	/* those are legal, so no warnings */
+	}
+	*val = c & ~((~0U << (bits - 1)) << 1);
+	return p;
+}
+
+void get_char_constant(struct token *token, unsigned long long *val)
+{
+	const char *p = token->embedded, *end;
+	unsigned v;
+	int type = token_type(token);
+	switch (type) {
+	case TOKEN_CHAR:
+	case TOKEN_WIDE_CHAR:
+		p = token->string->data;
+		end = p + token->string->length - 1;
+		break;
+	case TOKEN_CHAR_EMBEDDED_0 ... TOKEN_CHAR_EMBEDDED_3:
+		end = p + type - TOKEN_CHAR;
+		break;
+	default:
+		end = p + type - TOKEN_WIDE_CHAR;
+	}
+	p = parse_escape(p, &v, end,
+			type < TOKEN_WIDE_CHAR ? bits_in_char : bits_in_wchar, token->pos);
+	if (p != end)
+		warning(token->pos,
+			"multi-character character constant");
+	*val = v;
+}
+
+struct token *get_string_constant(struct token *token, struct expression *expr)
+{
+	struct string *string = token->string;
+	struct token *next = token->next, *done = NULL;
+	int stringtype = token_type(token);
+	int is_wide = stringtype == TOKEN_WIDE_STRING;
+	static char buffer[MAX_STRING];
+	int len = 0;
+	int bits;
+	int esc_count = 0;
+
+	while (!done) {
+		switch (token_type(next)) {
+		case TOKEN_WIDE_STRING:
+			is_wide = 1;
+		case TOKEN_STRING:
+			next = next->next;
+			break;
+		default:
+			done = next;
+		}
+	}
+	bits = is_wide ? bits_in_wchar : bits_in_char;
+	while (token != done) {
+		unsigned v;
+		const char *p = token->string->data;
+		const char *end = p + token->string->length - 1;
+		while (p < end) {
+			if (*p == '\\')
+				esc_count++;
+			p = parse_escape(p, &v, end, bits, token->pos);
+			if (len < MAX_STRING)
+				buffer[len] = v;
+			len++;
+		}
+		token = token->next;
+	}
+	if (len > MAX_STRING) {
+		warning(token->pos, "trying to concatenate %d-character string (%d bytes max)", len, MAX_STRING);
+		len = MAX_STRING;
+	}
+
+	if (esc_count || len >= string->length) {
+		if (string->immutable || len >= string->length)	/* can't cannibalize */
+			string = __alloc_string(len+1);
+		string->length = len+1;
+		memcpy(string->data, buffer, len);
+		string->data[len] = '\0';
+	}
+	expr->string = string;
+	expr->wide = is_wide;
+	return token;
+}
diff --git a/usr/src/tools/smatch/src/char.h b/usr/src/tools/smatch/src/char.h
new file mode 100644
index 0000000000..54be6b7468
--- /dev/null
+++ b/usr/src/tools/smatch/src/char.h
@@ -0,0 +1,2 @@
+extern void get_char_constant(struct token *, unsigned long long *);
+extern struct token *get_string_constant(struct token *, struct expression *);
diff --git a/usr/src/tools/smatch/src/check_64bit_shift.c b/usr/src/tools/smatch/src/check_64bit_shift.c
new file mode 100644
index 0000000000..89b1c23d3f
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_64bit_shift.c
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_shift_assignment(struct expression *expr)
+{
+	struct symbol *left_type, *right_type;
+	struct expression *right;
+	sval_t sval;
+	sval_t bits, shifter;
+	char *name;
+
+	right = strip_expr(expr->right);
+	if (right->type != EXPR_BINOP || right->op != SPECIAL_LEFTSHIFT)
+		return;
+
+	left_type = get_type(expr->left);
+	if (left_type != &llong_ctype && left_type != &ullong_ctype)
+		return;
+
+	right_type = get_type(expr->right);
+
+	if (type_bits(right_type) == 64)
+		return;
+
+	if (get_value(right, &sval))
+		return;
+
+	get_absolute_max(right->left, &bits);
+	get_absolute_max(right->right, &shifter);
+
+	bits = sval_cast(&ullong_ctype, bits);
+	if (sval_cmp_val(shifter, 32) < 0) {
+		sval = sval_binop(bits, SPECIAL_LEFTSHIFT, shifter);
+		if (sval_cmp_val(sval, UINT_MAX) < 0)
+			return;
+	}
+
+	name = expr_to_str_sym(right, NULL);
+	sm_warning("should '%s' be a 64 bit type?", name);
+	free_string(name);
+}
+
+void check_64bit_shift(int id)
+{
+	my_id = id;
+
+	add_hook(&match_shift_assignment, ASSIGNMENT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_access_ok_math.c b/usr/src/tools/smatch/src/check_access_ok_math.c
new file mode 100644
index 0000000000..7cfcdc4a7d
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_access_ok_math.c
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static int can_overflow(struct expression *expr)
+{
+	sval_t max;
+	int uncapped = 0;
+
+	expr = strip_expr(expr);
+
+	if (expr->type == EXPR_BINOP) {
+		uncapped += can_overflow(expr->left);
+		uncapped += can_overflow(expr->right);
+
+		if (uncapped &&
+			(expr->op == '+' || expr->op == '*' || expr->op == SPECIAL_LEFTSHIFT))
+			return 1;
+
+		return 0;
+	}
+
+	if (get_implied_max(expr, &max))
+		return 0;
+	if (get_absolute_max(expr, &max) && sval_cmp_val(max, 4096) <= 0)
+		return 0;
+	return 1;
+}
+
+static void match_size(struct expression *size_expr)
+{
+	char *name;
+
+	size_expr = strip_expr(size_expr);
+	if (!size_expr)
+		return;
+	if (size_expr->type != EXPR_BINOP) {
+		size_expr = get_assigned_expr(size_expr);
+		if (!size_expr || size_expr->type != EXPR_BINOP)
+			return;
+	}
+	if (!can_overflow(size_expr))
+		return;
+
+	name = expr_to_str(size_expr);
+	sm_warning("math in access_ok() is dangerous '%s'", name);
+
+	free_string(name);
+}
+
+static void match_access_ok(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *size_expr;
+
+	size_expr = get_argument_from_call_expr(expr->args, 1);
+	match_size(size_expr);
+}
+
+static void split_asm_constraints(struct expression_list *expr_list)
+{
+	struct expression *expr;
+        int state = 0;
+	int i;
+
+	i = 0;
+        FOR_EACH_PTR(expr_list, expr) {
+
+                switch (state) {
+                case 0: /* identifier */
+                case 1: /* constraint */
+                        state++;
+                        continue;
+                case 2: /* expression */
+                        state = 0;
+			if (i == 1)
+				match_size(expr);
+			i++;
+                        continue;
+                }
+        } END_FOR_EACH_PTR(expr);
+}
+
+static void match_asm_stmt(struct statement *stmt)
+{
+	char *name;
+
+	name = get_macro_name(stmt->pos);
+	if (!name || strcmp(name, "access_ok") != 0)
+		return;
+	split_asm_constraints(stmt->asm_inputs);
+}
+
+void check_access_ok_math(int id)
+{
+	my_id = id;
+	if (option_project != PROJ_KERNEL)
+		return;
+	if (!option_spammy)
+		return;
+	add_function_hook("__access_ok", &match_access_ok, NULL);
+	add_hook(&match_asm_stmt, ASM_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_all_func_returns.c b/usr/src/tools/smatch/src/check_all_func_returns.c
new file mode 100644
index 0000000000..f9d774499c
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_all_func_returns.c
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2018 Joyent, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Like lint of old, check that every return value from every function is used.
+ * Casting to (void) will silence this check.
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static void check_func_return(struct expression *expr)
+{
+	struct symbol *sym = get_real_base_type(get_type(expr->fn));
+	const char *func = expr_to_str(expr->fn);
+	struct statement *stmt;
+
+	if (sym == NULL) {
+		sm_error("unknown type for func '%s'", func);
+		return;
+	}
+
+	if (expr->type != EXPR_CALL) {
+		sm_error("func '%s' is not a call site", func);
+		return;
+	}
+
+	/*
+	 * There is never any need to check these returns.
+	 */
+	if (strcmp(func, "memcpy") == 0 ||
+	    strcmp(func, "memmove") == 0 ||
+	    strcmp(func, "memset") == 0)
+		return;
+
+	/*
+	 * Closer to a policy here, but there seems very few cases where it's
+	 * useful to check the return value of the standard printf() family
+	 * outputting to stdout or stderr.
+	 */
+	if (strcmp(func, "printf") == 0 || strcmp(func, "vprintf") == 0)
+		return;
+
+	if (strcmp(func, "fprintf") == 0 || strcmp(func, "vfprintf")) {
+		const char *arg0 = expr_to_str(get_argument_from_call_expr(expr->args, 0));
+
+		if (arg0 != NULL &&
+		    (strcmp(arg0, "(&__iob[1])") == 0 ||
+		    strcmp(arg0, "(&__iob[2])") == 0))
+			return;
+	}
+
+	/*
+	 * Either we got the return type already (direct call),
+	 * or we need to go one further (function pointer call)
+	 */
+	if (sym == &void_ctype || (sym->type == SYM_FN &&
+		get_real_base_type(sym) == &void_ctype))
+		return;
+
+	stmt = last_ptr_list((struct ptr_list *)big_statement_stack);
+
+	if (stmt->type == STMT_EXPRESSION && stmt->expression == expr)
+		sm_error("unchecked function return '%s'", expr_to_str(expr->fn));
+}
+
+void check_all_func_returns(int id)
+{
+	if (option_project != PROJ_ILLUMOS_KERNEL &&
+	    option_project != PROJ_ILLUMOS_USER)
+		return;
+
+	add_hook(&check_func_return, FUNCTION_CALL_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_allocating_enough_data.c b/usr/src/tools/smatch/src/check_allocating_enough_data.c
new file mode 100644
index 0000000000..12cb72bf23
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_allocating_enough_data.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static void db_returns_buf_size(struct expression *expr, int param, char *unused, char *math)
+{
+	struct expression *call;
+	struct symbol *left_type, *right_type;
+	int bytes;
+	sval_t sval;
+
+	if (expr->type != EXPR_ASSIGNMENT)
+		return;
+	right_type = get_pointer_type(expr->right);
+	if (!right_type || type_bits(right_type) != -1)
+		return;
+
+	call = strip_expr(expr->right);
+	left_type = get_pointer_type(expr->left);
+
+	if (!parse_call_math(call, math, &sval) || sval.value == 0)
+		return;
+	if (!left_type)
+		return;
+	bytes = type_bytes(left_type);
+	if (bytes <= 0)
+		return;
+	if (sval.uvalue >= bytes)
+		return;
+	sm_error("not allocating enough data %d vs %s", bytes, sval_to_str(sval));
+}
+
+void check_allocating_enough_data(int id)
+{
+	select_return_states_hook(BUF_SIZE, &db_returns_buf_size);
+}
diff --git a/usr/src/tools/smatch/src/check_allocation_funcs.c b/usr/src/tools/smatch/src/check_allocation_funcs.c
new file mode 100644
index 0000000000..e1e96aa53e
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_allocation_funcs.c
@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <fcntl.h>
+#include <unistd.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+/*
+ * Print a list of functions that return newly allocated memory.
+ */
+
+static struct tracker_list *allocated;
+
+static const char *allocation_funcs[] = {
+	"kmalloc",
+	"kzalloc",
+	"kcalloc",
+	"__alloc_skb",
+	NULL,
+};
+
+static void match_allocation(const char *fn, struct expression *expr,
+			     void *info)
+{
+	char *left_name;
+	struct symbol *left_sym;
+
+	left_name = expr_to_var_sym(expr->left, &left_sym);
+	if (!left_name || !left_sym)
+		goto free;
+	if (left_sym->ctype.modifiers & 
+	    (MOD_NONLOCAL | MOD_STATIC | MOD_ADDRESSABLE))
+		goto free;
+	add_tracker(&allocated, my_id, left_name, left_sym);
+free:
+	free_string(left_name);
+}
+
+static int returns_new_stuff = 0;
+static int returns_old_stuff = 0;
+static void match_return(struct expression *ret_value)
+{
+	char *name;
+	struct symbol *sym;
+	sval_t tmp;
+
+	if (__inline_fn)
+		return;
+	if (get_value(ret_value, &tmp) && tmp.value == 0)
+		return;
+	returns_new_stuff = 1;
+	name = expr_to_var_sym(ret_value, &sym);
+	if (!name || !sym) {
+		returns_old_stuff = 1;
+		goto free;
+	}
+	if (!in_tracker_list(allocated, my_id, name, sym))
+		returns_old_stuff = 1;
+free:
+	free_string(name);
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	if (returns_new_stuff && !returns_old_stuff)
+		sm_info("allocation func");
+	free_trackers_and_list(&allocated);
+	returns_new_stuff = 0;
+	returns_old_stuff = 0;
+}
+
+void check_allocation_funcs(int id)
+{
+	int i;
+
+	if (!option_info || option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_hook(&match_return, RETURN_HOOK);
+	add_hook(&match_end_func, AFTER_FUNC_HOOK);
+	for (i = 0; allocation_funcs[i]; i++) {
+		add_function_assign_hook(allocation_funcs[i],
+					 &match_allocation, NULL);
+	}
+}
diff --git a/usr/src/tools/smatch/src/check_array_condition.c b/usr/src/tools/smatch/src/check_array_condition.c
new file mode 100644
index 0000000000..7b9007100e
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_array_condition.c
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * struct foo { char buf[10]; };
+ *
+ * struct foo *p = something();
+ * if (p->buf) { ...
+ *
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_condition(struct expression *expr)
+{
+	struct symbol *type;
+	char *str;
+
+	if (expr->type != EXPR_DEREF)
+		return;
+	type = get_type(expr);
+	if (!type || type->type != SYM_ARRAY)
+		return;
+	if (get_macro_name(expr->pos))
+		return;
+
+	str = expr_to_str(expr);
+	sm_warning("this array is probably non-NULL. '%s'", str);
+	free_string(str);
+}
+
+void check_array_condition(int id)
+{
+	my_id = id;
+	add_hook(&match_condition, CONDITION_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_assign_vs_compare.c b/usr/src/tools/smatch/src/check_assign_vs_compare.c
new file mode 100644
index 0000000000..c6b075333b
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_assign_vs_compare.c
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void check_constant(struct expression *expr)
+{
+	sval_t val;
+
+	if (!get_value(expr->right, &val))
+		return;
+	sm_warning("was '== %s' instead of '='", sval_to_str(val));
+}
+
+static void check_address(struct expression *expr)
+{
+	char *str;
+	struct expression *right = strip_expr(expr->right);
+
+	if (!__cur_stmt || __cur_stmt->type != STMT_IF)
+		return;
+
+	if (right->type != EXPR_PREOP ||
+	    right->op != '&')
+		return;
+
+	if (get_macro_name(expr->pos))
+		return;
+
+	str = expr_to_str(right);
+	sm_warning("was '== %s' instead of '='", str);
+	free_string(str);
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (expr->type != EXPR_ASSIGNMENT || expr->op != '=')
+		return;
+
+	check_constant(expr);
+	check_address(expr);
+}
+
+void check_assign_vs_compare(int id)
+{
+	my_id = id;
+	add_hook(&match_condition, CONDITION_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_atomic_inc_dec.c b/usr/src/tools/smatch/src/check_atomic_inc_dec.c
new file mode 100644
index 0000000000..6474323eac
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_atomic_inc_dec.c
@@ -0,0 +1,248 @@
+/*
+ * Copyright (C) 2016 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(inc);
+STATE(orig);
+STATE(dec);
+
+static void db_inc_dec(struct expression *expr, int param, const char *key, const char *value, int inc_dec)
+{
+	struct smatch_state *start_state;
+	struct expression *arg;
+	char *name;
+	struct symbol *sym;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	start_state = get_state(my_id, name, sym);
+
+	if (inc_dec == ATOMIC_INC) {
+//		if (start_state == &inc)
+//			sm_error("XXX double increment '%s'", name);
+		set_state(my_id, name, sym, &inc);
+	} else {
+//		if (start_state == &dec)
+//			sm_error("XXX double decrement '%s'", name);
+		if (start_state == &inc)
+			set_state(my_id, name, sym, &orig);
+		else
+			set_state(my_id, name, sym, &dec);
+	}
+
+free:
+	free_string(name);
+}
+
+static void db_inc(struct expression *expr, int param, char *key, char *value)
+{
+	db_inc_dec(expr, param, key, value, ATOMIC_INC);
+}
+
+static void db_dec(struct expression *expr, int param, char *key, char *value)
+{
+	db_inc_dec(expr, param, key, value, ATOMIC_DEC);
+}
+
+static void match_atomic_inc(const char *fn, struct expression *expr, void *_unused)
+{
+	db_inc_dec(expr, 0, "$->counter", "", ATOMIC_INC);
+}
+
+static void match_atomic_dec(const char *fn, struct expression *expr, void *_unused)
+{
+	db_inc_dec(expr, 0, "$->counter", "", ATOMIC_DEC);
+}
+
+static void match_atomic_add(const char *fn, struct expression *expr, void *_unused)
+{
+	struct expression *amount;
+	sval_t sval;
+
+	amount = get_argument_from_call_expr(expr->args, 0);
+	if (get_implied_value(amount, &sval) && sval_is_negative(sval)) {
+		db_inc_dec(expr, 1, "$->counter", "", ATOMIC_DEC);
+		return;
+	}
+
+	db_inc_dec(expr, 1, "$->counter", "", ATOMIC_INC);
+}
+
+static void match_atomic_sub(const char *fn, struct expression *expr, void *_unused)
+{
+	db_inc_dec(expr, 1, "$->counter", "", ATOMIC_DEC);
+}
+
+static void refcount_inc(const char *fn, struct expression *expr, void *param)
+{
+	db_inc_dec(expr, PTR_INT(param), "$->ref.counter", "", ATOMIC_INC);
+}
+
+static void refcount_dec(const char *fn, struct expression *expr, void *param)
+{
+	db_inc_dec(expr, PTR_INT(param), "$->ref.counter", "", ATOMIC_DEC);
+}
+
+static void match_return_info(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *sm;
+	const char *param_name;
+	int param;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (sm->state != &inc &&
+		    sm->state != &dec)
+			continue;
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+		sql_insert_return_states(return_id, return_ranges,
+					 (sm->state == &inc) ? ATOMIC_INC : ATOMIC_DEC,
+					 param, param_name, "");
+	} END_FOR_EACH_SM(sm);
+}
+
+enum {
+	NEGATIVE, ZERO, POSITIVE,
+};
+
+static int success_fail_positive(struct range_list *rl)
+{
+	if (!rl)
+		return ZERO;
+
+	if (sval_is_negative(rl_min(rl)))
+		return NEGATIVE;
+
+	if (rl_min(rl).value == 0)
+		return ZERO;
+
+	return POSITIVE;
+}
+
+static void check_counter(const char *name, struct symbol *sym)
+{
+	struct range_list *inc_lines = NULL;
+	struct range_list *dec_lines = NULL;
+	int inc_buckets[3] = {};
+	struct stree *stree;
+	struct sm_state *return_sm;
+	struct sm_state *sm;
+	sval_t line = sval_type_val(&int_ctype, 0);
+
+	FOR_EACH_PTR(get_all_return_strees(), stree) {
+		return_sm = get_sm_state_stree(stree, RETURN_ID, "return_ranges", NULL);
+		if (!return_sm)
+			continue;
+		line.value = return_sm->line;
+
+		sm = get_sm_state_stree(stree, my_id, name, sym);
+		if (!sm)
+			continue;
+
+		if (sm->state != &inc && sm->state != &dec)
+			continue;
+
+		if (sm->state == &inc) {
+			add_range(&inc_lines, line, line);
+			inc_buckets[success_fail_positive(estate_rl(return_sm->state))] = 1;
+		}
+		if (sm->state == &dec)
+			add_range(&dec_lines, line, line);
+	} END_FOR_EACH_PTR(stree);
+
+	if (inc_buckets[NEGATIVE] &&
+	    inc_buckets[ZERO]) {
+		// sm_warning("XXX '%s' not decremented on lines: %s.", name, show_rl(inc_lines));
+	}
+
+}
+
+static void match_check_missed(struct symbol *sym)
+{
+	struct sm_state *sm;
+
+	FOR_EACH_MY_SM(my_id, get_all_return_states(), sm) {
+		check_counter(sm->name, sm->sym);
+	} END_FOR_EACH_SM(sm);
+}
+
+int on_atomic_dec_path(void)
+{
+	struct sm_state *sm;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (sm->state == &dec)
+			return 1;
+	} END_FOR_EACH_SM(sm);
+
+	return 0;
+}
+
+int was_inced(const char *name, struct symbol *sym)
+{
+	return get_state(my_id, name, sym) == &inc;
+}
+
+void check_atomic_inc_dec(int id)
+{
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	select_return_states_hook(ATOMIC_INC, &db_inc);
+	select_return_states_hook(ATOMIC_DEC, &db_dec);
+	add_function_hook("atomic_inc_return", &match_atomic_inc, NULL);
+	add_function_hook("atomic_add_return", &match_atomic_add, NULL);
+	add_function_hook("atomic_sub_return", &match_atomic_sub, NULL);
+	add_function_hook("atomic_sub_and_test", &match_atomic_sub, NULL);
+	add_function_hook("atomic_dec_and_test", &match_atomic_dec, NULL);
+	add_function_hook("_atomic_dec_and_lock", &match_atomic_dec, NULL);
+	add_function_hook("atomic_dec", &match_atomic_dec, NULL);
+	add_function_hook("atomic_long_inc", &match_atomic_inc, NULL);
+	add_function_hook("atomic_long_dec", &match_atomic_dec, NULL);
+	add_function_hook("atomic_inc", &match_atomic_inc, NULL);
+	add_function_hook("atomic_sub", &match_atomic_sub, NULL);
+	add_split_return_callback(match_return_info);
+
+	add_function_hook("refcount_add_not_zero", &refcount_inc, INT_PTR(1));
+	add_function_hook("refcount_inc_not_zero", &refcount_inc, INT_PTR(0));
+	add_function_hook("refcount_sub_and_test", &refcount_dec, INT_PTR(1));
+	add_function_hook("refcount_dec_and_test", &refcount_dec, INT_PTR(1));
+
+	add_hook(&match_check_missed, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_bit_shift.c b/usr/src/tools/smatch/src/check_bit_shift.c
new file mode 100644
index 0000000000..fe4ecee308
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_bit_shift.c
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This test is used to warn about mixups between bit shifters and bit flags.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_function_hashtable.h"
+
+static int my_id;
+
+static DEFINE_HASHTABLE_INSERT(insert_struct, char, int);
+static DEFINE_HASHTABLE_SEARCH(search_struct, char, int);
+static struct hashtable *shifters;
+
+static const char *get_shifter(struct expression *expr)
+{
+	const char *name;
+	sval_t expr_value;
+	const int *shifter_value;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_VALUE)
+		return NULL;
+	if (!get_value(expr, &expr_value))
+		return NULL;
+	name = pos_ident(expr->pos);
+	if (!name)
+		return NULL;
+	shifter_value = search_struct(shifters, (char *)name);
+	if (!shifter_value)
+		return NULL;
+	if (sval_cmp_val(expr_value, *shifter_value) != 0)
+		return NULL;
+	return name;
+}
+
+static void match_assign(struct expression *expr)
+{
+	const char *name;
+
+	if (expr->op != SPECIAL_OR_ASSIGN)
+		return;
+	if (positions_eq(expr->pos, expr->right->pos))
+		return;
+	name = get_shifter(expr->right);
+	if (!name)
+		return;
+
+	sm_warning("'%s' is a shifter (not for '%s').",
+			name, show_special(expr->op));
+}
+
+static void match_binop(struct expression *expr)
+{
+	const char *name;
+
+	if (positions_eq(expr->pos, expr->right->pos))
+		return;
+	if (expr->op != '&')
+		return;
+	name = get_shifter(expr->right);
+	if (!name)
+		return;
+
+	sm_warning("bit shifter '%s' used for logical '%s'",
+			name, show_special(expr->op));
+}
+
+static void register_shifters(void)
+{
+	char filename[256];
+	struct token *token;
+	char *name;
+	int *val;
+
+	snprintf(filename, sizeof(filename), "%s.bit_shifters", option_project_str);
+	token = get_tokens_file(filename);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		name = alloc_string(show_ident(token->ident));
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		val = malloc(sizeof(int));
+		*val = atoi(token->number);
+		insert_struct(shifters, name, val);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void match_binop_info(struct expression *expr)
+{
+	char *name;
+	sval_t sval;
+
+	if (positions_eq(expr->pos, expr->right->pos))
+		return;
+	if (expr->op != SPECIAL_LEFTSHIFT)
+		return;
+	if (expr->right->type != EXPR_VALUE)
+		return;
+	name = pos_ident(expr->right->pos);
+	if (!name)
+		return;
+	if (!get_value(expr->right, &sval))
+		return;
+	sm_msg("info: bit shifter '%s' '%s'", name, sval_to_str(sval));
+}
+
+static void match_call(const char *fn, struct expression *expr, void *_arg_no)
+{
+	struct expression *arg_expr;
+	int arg_no = PTR_INT(_arg_no);
+	sval_t sval;
+	char *name;
+
+	arg_expr = get_argument_from_call_expr(expr->args, arg_no);
+	if (positions_eq(expr->pos, arg_expr->pos))
+		return;
+	name = pos_ident(arg_expr->pos);
+	if (!name)
+		return;
+	if (!get_value(arg_expr, &sval))
+		return;
+	sm_msg("info: bit shifter '%s' '%s'", name, sval_to_str(sval));
+}
+
+void check_bit_shift(int id)
+{
+	my_id = id;
+
+	shifters = create_function_hashtable(5000);
+	register_shifters();
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_binop, BINOP_HOOK);
+
+	if (option_info) {
+		add_hook(&match_binop_info, BINOP_HOOK);
+		if (option_project == PROJ_KERNEL) {
+			add_function_hook("set_bit", &match_call, INT_PTR(0));
+			add_function_hook("test_bit", &match_call, INT_PTR(0));
+		}
+	}
+}
diff --git a/usr/src/tools/smatch/src/check_bogus_irqrestore.c b/usr/src/tools/smatch/src/check_bogus_irqrestore.c
new file mode 100644
index 0000000000..c47077a2f5
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_bogus_irqrestore.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2011 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_irqrestore(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg_expr;
+	sval_t tmp;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 1);
+	if (!get_implied_value(arg_expr, &tmp))
+		return;
+	sm_error("calling '%s()' with bogus flags", fn);
+}
+
+void check_bogus_irqrestore(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_function_hook("spin_unlock_irqrestore", &match_irqrestore, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_bogus_loop.c b/usr/src/tools/smatch/src/check_bogus_loop.c
new file mode 100644
index 0000000000..44d5ace25c
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_bogus_loop.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2011 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static int right_side_changes(struct expression *expr)
+{
+	sval_t dummy;
+
+	if (get_value(expr->right, &dummy))
+		return 0;
+	return 1;
+}
+
+static struct expression *get_iterator_set(struct statement *stmt)
+{
+	struct expression *expr;
+
+	if (!stmt)
+		return NULL;
+	if (stmt->type != STMT_EXPRESSION)
+		return NULL;
+	expr = stmt->expression;
+	if (expr->type != EXPR_ASSIGNMENT)
+		return NULL;
+	if (expr->op != '=')
+		return NULL;
+	if (right_side_changes(expr))
+		return NULL;
+	return expr->left;
+}
+
+static struct expression *get_iterator_tested(struct expression *expr)
+{
+	if (!expr)
+		return NULL;
+	if (expr->type != EXPR_COMPARE)
+		return NULL;
+	return expr->left;
+}
+
+static void match_loop(struct statement *stmt)
+{
+	struct expression *iterator;
+	char *iter_set;
+	char *iter_tested;
+
+	if (get_macro_name(stmt->pos))
+		return;
+
+	iterator = get_iterator_set(stmt->iterator_pre_statement);
+	iter_set = expr_to_var(iterator);
+	iterator = get_iterator_tested(stmt->iterator_pre_condition);
+	iter_tested = expr_to_var(iterator);
+	if (!iter_set || !iter_tested)
+		goto free;
+	if (strcmp(iter_set, iter_tested))
+		goto free;
+
+	/* smatch doesn't handle loops correctly so this silences some
+	 * false positives.
+	 */
+	if (right_side_changes(stmt->iterator_pre_condition))
+		goto free;
+
+	if (implied_condition_false(stmt->iterator_pre_condition))
+		sm_warning("we never enter this loop");
+
+free:
+	free_string(iter_set);
+	free_string(iter_tested);
+}
+
+void check_bogus_loop(int id)
+{
+	my_id = id;
+	add_hook(&match_loop, PRELOOP_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_buffer_too_small_for_struct.c b/usr/src/tools/smatch/src/check_buffer_too_small_for_struct.c
new file mode 100644
index 0000000000..06b69d89fa
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_buffer_too_small_for_struct.c
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+STATE(too_small);
+
+static void match_assign(struct expression *expr)
+{
+	struct symbol *left_type, *right_type;
+	struct expression *size_expr;
+	sval_t min_size;
+
+	left_type = get_type(expr->left);
+	if (!left_type || left_type->type != SYM_PTR)
+		return;
+	left_type = get_real_base_type(left_type);
+	if (!left_type || left_type->type != SYM_STRUCT)
+		return;
+
+	right_type = get_type(expr->right);
+	if (!right_type || right_type->type != SYM_PTR)
+		return;
+	right_type = get_real_base_type(right_type);
+	if (!right_type)
+		return;
+	if (right_type != &void_ctype && type_bits(right_type) != 8)
+		return;
+
+	size_expr = get_size_variable(expr->right);
+	if (!size_expr)
+		return;
+
+	get_absolute_min(size_expr, &min_size);
+	if (min_size.value >= type_bytes(left_type))
+		return;
+
+	set_state_expr(my_id, expr->left, &too_small);
+}
+
+static void match_dereferences(struct expression *expr)
+{
+	struct symbol *left_type;
+	struct expression *right;
+	struct smatch_state *state;
+	char *name;
+	struct expression *size_expr;
+	sval_t min_size;
+
+	if (expr->type != EXPR_PREOP)
+		return;
+
+	expr = strip_expr(expr->unop);
+	state = get_state_expr(my_id, expr);
+	if (state != &too_small)
+		return;
+
+	left_type = get_type(expr);
+	if (!left_type || left_type->type != SYM_PTR)
+		return;
+	left_type = get_real_base_type(left_type);
+	if (!left_type || left_type->type != SYM_STRUCT)
+		return;
+
+	right = get_assigned_expr(expr);
+	size_expr = get_size_variable(right);
+	if (!size_expr)
+		return;
+
+	get_absolute_min(size_expr, &min_size);
+	if (min_size.value >= type_bytes(left_type))
+		return;
+
+	name = expr_to_str(right);
+	sm_warning("is '%s' large enough for 'struct %s'? %s", name, left_type->ident ? left_type->ident->name : "<anon>", sval_to_str(min_size));
+	free_string(name);
+	set_state_expr(my_id, expr, &undefined);
+}
+
+void check_buffer_too_small_for_struct(int id)
+{
+	my_id = id;
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_dereferences, DEREF_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_call_tree.c b/usr/src/tools/smatch/src/check_call_tree.c
new file mode 100644
index 0000000000..b304fd7707
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_call_tree.c
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_call(struct expression *expr)
+{
+	char *fn_name;
+
+	fn_name = expr_to_var(expr->fn);
+	if (!fn_name)
+		return;
+	sm_prefix();
+	sm_printf("info: func_call (");
+	print_held_locks();
+	sm_printf(") %s\n", fn_name);
+	free_string(fn_name);
+}
+
+void check_call_tree(int id)
+{
+	if (!option_call_tree)
+		return;
+	my_id = id;
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_capable.c b/usr/src/tools/smatch/src/check_capable.c
new file mode 100644
index 0000000000..7366fa9c82
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_capable.c
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+STATE(capable);
+
+static int capable_id;
+static int ns_capable_id;
+
+static void match_capable(const char *fn, struct expression *expr, void *_param)
+{
+	struct expression *arg;
+	sval_t sval;
+	char buf[32];
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	if (!get_implied_value(arg, &sval))
+		return;
+	snprintf(buf, sizeof(buf), "%s", sval_to_str(sval));
+	set_state(capable_id, buf, NULL, &capable);
+}
+
+static void match_ns_capable(const char *fn, struct expression *expr, void *_param)
+{
+	struct expression *arg;
+	sval_t sval;
+	char buf[32];
+
+	if (get_function() && strcmp(get_function(), "capable") == 0)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, 1);
+	if (!get_implied_value(arg, &sval))
+		return;
+	snprintf(buf, sizeof(buf), "%s", sval_to_str(sval));
+	set_state(ns_capable_id, buf, NULL, &capable);
+}
+
+static void save_call_info(struct expression *call)
+{
+	struct sm_state *sm;
+
+	FOR_EACH_MY_SM(capable_id, __get_cur_stree(), sm) {
+		if (sm->state == &capable)
+			sql_insert_caller_info(call, CAPABLE, 0, sm->name, "");
+	} END_FOR_EACH_SM(sm);
+
+	FOR_EACH_MY_SM(ns_capable_id, __get_cur_stree(), sm) {
+		if (sm->state == &capable)
+			sql_insert_caller_info(call, NS_CAPABLE, 0, sm->name, "");
+	} END_FOR_EACH_SM(sm);
+}
+
+static void save_return_info(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *sm;
+
+	FOR_EACH_MY_SM(capable_id, __get_cur_stree(), sm) {
+		if (sm->state == &capable)
+			sql_insert_return_states(return_id, return_ranges,
+						 CAPABLE, 0, sm->name, "");
+	} END_FOR_EACH_SM(sm);
+
+	FOR_EACH_MY_SM(ns_capable_id, __get_cur_stree(), sm) {
+		if (sm->state == &capable)
+			sql_insert_return_states(return_id, return_ranges,
+						 CAPABLE, 0, sm->name, "");
+	} END_FOR_EACH_SM(sm);
+}
+
+static void set_db_capable(const char *name, struct symbol *sym, char *key, char *value)
+{
+	char buf[32];
+
+	snprintf(buf, sizeof(buf), "%s", key);
+	set_state(capable_id, buf, NULL, &capable);
+}
+
+static void set_db_ns_capable(const char *name, struct symbol *sym, char *key, char *value)
+{
+	char buf[32];
+
+	snprintf(buf, sizeof(buf), "%s", key);
+	set_state(ns_capable_id, buf, NULL, &capable);
+}
+
+void check_capable(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	capable_id = id;
+	add_function_hook("capable", &match_capable, INT_PTR(0));
+
+	add_hook(&save_call_info, FUNCTION_CALL_HOOK);
+	add_split_return_callback(save_return_info);
+	select_caller_info_hook(set_db_capable, CAPABLE);
+}
+
+void check_ns_capable(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	ns_capable_id = id;
+	add_function_hook("ns_capable", &match_ns_capable, INT_PTR(0));
+	select_caller_info_hook(set_db_ns_capable, NS_CAPABLE);
+}
diff --git a/usr/src/tools/smatch/src/check_cast_assign.c b/usr/src/tools/smatch/src/check_cast_assign.c
new file mode 100644
index 0000000000..589b6d46e2
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_cast_assign.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static struct symbol *get_cast_type(struct expression *expr)
+{
+	if (!expr || expr->type != EXPR_PREOP || expr->op != '*')
+		return NULL;
+	expr = strip_parens(expr->unop);
+	if (expr->type != EXPR_CAST)
+		return NULL;
+	return get_pointer_type(expr);
+}
+
+static void match_overflow(struct expression *expr)
+{
+	struct expression *ptr;
+	struct symbol *type;
+	int cast_size;
+	int data_size;
+
+	type = get_cast_type(expr->left);
+	if (!type)
+		return;
+	cast_size = type_bytes(type);
+
+	ptr = strip_expr(expr->left->unop);
+	data_size = get_array_size_bytes_min(ptr);
+	if (data_size <= 0)
+		return;
+	if (data_size >= cast_size)
+		return;
+	sm_warning("potential memory corrupting cast %d vs %d bytes",
+	       cast_size, data_size);
+}
+
+void check_cast_assign(int id)
+{
+	my_id = id;
+	add_hook(&match_overflow, ASSIGNMENT_HOOK);
+}
+
diff --git a/usr/src/tools/smatch/src/check_check_deref.c b/usr/src/tools/smatch/src/check_check_deref.c
new file mode 100644
index 0000000000..da2a5c942b
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_check_deref.c
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is like check_deref_check.c except that it complains about code like:
+ * if (a)
+ *        a->foo = 42;
+ * a->bar = 7;
+ *
+ * Of course, Smatch has complained about these for forever but the problem is
+ * the old scripts were too messy and complicated and generated too many false
+ * positives.
+ *
+ * This check is supposed to be simpler because it only looks for one kind of 
+ * null dereference bug instead of every kind.  It also gets rid of the false 
+ * positives caused by the checks that happen inside macros.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(null);
+STATE(ok);
+
+static void is_ok(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &ok);
+}
+
+static void check_dereference(struct expression *expr)
+{
+	struct sm_state *sm;
+	struct sm_state *tmp;
+
+	if (__in_fake_assign)
+		return;
+
+	expr = strip_expr(expr);
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return;
+	if (is_ignored(my_id, sm->name, sm->sym))
+		return;
+	if (implied_not_equal(expr, 0))
+		return;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->state == &merged)
+			continue;
+		if (tmp->state == &ok)
+			continue;
+		if (tmp->state == &null) {
+			sm_error("we previously assumed '%s' could be null (see line %d)",
+			       tmp->name, tmp->line);
+			add_ignore(my_id, sm->name, sm->sym);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void check_dereference_name_sym(char *name, struct symbol *sym)
+{
+	struct sm_state *sm;
+	struct sm_state *tmp;
+
+	sm = get_sm_state(my_id, name, sym);
+	if (!sm)
+		return;
+	if (is_ignored(my_id, sm->name, sm->sym))
+		return;
+	if (implied_not_equal_name_sym(name, sym, 0))
+		return;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->state == &merged)
+			continue;
+		if (tmp->state == &ok)
+			continue;
+		if (tmp->state == &null) {
+			sm_error("we previously assumed '%s' could be null (see line %d)",
+			       tmp->name, tmp->line);
+			add_ignore(my_id, sm->name, sm->sym);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void match_dereferences(struct expression *expr)
+{
+	if (expr->type != EXPR_PREOP)
+		return;
+	check_dereference(expr->unop);
+}
+
+static void match_pointer_as_array(struct expression *expr)
+{
+	if (!is_array(expr))
+		return;
+	check_dereference(get_array_base(expr));
+}
+
+static void set_param_dereferenced(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	check_dereference_name_sym(name, sym);
+free:
+	free_string(name);
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct smatch_state *true_state = NULL;
+
+	if (get_macro_name(expr->pos))
+		return;
+
+	if (!is_pointer(expr))
+		return;
+
+	if (expr->type == EXPR_ASSIGNMENT) {
+		match_condition(expr->right);
+		match_condition(expr->left);
+	}
+
+	if (implied_not_equal(expr, 0))
+		return;
+
+	if (get_state_expr(my_id, expr))
+		true_state = &ok;
+
+	set_true_false_states_expr(my_id, expr, true_state, &null);
+}
+
+void check_check_deref(int id)
+{
+	my_id = id;
+
+	add_modification_hook(my_id, &is_ok);
+	add_hook(&match_dereferences, DEREF_HOOK);
+	add_hook(&match_pointer_as_array, OP_HOOK);
+	select_return_implies_hook(DEREFERENCE, &set_param_dereferenced);
+	add_hook(&match_condition, CONDITION_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_container_of.c b/usr/src/tools/smatch/src/check_container_of.c
new file mode 100644
index 0000000000..411c987488
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_container_of.c
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Some macros don't return NULL pointers.  Complain if people
+ * check the results for NULL because obviously the programmers
+ * don't know what the pants they're doing.
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+STATE(non_null);
+
+static void is_ok(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &undefined);
+}
+
+static void match_non_null(const char *fn, struct expression *expr, void *unused)
+{
+	set_state_expr(my_id, expr->left, &non_null);
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (__in_pre_condition)
+		return;
+
+	if (get_macro_name(expr->pos))
+		return;
+
+	if (get_state_expr(my_id, expr) == &non_null) {
+		char *name;
+
+		name = expr_to_var(expr);
+		sm_warning("can '%s' even be NULL?", name);
+		set_state_expr(my_id, expr, &undefined);
+		free_string(name);
+	}
+}
+
+void check_container_of(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_macro_assign_hook("container_of", &match_non_null, NULL);
+	add_macro_assign_hook("list_first_entry", &match_non_null, NULL);
+	add_function_assign_hook("nla_data", &match_non_null, NULL);
+	add_modification_hook(my_id, &is_ok);
+	add_hook(&match_condition, CONDITION_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_continue_vs_break.c b/usr/src/tools/smatch/src/check_continue_vs_break.c
new file mode 100644
index 0000000000..c22ce0ed65
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_continue_vs_break.c
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2015 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * If you have code like:
+ * do {
+ *    if (xxx)
+ *        continue;
+ * while (0);
+ *
+ * Then the continue is equivalent of a break.  So what was really intended?
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static struct statement_list *iterator_stack;
+
+static int is_do_while_zero(struct statement *stmt)
+{
+	if (!stmt->iterator_post_condition)
+		return 0;
+	if (!is_zero(stmt->iterator_post_condition))
+		return 0;
+	return 1;
+}
+
+static void push_statement(struct statement_list **stack, struct statement *stmt)
+{
+	add_ptr_list(stack, stmt);
+}
+
+static void pop_statement(struct statement_list **stack)
+{
+	delete_ptr_list_last((struct ptr_list **)stack);
+}
+
+static int inside_do_while_zero(void)
+{
+	struct statement *stmt;
+
+	stmt = last_ptr_list((struct ptr_list *)iterator_stack);
+	return !!stmt;
+}
+
+static int loop_is_macro(void)
+{
+	struct statement *stmt;
+
+	stmt = last_ptr_list((struct ptr_list *)iterator_stack);
+	if (!stmt)
+		return 0;
+	if (get_macro_name(stmt->iterator_post_condition->pos))
+		return 1;
+	return 0;
+}
+
+static void match_stmt(struct statement *stmt)
+{
+	if (stmt->type != STMT_ITERATOR)
+		return;
+
+	if (is_do_while_zero(stmt)) {
+		push_statement(&iterator_stack, stmt);
+	} else
+		push_statement(&iterator_stack, NULL);
+}
+
+static void match_stmt_after(struct statement *stmt)
+{
+	if (stmt->type != STMT_ITERATOR)
+		return;
+
+	pop_statement(&iterator_stack);
+}
+
+static void match_inline_start(struct expression *expr)
+{
+	push_statement(&iterator_stack, NULL);
+}
+
+static void match_inline_end(struct expression *expr)
+{
+	pop_statement(&iterator_stack);
+}
+
+static void match_continue(struct statement *stmt)
+{
+	if (stmt->type != STMT_GOTO)
+		return;
+
+	if (!stmt->goto_label || stmt->goto_label->type != SYM_NODE)
+		return;
+	if (strcmp(stmt->goto_label->ident->name, "continue") != 0)
+		return;
+	if (!inside_do_while_zero())
+		return;
+	if (loop_is_macro())
+		return;
+	sm_warning("continue to end of do { ... } while(0); loop");
+}
+
+void check_continue_vs_break(int id)
+{
+	my_id = id;
+	add_hook(&match_stmt, STMT_HOOK);
+	add_hook(&match_stmt_after, STMT_HOOK_AFTER);
+	add_hook(&match_inline_start, INLINE_FN_START);
+	add_hook(&match_inline_end, INLINE_FN_END);
+
+	add_hook(&match_continue, STMT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_debug.c b/usr/src/tools/smatch/src/check_debug.c
new file mode 100644
index 0000000000..0defd2bfad
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_debug.c
@@ -0,0 +1,772 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+int local_debug;
+static int my_id;
+char *trace_variable;
+
+static void match_all_values(const char *fn, struct expression *expr, void *info)
+{
+	struct stree *stree;
+
+	stree = get_all_states_stree(SMATCH_EXTRA);
+	__print_stree(stree);
+	free_stree(&stree);
+}
+
+static void match_cur_stree(const char *fn, struct expression *expr, void *info)
+{
+	__print_cur_stree();
+}
+
+static void match_state(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *check_arg, *state_arg;
+	struct sm_state *sm;
+	int found = 0;
+
+	check_arg = get_argument_from_call_expr(expr->args, 0);
+	if (check_arg->type != EXPR_STRING) {
+		sm_error("the check_name argument to %s is supposed to be a string literal", fn);
+		return;
+	}
+	state_arg = get_argument_from_call_expr(expr->args, 1);
+	if (!state_arg || state_arg->type != EXPR_STRING) {
+		sm_error("the state_name argument to %s is supposed to be a string literal", fn);
+		return;
+	}
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (strcmp(check_name(sm->owner), check_arg->string->data) != 0)
+			continue;
+		if (strcmp(sm->name, state_arg->string->data) != 0)
+			continue;
+		sm_msg("'%s' = '%s'", sm->name, sm->state->name);
+		found = 1;
+	} END_FOR_EACH_SM(sm);
+
+	if (!found)
+		sm_msg("%s '%s' not found", check_arg->string->data, state_arg->string->data);
+}
+
+static void match_states(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *check_arg;
+	struct sm_state *sm;
+	int found = 0;
+
+	check_arg = get_argument_from_call_expr(expr->args, 0);
+	if (check_arg->type != EXPR_STRING) {
+		sm_error("the check_name argument to %s is supposed to be a string literal", fn);
+		return;
+	}
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (strcmp(check_name(sm->owner), check_arg->string->data) != 0)
+			continue;
+		sm_msg("%s", show_sm(sm));
+		found = 1;
+	} END_FOR_EACH_SM(sm);
+
+	if (found)
+		return;
+
+	if (!id_from_name(check_arg->string->data))
+		sm_msg("invalid check name '%s'", check_arg->string->data);
+	else
+		sm_msg("%s: no states", check_arg->string->data);
+}
+
+static void match_print_value(const char *fn, struct expression *expr, void *info)
+{
+	struct stree *stree;
+	struct sm_state *tmp;
+	struct expression *arg_expr;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 0);
+	if (arg_expr->type != EXPR_STRING) {
+		sm_error("the argument to %s is supposed to be a string literal", fn);
+		return;
+	}
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
+		if (!strcmp(tmp->name, arg_expr->string->data))
+			sm_msg("%s = %s", tmp->name, tmp->state->name);
+	} END_FOR_EACH_SM(tmp);
+}
+
+static void match_print_known(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	struct range_list *rl = NULL;
+	char *name;
+	int known = 0;
+	sval_t sval;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	if (get_value(arg, &sval))
+		known = 1;
+
+	get_implied_rl(arg, &rl);
+
+	name = expr_to_str(arg);
+	sm_msg("known: '%s' = '%s'.  implied = '%s'", name, known ? sval_to_str(sval) : "<unknown>", show_rl(rl));
+	free_string(name);
+}
+
+static void match_print_implied(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	struct range_list *rl = NULL;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	get_implied_rl(arg, &rl);
+
+	name = expr_to_str(arg);
+	sm_msg("implied: %s = '%s'", name, show_rl(rl));
+	free_string(name);
+}
+
+static void match_real_absolute(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	struct range_list *rl = NULL;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	get_real_absolute_rl(arg, &rl);
+
+	name = expr_to_str(arg);
+	sm_msg("real absolute: %s = '%s'", name, show_rl(rl));
+	free_string(name);
+}
+
+static void match_print_implied_min(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	sval_t sval;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+
+	if (get_implied_min(arg, &sval))
+		sm_msg("implied min: %s = %s", name, sval_to_str(sval));
+	else
+		sm_msg("implied min: %s = <unknown>", name);
+
+	free_string(name);
+}
+
+static void match_print_implied_max(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	sval_t sval;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+
+	if (get_implied_max(arg, &sval))
+		sm_msg("implied max: %s = %s", name, sval_to_str(sval));
+	else
+		sm_msg("implied max: %s = <unknown>", name);
+
+	free_string(name);
+}
+
+static void match_user_rl(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	struct range_list *rl;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+
+	get_user_rl(arg, &rl);
+	sm_msg("user rl: '%s' = '%s'", name, show_rl(rl));
+
+	free_string(name);
+}
+
+static void match_capped(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+	sm_msg("'%s' = '%s'", name, is_capped(arg) ? "capped" : "not capped");
+	free_string(name);
+}
+
+static void match_print_hard_max(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	sval_t sval;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+
+	if (get_hard_max(arg, &sval))
+		sm_msg("hard max: %s = %s", name, sval_to_str(sval));
+	else
+		sm_msg("hard max: %s = <unknown>", name);
+
+	free_string(name);
+}
+
+static void match_print_fuzzy_max(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	sval_t sval;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+
+	if (get_fuzzy_max(arg, &sval))
+		sm_msg("fuzzy max: %s = %s", name, sval_to_str(sval));
+	else
+		sm_msg("fuzzy max: %s = <unknown>", name);
+
+	free_string(name);
+}
+
+static void match_print_absolute(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	struct range_list *rl;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+
+	get_absolute_rl(arg, &rl);
+	sm_msg("absolute: %s = %s", name, show_rl(rl));
+
+	free_string(name);
+}
+
+static void match_print_absolute_min(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	sval_t sval;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+
+	if (get_absolute_min(arg, &sval))
+		sm_msg("absolute min: %s = %s", name, sval_to_str(sval));
+	else
+		sm_msg("absolute min: %s = <unknown>", name);
+
+	free_string(name);
+}
+
+static void match_print_absolute_max(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	sval_t sval;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	get_absolute_max(arg, &sval);
+
+	name = expr_to_str(arg);
+	sm_msg("absolute max: %s = %s", name, sval_to_str(sval));
+	free_string(name);
+}
+
+static void match_sval_info(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	sval_t sval;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+
+	if (!get_implied_value(arg, &sval)) {
+		sm_msg("no sval for '%s'", name);
+		goto free;
+	}
+
+	sm_msg("implied: %s %c%d ->value = %llx", name, sval_unsigned(sval) ? 'u' : 's', sval_bits(sval), sval.value);
+free:
+	free_string(name);
+}
+
+static void match_member_name(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	char *name, *member_name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+	member_name = get_member_name(arg);
+	sm_msg("member name: '%s => %s'", name, member_name);
+	free_string(member_name);
+	free_string(name);
+}
+
+static void print_possible(struct sm_state *sm)
+{
+	struct sm_state *tmp;
+
+	sm_msg("Possible values for %s", sm->name);
+	FOR_EACH_PTR(sm->possible, tmp) {
+		printf("%s\n", tmp->state->name);
+	} END_FOR_EACH_PTR(tmp);
+	sm_msg("===");
+}
+
+static void match_possible(const char *fn, struct expression *expr, void *info)
+{
+	struct stree *stree;
+	struct sm_state *tmp;
+	struct expression *arg_expr;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 0);
+	if (arg_expr->type != EXPR_STRING) {
+		sm_error("the argument to %s is supposed to be a string literal", fn);
+		return;
+	}
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
+		if (!strcmp(tmp->name, arg_expr->string->data))
+			print_possible(tmp);
+	} END_FOR_EACH_SM(tmp);
+}
+
+static void match_strlen(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	struct range_list *rl;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	get_implied_strlen(arg, &rl);
+
+	name = expr_to_str(arg);
+	sm_msg("strlen: '%s' %s characters", name, show_rl(rl));
+	free_string(name);
+}
+
+static void match_buf_size(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg, *comp;
+	struct range_list *rl;
+	int elements, bytes;
+	char *name;
+	char buf[256] = "";
+	int n;
+	sval_t sval;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+
+	elements = get_array_size(arg);
+	bytes = get_array_size_bytes_max(arg);
+	rl = get_array_size_bytes_rl(arg);
+	comp = get_size_variable(arg);
+
+	name = expr_to_str(arg);
+	n = snprintf(buf, sizeof(buf), "buf size: '%s' %d elements, %d bytes", name, elements, bytes);
+	free_string(name);
+
+	if (!rl_to_sval(rl, &sval))
+		n += snprintf(buf + n, sizeof(buf) - n, " (rl = %s)", show_rl(rl));
+
+	if (comp) {
+		name = expr_to_str(comp);
+		snprintf(buf + n, sizeof(buf) - n, "[size_var=%s]", name);
+		free_string(name);
+	}
+	sm_msg("%s", buf);
+}
+
+static void match_note(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg_expr;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 0);
+	if (arg_expr->type != EXPR_STRING) {
+		sm_error("the argument to %s is supposed to be a string literal", fn);
+		return;
+	}
+	sm_msg("%s", arg_expr->string->data);
+}
+
+static void print_related(struct sm_state *sm)
+{
+	struct relation *rel;
+
+	if (!estate_related(sm->state))
+		return;
+
+	sm_prefix();
+	sm_printf("%s: ", sm->name);
+	FOR_EACH_PTR(estate_related(sm->state), rel) {
+		sm_printf("%s ", rel->name);
+	} END_FOR_EACH_PTR(rel);
+	sm_printf("\n");
+}
+
+static void match_dump_related(const char *fn, struct expression *expr, void *info)
+{
+	struct stree *stree;
+	struct sm_state *tmp;
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
+		print_related(tmp);
+	} END_FOR_EACH_SM(tmp);
+}
+
+static void match_compare(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *one, *two;
+	char *one_name, *two_name;
+	int comparison;
+	char buf[16];
+
+	one = get_argument_from_call_expr(expr->args, 0);
+	two = get_argument_from_call_expr(expr->args, 1);
+
+	comparison = get_comparison(one, two);
+	if (!comparison)
+		snprintf(buf, sizeof(buf), "<none>");
+	else
+		snprintf(buf, sizeof(buf), "%s", show_special(comparison));
+
+	one_name = expr_to_str(one);
+	two_name = expr_to_str(two);
+
+	sm_msg("%s %s %s", one_name, buf, two_name);
+
+	free_string(one_name);
+	free_string(two_name);
+}
+
+static void match_debug_on(const char *fn, struct expression *expr, void *info)
+{
+	option_debug = 1;
+}
+
+static void match_debug_check(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	if (!arg || arg->type != EXPR_STRING)
+		return;
+	option_debug_check = arg->string->data;
+	sm_msg("arg = '%s'", option_debug_check);
+}
+
+static void match_debug_off(const char *fn, struct expression *expr, void *info)
+{
+	option_debug_check = (char *)"";
+	option_debug = 0;
+}
+
+static void match_local_debug_on(const char *fn, struct expression *expr, void *info)
+{
+	local_debug = 1;
+}
+
+static void match_local_debug_off(const char *fn, struct expression *expr, void *info)
+{
+	local_debug = 0;
+}
+
+static void match_debug_implied_on(const char *fn, struct expression *expr, void *info)
+{
+	option_debug_implied = 1;
+}
+
+static void match_debug_implied_off(const char *fn, struct expression *expr, void *info)
+{
+	option_debug_implied = 0;
+}
+
+static void match_about(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	struct sm_state *sm;
+	char *name;
+
+	sm_msg("---- about ----");
+	match_print_implied(fn, expr, NULL);
+	match_buf_size(fn, expr, NULL);
+	match_strlen(fn, expr, NULL);
+	match_real_absolute(fn, expr, NULL);
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+	if (!name) {
+		sm_msg("info: not a straight forward variable.");
+		return;
+	}
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (strcmp(sm->name, name) != 0)
+			continue;
+		sm_msg("%s", show_sm(sm));
+	} END_FOR_EACH_SM(sm);
+}
+
+static void match_intersection(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *one, *two;
+	struct range_list *one_rl, *two_rl;
+	struct range_list *res;
+
+	one = get_argument_from_call_expr(expr->args, 0);
+	two = get_argument_from_call_expr(expr->args, 1);
+
+	get_absolute_rl(one, &one_rl);
+	get_absolute_rl(two, &two_rl);
+
+	res = rl_intersection(one_rl, two_rl);
+	sm_msg("'%s' intersect '%s' is '%s'", show_rl(one_rl), show_rl(two_rl), show_rl(res));
+}
+
+static void match_type(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *one;
+	struct symbol *type;
+	char *name;
+
+	one = get_argument_from_call_expr(expr->args, 0);
+	type = get_type(one);
+	name = expr_to_str(one);
+	sm_msg("type of '%s' is: '%s'", name, type_to_str(type));
+	free_string(name);
+}
+
+static int match_type_rl_return(struct expression *call, void *unused, struct range_list **rl)
+{
+	struct expression *one, *two;
+	struct symbol *type;
+
+	one = get_argument_from_call_expr(call->args, 0);
+	type = get_type(one);
+
+	two = get_argument_from_call_expr(call->args, 1);
+	if (!two || two->type != EXPR_STRING) {
+		sm_msg("expected: __smatch_type_rl(type, \"string\")");
+		return 0;
+	}
+	call_results_to_rl(call, type, two->string->data, rl);
+	return 1;
+}
+
+static void print_left_right(struct sm_state *sm)
+{
+	if (!sm)
+		return;
+	if (!sm->left && !sm->right)
+		return;
+
+	sm_printf("[ ");
+	if (sm->left)
+		sm_printf("(%d: %s->'%s')", get_stree_id(sm->left->pool),  sm->left->name, sm->left->state->name);
+	else
+		sm_printf(" - ");
+
+
+	print_left_right(sm->left);
+
+	if (sm->right)
+		sm_printf("(%d: %s->'%s')", get_stree_id(sm->right->pool),  sm->right->name, sm->right->state->name);
+	else
+		sm_printf(" - ");
+
+	print_left_right(sm->right);
+}
+
+static void match_print_merge_tree(const char *fn, struct expression *expr, void *info)
+{
+	struct sm_state *sm;
+	struct expression *arg;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+
+	sm = get_sm_state_expr(SMATCH_EXTRA, arg);
+	if (!sm) {
+		sm_msg("no sm state for '%s'", name);
+		goto free;
+	}
+
+	sm_prefix();
+	sm_printf("merge tree: %s -> %s", name, sm->state->name);
+	print_left_right(sm);
+	sm_printf("\n");
+
+free:
+	free_string(name);
+}
+
+static void match_print_stree_id(const char *fn, struct expression *expr, void *info)
+{
+	sm_msg("stree_id %d", __stree_id);
+}
+
+static void match_mtag(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	char *name;
+	mtag_t tag = 0;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+	get_mtag(arg, &tag);
+	sm_msg("mtag: '%s' => tag: %lld", name, tag);
+	free_string(name);
+}
+
+static void match_mtag_data_offset(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *arg;
+	char *name;
+	mtag_t tag = 0;
+	int offset = -1;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	name = expr_to_str(arg);
+	expr_to_mtag_offset(arg, &tag, &offset);
+	sm_msg("mtag: '%s' => tag: %lld, offset: %d", name, tag, offset);
+	free_string(name);
+}
+
+static void match_state_count(const char *fn, struct expression *expr, void *info)
+{
+	sm_msg("state_count = %d\n", sm_state_counter);
+}
+
+static void match_mem(const char *fn, struct expression *expr, void *info)
+{
+	show_sname_alloc();
+	show_ptrlist_alloc();
+	sm_msg("%lu pools", get_pool_count());
+	sm_msg("%d strees", unfree_stree);
+	show_smatch_state_alloc();
+	show_sm_state_alloc();
+}
+
+static void match_exit(const char *fn, struct expression *expr, void *info)
+{
+	exit(0);
+}
+
+static struct stree *old_stree;
+static void trace_var(struct statement *stmt)
+{
+	struct sm_state *sm, *old;
+	int printed = 0;
+
+	if (!trace_variable)
+		return;
+	if (__inline_fn)
+		return;
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (strcmp(sm->name, trace_variable) != 0)
+			continue;
+		old = get_sm_state_stree(old_stree, sm->owner, sm->name, sm->sym);
+		if (old && old->state == sm->state)
+			continue;
+		sm_msg("[%d] %s '%s': '%s' => '%s'", stmt->type,
+		       check_name(sm->owner),
+		       sm->name, old ? old->state->name : "<none>", sm->state->name);
+		printed = 1;
+	} END_FOR_EACH_SM(sm);
+
+	if (printed) {
+		free_stree(&old_stree);
+		old_stree = clone_stree(__get_cur_stree());
+	}
+}
+
+static void free_old_stree(struct symbol *sym)
+{
+	free_stree(&old_stree);
+}
+
+void check_debug(int id)
+{
+	my_id = id;
+	add_function_hook("__smatch_about", &match_about, NULL);
+	add_function_hook("__smatch_all_values", &match_all_values, NULL);
+	add_function_hook("__smatch_state", &match_state, NULL);
+	add_function_hook("__smatch_states", &match_states, NULL);
+	add_function_hook("__smatch_value", &match_print_value, NULL);
+	add_function_hook("__smatch_known", &match_print_known, NULL);
+	add_function_hook("__smatch_implied", &match_print_implied, NULL);
+	add_function_hook("__smatch_implied_min", &match_print_implied_min, NULL);
+	add_function_hook("__smatch_implied_max", &match_print_implied_max, NULL);
+	add_function_hook("__smatch_user_rl", &match_user_rl, NULL);
+	add_function_hook("__smatch_capped", &match_capped, NULL);
+	add_function_hook("__smatch_hard_max", &match_print_hard_max, NULL);
+	add_function_hook("__smatch_fuzzy_max", &match_print_fuzzy_max, NULL);
+	add_function_hook("__smatch_absolute", &match_print_absolute, NULL);
+	add_function_hook("__smatch_absolute_min", &match_print_absolute_min, NULL);
+	add_function_hook("__smatch_absolute_max", &match_print_absolute_max, NULL);
+	add_function_hook("__smatch_real_absolute", &match_real_absolute, NULL);
+	add_function_hook("__smatch_sval_info", &match_sval_info, NULL);
+	add_function_hook("__smatch_member_name", &match_member_name, NULL);
+	add_function_hook("__smatch_possible", &match_possible, NULL);
+	add_function_hook("__smatch_cur_stree", &match_cur_stree, NULL);
+	add_function_hook("__smatch_strlen", &match_strlen, NULL);
+	add_function_hook("__smatch_buf_size", &match_buf_size, NULL);
+	add_function_hook("__smatch_note", &match_note, NULL);
+	add_function_hook("__smatch_dump_related", &match_dump_related, NULL);
+	add_function_hook("__smatch_compare", &match_compare, NULL);
+	add_function_hook("__smatch_debug_on", &match_debug_on, NULL);
+	add_function_hook("__smatch_debug_check", &match_debug_check, NULL);
+	add_function_hook("__smatch_debug_off", &match_debug_off, NULL);
+	add_function_hook("__smatch_local_debug_on", &match_local_debug_on, NULL);
+	add_function_hook("__smatch_local_debug_off", &match_local_debug_off, NULL);
+	add_function_hook("__smatch_debug_implied_on", &match_debug_implied_on, NULL);
+	add_function_hook("__smatch_debug_implied_off", &match_debug_implied_off, NULL);
+	add_function_hook("__smatch_intersection", &match_intersection, NULL);
+	add_function_hook("__smatch_type", &match_type, NULL);
+	add_implied_return_hook("__smatch_type_rl_helper", &match_type_rl_return, NULL);
+	add_function_hook("__smatch_merge_tree", &match_print_merge_tree, NULL);
+	add_function_hook("__smatch_stree_id", &match_print_stree_id, NULL);
+	add_function_hook("__smatch_mtag", &match_mtag, NULL);
+	add_function_hook("__smatch_mtag_data", &match_mtag_data_offset, NULL);
+	add_function_hook("__smatch_state_count", &match_state_count, NULL);
+	add_function_hook("__smatch_mem", &match_mem, NULL);
+	add_function_hook("__smatch_exit", &match_exit, NULL);
+
+	add_hook(free_old_stree, AFTER_FUNC_HOOK);
+	add_hook(trace_var, STMT_HOOK_AFTER);
+}
diff --git a/usr/src/tools/smatch/src/check_debug.h b/usr/src/tools/smatch/src/check_debug.h
new file mode 100644
index 0000000000..8e6a97f4e4
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_debug.h
@@ -0,0 +1,77 @@
+#ifndef __SMATCH_CHECK_DEBUG
+#define __SMATCH_CHECK_DEBUG
+
+static inline void __smatch_about(long var){}
+
+static inline void __smatch_cur_stree(void){}
+static inline void __smatch_all_values(void){}
+static inline void __smatch_state(const char *check_name, const char *state_name){}
+static inline void __smatch_states(const char *check_name){}
+static inline void __smatch_value(const char *unused){}
+static inline void __smatch_known(long long val){}
+static inline void __smatch_implied(long long val){}
+static inline void __smatch_implied_min(long long val){}
+static inline void __smatch_implied_max(long long val){}
+static inline void __smatch_user_rl(long long val){}
+static inline void __smatch_capped(long long val){}
+
+static inline void __smatch_hard_max(long long val){}
+static inline void __smatch_fuzzy_max(long long val){}
+
+static inline void __smatch_absolute(long long val){}
+static inline void __smatch_absolute_min(long long val){}
+static inline void __smatch_absolute_max(long long val){}
+static inline void __smatch_real_absolute(long long val){}
+
+static inline void __smatch_sval_info(long long val){}
+
+static inline void __smatch_member_name(long long val){}
+
+static inline void __smatch_possible(const char *unused){}
+static inline void __smatch_print_value(const char *unused){}
+
+static inline void __smatch_strlen(const void *buf){}
+static inline void __smatch_buf_size(const void *buf){}
+
+static inline void __smatch_note(const char *note){}
+
+static inline void __smatch_dump_related(void){}
+
+static inline void __smatch_compare(long long one, long long two){}
+
+static inline void __smatch_debug_on(void){}
+static inline void __smatch_debug_check(const char *check_name){}
+static inline void __smatch_debug_off(void){}
+
+static inline void __smatch_local_debug_on(void){}
+static inline void __smatch_local_debug_off(void){}
+
+static inline void __smatch_debug_implied_on(void){}
+static inline void __smatch_debug_implied_off(void){}
+
+static inline void __smatch_intersection(long long one, long long two){}
+static inline void __smatch_type(long long one){}
+
+static long long __smatch_val;
+static inline long long __smatch_type_rl_helper(long long type, const char *str, ...)
+{
+	return __smatch_val;
+}
+#define __smatch_type_rl(type, fmt...) __smatch_type_rl_helper((type)0, fmt)
+#define __smatch_rl(fmt...) __smatch_type_rl(long long, fmt)
+
+static inline void __smatch_bit_info(long long expr){}
+
+static inline void __smatch_oops(unsigned long null_val){}
+
+static inline void __smatch_merge_tree(long long var){}
+
+static inline void __smatch_stree_id(void){}
+
+static inline void __smatch_mtag(void *p){}
+static inline void __smatch_mtag_data(long long arg){}
+static inline void __smatch_exit(void){}
+
+static inline void __smatch_state_count(void){}
+static inline void __smatch_mem(void){}
+#endif
diff --git a/usr/src/tools/smatch/src/check_deref.c b/usr/src/tools/smatch/src/check_deref.c
new file mode 100644
index 0000000000..d8777db233
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_deref.c
@@ -0,0 +1,296 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * There was a previous null dereference test but it was too confusing and
+ * difficult to debug.  This test is much simpler in its goals and scope.
+ *
+ * This test only complains about:
+ * 1) dereferencing uninitialized variables
+ * 2) dereferencing variables which were assigned as null.
+ * 3) dereferencing variables which were assigned a function the returns 
+ *    null.
+ *
+ * If we dereference something then we complain if any of those three
+ * are possible.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+#define __GFP_NOFAIL 0x800
+
+STATE(null);
+STATE(ok);
+STATE(uninitialized);
+
+static struct smatch_state *alloc_my_state(const char *name)
+{
+	struct smatch_state *state;
+
+	state = __alloc_smatch_state(0);
+	state->name = name;
+	return state;
+}
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	return &ok;
+}
+
+static void is_ok(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &ok);
+}
+
+static void check_dereference(struct expression *expr)
+{
+	struct sm_state *sm;
+	struct sm_state *tmp;
+
+	expr = strip_expr(expr);
+	if (is_static(expr))
+		return;
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return;
+	if (is_ignored(my_id, sm->name, sm->sym))
+		return;
+	if (implied_not_equal(expr, 0))
+		return;
+	if (is_impossible_path())
+		return;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->state == &merged)
+			continue;
+		if (tmp->state == &ok)
+			continue;
+		add_ignore(my_id, sm->name, sm->sym);
+		if (tmp->state == &null) {
+			if (option_spammy)
+				sm_error("potential NULL dereference '%s'.", tmp->name);
+			return;
+		}
+		if (tmp->state == &uninitialized) {
+			if (option_spammy)
+				sm_error("potentially dereferencing uninitialized '%s'.", tmp->name);
+			return;
+		}
+		sm_error("potential null dereference '%s'.  (%s returns null)",
+			tmp->name, tmp->state->name);
+		return;
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void check_dereference_name_sym(char *name, struct symbol *sym)
+{
+	struct sm_state *sm;
+	struct sm_state *tmp;
+
+	sm = get_sm_state(my_id, name, sym);
+	if (!sm)
+		return;
+	if (is_ignored(my_id, sm->name, sm->sym))
+		return;
+	if (implied_not_equal_name_sym(name, sym, 0))
+		return;
+	if (is_impossible_path())
+		return;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->state == &merged)
+			continue;
+		if (tmp->state == &ok)
+			continue;
+		add_ignore(my_id, sm->name, sm->sym);
+		if (tmp->state == &null) {
+			if (option_spammy)
+				sm_error("potential NULL dereference '%s'.", tmp->name);
+			return;
+		}
+		if (tmp->state == &uninitialized) {
+			if (option_spammy)
+				sm_error("potentially dereferencing uninitialized '%s'.", tmp->name);
+			return;
+		}
+		sm_error("potential null dereference '%s'.  (%s returns null)",
+			tmp->name, tmp->state->name);
+		return;
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void match_dereferences(struct expression *expr)
+{
+	if (expr->type != EXPR_PREOP)
+		return;
+	check_dereference(expr->unop);
+}
+
+static void match_pointer_as_array(struct expression *expr)
+{
+	if (!is_array(expr))
+		return;
+	check_dereference(get_array_base(expr));
+}
+
+static void set_param_dereferenced(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	check_dereference_name_sym(name, sym);
+free:
+	free_string(name);
+}
+
+static void match_declarations(struct symbol *sym)
+{
+	const char *name;
+
+	if ((get_base_type(sym))->type == SYM_ARRAY)
+		return;
+
+	if (!sym->ident)
+		return;
+	name = sym->ident->name;
+	if (!sym->initializer) {
+		set_state(my_id, name, sym, &uninitialized);
+		scoped_state(my_id, name, sym);
+	}
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct statement *stmt;
+
+	if (!is_zero(expr->right))
+		return;
+
+	if (__in_fake_assign)
+		return;
+
+	FOR_EACH_PTR_REVERSE(big_statement_stack, stmt) {
+		if (stmt->type == STMT_DECLARATION)
+			return;
+		break;
+	} END_FOR_EACH_PTR_REVERSE(stmt);
+
+	set_state_expr(my_id, expr->left, &null);
+}
+
+static void match_assigns_address(struct expression *expr)
+{
+	struct expression *right;
+
+	right = strip_expr(expr->right);
+	if (right->type != EXPR_PREOP || right->op != '&')
+		return;
+	set_state_expr(my_id, right, &ok);
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (expr->type == EXPR_ASSIGNMENT) {
+		match_condition(expr->right);
+		match_condition(expr->left);
+	}
+	if (!get_state_expr(my_id, expr))
+		return;
+	set_true_false_states_expr(my_id, expr, &ok, NULL);
+}
+
+static int called_with_no_fail(struct expression *call, int param)
+{
+	struct expression *arg;
+	sval_t sval;
+
+	if (param == -1)
+		return 0;
+	call = strip_expr(call);
+	if (call->type != EXPR_CALL)
+		return 0;
+	arg = get_argument_from_call_expr(call->args, param);
+	if (get_value(arg, &sval) && (sval.uvalue & __GFP_NOFAIL))
+		return 1;
+	return 0;
+}
+
+static void match_assign_returns_null(const char *fn, struct expression *expr, void *_gfp)
+{
+	struct smatch_state *state;
+	int gfp_param = PTR_INT(_gfp);
+
+	if (called_with_no_fail(expr->right, gfp_param))
+		return;
+	state = alloc_my_state(fn);
+	set_state_expr(my_id, expr->left, state);
+}
+
+static void register_allocation_funcs(void)
+{
+	struct token *token;
+	const char *func;
+	int arg;
+
+	token = get_tokens_file("kernel.allocation_funcs_gfp");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		token = token->next;
+		if (token_type(token) == TOKEN_IDENT)
+			arg = -1;
+		else if (token_type(token) == TOKEN_NUMBER)
+			arg = atoi(token->number);
+		else
+			return;
+		add_function_assign_hook(func, &match_assign_returns_null, INT_PTR(arg));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_deref(int id)
+{
+	my_id = id;
+
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	add_modification_hook(my_id, &is_ok);
+	add_hook(&match_dereferences, DEREF_HOOK);
+	add_hook(&match_pointer_as_array, OP_HOOK);
+	select_return_implies_hook(DEREFERENCE, &set_param_dereferenced);
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_declarations, DECLARATION_HOOK);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_assigns_address, ASSIGNMENT_HOOK);
+	if (option_project == PROJ_KERNEL)
+		register_allocation_funcs();
+}
diff --git a/usr/src/tools/smatch/src/check_deref_check.c b/usr/src/tools/smatch/src/check_deref_check.c
new file mode 100644
index 0000000000..a06cc8bdc0
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_deref_check.c
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(derefed);
+
+static void underef(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &undefined);
+}
+
+static void match_dereference(struct expression *expr)
+{
+	if (__in_fake_assign)
+		return;
+
+	if (expr->type != EXPR_PREOP)
+		return;
+	expr = strip_expr(expr->unop);
+	if (!is_pointer(expr))
+		return;
+	if (implied_not_equal(expr, 0))
+		return;
+
+	if (is_impossible_path())
+		return;
+
+	set_state_expr(my_id, expr, &derefed);
+}
+
+static void set_param_dereferenced(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	if (implied_not_equal_name_sym(name, sym, 0))
+		goto free;
+	set_state(my_id, name, sym, &derefed);
+
+free:
+	free_string(name);
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	if (__in_pre_condition)
+		return;
+
+	if (get_macro_name(expr->pos))
+		return;
+
+	if (!is_pointer(expr))
+		return;
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm || sm->state != &derefed)
+		return;
+
+	sm_warning("variable dereferenced before check '%s' (see line %d)", sm->name, sm->line);
+	set_state_expr(my_id, expr, &undefined);
+}
+
+void check_deref_check(int id)
+{
+	my_id = id;
+	add_hook(&match_dereference, DEREF_HOOK);
+	add_hook(&match_condition, CONDITION_HOOK);
+	select_return_implies_hook(DEREFERENCE, &set_param_dereferenced);
+	add_modification_hook(my_id, &underef);
+}
diff --git a/usr/src/tools/smatch/src/check_dereferences_param.c b/usr/src/tools/smatch/src/check_dereferences_param.c
new file mode 100644
index 0000000000..25192491a3
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_dereferences_param.c
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is an --info recipe.  The goal is to print a message for every parameter
+ * which we can not avoid dereferencing.  This is maybe a bit restrictive but it
+ * avoids some false positives.
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(derefed);
+STATE(ignore);
+STATE(param);
+
+static void set_ignore(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state == &derefed)
+		return;
+	set_state(my_id, sm->name, sm->sym, &ignore);
+}
+
+static void match_function_def(struct symbol *sym)
+{
+	struct symbol *arg;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(sym->ctype.base_type->arguments, arg) {
+		i++;
+		if (!arg->ident)
+			continue;
+		set_state(my_id, arg->ident->name, arg, &param);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void check_deref(struct expression *expr)
+{
+	struct expression *tmp;
+	struct sm_state *sm;
+
+	tmp = get_assigned_expr(expr);
+	if (tmp)
+		expr = tmp;
+	expr = strip_expr(expr);
+
+	if (get_param_num(expr) < 0)
+		return;
+
+	if (param_was_set(expr))
+		return;
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (sm && slist_has_state(sm->possible, &ignore))
+		return;
+	set_state_expr(my_id, expr, &derefed);
+}
+
+static void match_dereference(struct expression *expr)
+{
+	if (expr->type != EXPR_PREOP)
+		return;
+	if (getting_address())
+		return;
+	check_deref(expr->unop);
+}
+
+static void set_param_dereferenced(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	/* XXX FIXME: param_implies has more information now */
+	if (strcmp(key, "$") != 0)
+		return;
+	check_deref(arg);
+}
+
+static void process_states(void)
+{
+	struct sm_state *tmp;
+	int arg;
+	const char *name;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), tmp) {
+		if (tmp->state != &derefed)
+			continue;
+		arg = get_param_num_from_sym(tmp->sym);
+		if (arg < 0)
+			continue;
+		name = get_param_name(tmp);
+		if (!name)
+			continue;
+		sql_insert_return_implies(DEREFERENCE, arg, name, "1");
+	} END_FOR_EACH_SM(tmp);
+}
+
+static void match_pointer_as_array(struct expression *expr)
+{
+	if (!is_array(expr))
+		return;
+	check_deref(get_array_base(expr));
+}
+
+void check_dereferences_param(int id)
+{
+	my_id = id;
+
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+
+	add_hook(&match_dereference, DEREF_HOOK);
+	add_hook(&match_pointer_as_array, OP_HOOK);
+	select_return_implies_hook(DEREFERENCE, &set_param_dereferenced);
+	add_modification_hook(my_id, &set_ignore);
+
+	all_return_states_hook(&process_states);
+}
diff --git a/usr/src/tools/smatch/src/check_dev_queue_xmit.c b/usr/src/tools/smatch/src/check_dev_queue_xmit.c
new file mode 100644
index 0000000000..c794e6568e
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_dev_queue_xmit.c
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * According to an email on lkml you are not allowed to reuse the skb
+ * passed to dev_queue_xmit()
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(do_not_use);
+
+static void ok_to_use(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &undefined);
+}
+
+static int valid_use(void)
+{
+	struct expression *tmp;
+	int i = 0;
+	int dot_ops = 0;
+
+	FOR_EACH_PTR_REVERSE(big_expression_stack, tmp) {
+		if (!i++)
+			continue;
+		if (tmp->type == EXPR_PREOP && tmp->op == '(')
+			continue;
+		if (tmp->op == '.' && !dot_ops++)
+			continue;
+//		if (tmp->type == EXPR_POSTOP)
+//			return 1;
+		if (tmp->type == EXPR_CALL && sym_name_is("kfree_skb", tmp->fn))
+			return 1;
+		return 0;
+	} END_FOR_EACH_PTR_REVERSE(tmp);
+	return 0;
+}
+
+/* match symbol is expensive.  only turn it on after we match the xmit function */
+static int match_symbol_active;
+static void match_symbol(struct expression *expr)
+{
+	struct sm_state *sm;
+	char *name;
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm || !slist_has_state(sm->possible, &do_not_use))
+		return;
+	if (valid_use())
+		return;
+	name = expr_to_var(expr);
+	sm_error("'%s' was already used up by dev_queue_xmit()", name);
+	free_string(name);
+}
+
+static void match_kfree_skb(const char *fn, struct expression *expr, void *param)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	if (!arg)
+		return;
+	set_state_expr(my_id, arg, &undefined);
+}
+
+static void match_xmit(const char *fn, struct expression *expr, void *param)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(expr->args, PTR_INT(param));
+	if (!arg)
+		return;
+	set_state_expr(my_id, arg, &do_not_use);
+	if (!match_symbol_active++) {
+		add_hook(&match_symbol, SYM_HOOK);
+		add_function_hook("kfree_skb", &match_kfree_skb, NULL);
+	}
+}
+
+static void register_funcs_from_file(void)
+{
+	struct token *token;
+	const char *func;
+	int arg;
+
+	token = get_tokens_file("kernel.dev_queue_xmit");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		arg = atoi(token->number);
+		add_function_hook(func, &match_xmit, INT_PTR(arg));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_dev_queue_xmit(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	my_id = id;
+	add_modification_hook(my_id, ok_to_use);
+	register_funcs_from_file();
+}
diff --git a/usr/src/tools/smatch/src/check_dma_mapping_error.c b/usr/src/tools/smatch/src/check_dma_mapping_error.c
new file mode 100644
index 0000000000..a786813cd5
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_dma_mapping_error.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2015 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(positive);
+STATE(ok);
+
+static void ok_to_use(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state != &ok)
+		set_state(my_id, sm->name, sm->sym, &ok);
+}
+
+static void match_assign(const char *fn, struct expression *expr, void *unused)
+{
+	set_state_expr(my_id, expr->left, &positive);
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (!get_state_expr(my_id, expr))
+		return;
+	/* If the variable is zero that's ok */
+	set_true_false_states_expr(my_id, expr, NULL, &ok);
+}
+
+static void match_return(struct expression *ret_value)
+{
+	struct smatch_state *state;
+	struct sm_state *sm;
+	sval_t min;
+
+	sm = get_sm_state_expr(my_id, ret_value);
+	if (!sm)
+		return;
+	if (!slist_has_state(sm->possible, &positive))
+		return;
+	state = get_state_expr(SMATCH_EXTRA, ret_value);
+	if (!state)
+		return;
+	if (!get_absolute_min(ret_value, &min))
+		return;
+	if (min.value == 0)
+		return;
+	sm_warning("dma_mapping_error() doesn't return an error code");
+}
+
+void check_dma_mapping_error(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_function_assign_hook("dma_mapping_error", &match_assign, NULL);
+	add_function_assign_hook("pci_dma_mapping_error", &match_assign, NULL);
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_return, RETURN_HOOK);
+	add_modification_hook(my_id, &ok_to_use);
+}
diff --git a/usr/src/tools/smatch/src/check_dma_on_stack.c b/usr/src/tools/smatch/src/check_dma_on_stack.c
new file mode 100644
index 0000000000..ffa9ae9128
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_dma_on_stack.c
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_dma_func(const char *fn, struct expression *expr, void *param)
+{
+	struct expression *arg;
+	struct symbol *sym;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, PTR_INT(param));
+	arg = strip_expr(arg);
+	if (!arg)
+		return;
+	if (arg->type == EXPR_PREOP && arg->op == '&') {
+		if (arg->unop->type != EXPR_SYMBOL)
+			return;
+		name = expr_to_str(arg);
+		sm_error("doing dma on the stack (%s)", name);
+		free_string(name);
+		return;
+	}
+	if (arg->type != EXPR_SYMBOL)
+		return;
+	sym = get_type(arg);
+	if (!sym || sym->type != SYM_ARRAY)
+		return;
+	if (get_param_num(arg) >= 0)
+		return;
+	name = expr_to_var(arg);
+	sm_error("doing dma on the stack (%s)", name);
+	free_string(name);
+}
+
+static void register_funcs_from_file(void)
+{
+	struct token *token;
+	const char *func;
+	int arg;
+
+	token = get_tokens_file("kernel.dma_funcs");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		arg = atoi(token->number);
+		add_function_hook(func, &match_dma_func, INT_PTR(arg));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_dma_on_stack(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	my_id = id;
+	register_funcs_from_file();
+}
diff --git a/usr/src/tools/smatch/src/check_double_checking.c b/usr/src/tools/smatch/src/check_double_checking.c
new file mode 100644
index 0000000000..83d10fd1c2
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_double_checking.c
@@ -0,0 +1,281 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#define _GNU_SOURCE
+#include <string.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(checked);
+STATE(modified);
+
+struct stree *to_check;
+
+static struct statement *get_cur_stmt(void)
+{
+	return last_ptr_list((struct ptr_list *)big_statement_stack);
+}
+
+static void set_modified(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &modified);
+}
+
+static struct expression *strip_condition(struct expression *expr)
+{
+	expr = strip_expr(expr);
+
+	if (expr->type == EXPR_PREOP && expr->op == '!')
+		return strip_condition(expr->unop);
+
+	if (expr->type == EXPR_COMPARE &&
+	    (expr->op == SPECIAL_EQUAL ||
+	     expr->op == SPECIAL_NOTEQUAL)) {
+		if (is_zero(expr->left))
+			return strip_condition(expr->right);
+		if (is_zero(expr->right))
+			return strip_condition(expr->left);
+	}
+
+	return expr;
+}
+
+static int conditions_match(struct expression *cond, struct expression *prev)
+{
+	prev = strip_condition(prev);
+
+	if (prev == cond)
+		return 1;
+
+	if (prev->type == EXPR_LOGICAL) {
+		if (conditions_match(cond, prev->left) ||
+		    conditions_match(cond, prev->right))
+			return 1;
+	}
+
+	return 0;
+}
+
+/*
+ * People like to do "if (foo) { ... } else if (!foo) { ... }".  Don't
+ * complain when they do that even though it is nonsense.
+ */
+static int is_obvious_else(struct expression *cond)
+{
+	struct statement *parent;
+	struct expression *prev;
+
+	if (!get_cur_stmt())
+		return 0;
+	parent = get_cur_stmt()->parent;
+	if (!parent)
+		return 0;
+
+	if (parent->type != STMT_IF)
+		return 0;
+
+	if (!parent->if_false)
+		return 0;
+	if (parent->if_false != get_cur_stmt())
+		return 0;
+
+	prev = strip_condition(parent->if_conditional);
+
+	return conditions_match(cond, prev);
+}
+
+static int name_means_synchronize(const char *name)
+{
+	if (!name)
+		return 0;
+
+	if (strcasestr(name, "wait"))
+		return 1;
+	if (strcasestr(name, "down"))
+		return 1;
+	if (strcasestr(name, "lock") && !strcasestr(name, "unlock"))
+		return 1;
+	if (strcasestr(name, "delay"))
+		return 1;
+	if (strcasestr(name, "schedule"))
+		return 1;
+	if (strcmp(name, "smp_rmb") == 0)
+		return 1;
+	if (strcmp(name, "mb") == 0)
+		return 1;
+	if (strcmp(name, "barrier") == 0)
+		return 1;
+	return 0;
+}
+
+static int previous_statement_was_synchronize(void)
+{
+	struct statement *stmt;
+	struct position pos;
+	struct position prev_pos;
+	char *ident;
+
+	if (__prev_stmt) {
+		prev_pos = __prev_stmt->pos;
+		prev_pos.line -= 3;
+	} else {
+		prev_pos = __cur_stmt->pos;
+		prev_pos.line -= 5;
+	}
+
+	FOR_EACH_PTR_REVERSE(big_statement_stack, stmt) {
+		if (stmt->pos.line < prev_pos.line)
+			return 0;
+		pos = stmt->pos;
+		ident = get_macro_name(pos);
+		if (name_means_synchronize(ident))
+			return 1;
+		ident = pos_ident(pos);
+		if (!ident)
+			continue;
+		if (strcmp(ident, "if") == 0) {
+			pos.pos += 4;
+			ident = pos_ident(pos);
+			if (!ident)
+				continue;
+		}
+		if (name_means_synchronize(ident))
+			return 1;
+	} END_FOR_EACH_PTR_REVERSE(stmt);
+	return 0;
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct smatch_state *state;
+	sval_t dummy;
+	char *name;
+
+	if (inside_loop())
+		return;
+
+	if (get_value(expr, &dummy))
+		return;
+
+	if (get_macro_name(expr->pos))
+		return;
+
+	state = get_stored_condition(expr);
+	if (!state || !state->data)
+		return;
+	if (get_macro_name(((struct expression *)state->data)->pos))
+		return;
+
+	/*
+	 * we allow double checking for NULL because people do this all the time
+	 * and trying to stop them is a losers' battle.
+	 */
+	if (is_pointer(expr) && implied_condition_true(expr))
+		return;
+
+	if (definitely_inside_loop()) {
+		struct symbol *sym;
+
+		if (__inline_fn)
+			return;
+
+		name = expr_to_var_sym(expr, &sym);
+		if (!name)
+			return;
+		set_state_expr(my_id, expr, &checked);
+		set_state_stree(&to_check, my_id, name, sym, &checked);
+		free_string(name);
+		return;
+	}
+
+	if (is_obvious_else(state->data))
+		return;
+
+	/*
+	 * It's common to test something, then take a lock and test if it is
+	 * still true.
+	 */
+	if (previous_statement_was_synchronize())
+		return;
+
+	name = expr_to_str(expr);
+	sm_warning("we tested '%s' before and it was '%s'", name, state->name);
+	free_string(name);
+}
+
+int get_check_line(struct sm_state *sm)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->state == &checked)
+			return tmp->line;
+	} END_FOR_EACH_PTR(tmp);
+
+	return get_lineno();
+}
+
+static void after_loop(struct statement *stmt)
+{
+	struct sm_state *check, *sm;
+
+	if (!stmt || stmt->type != STMT_ITERATOR)
+		return;
+	if (definitely_inside_loop())
+		return;
+	if (__inline_fn)
+		return;
+
+	FOR_EACH_SM(to_check, check) {
+		continue;
+		sm = get_sm_state(my_id, check->name, check->sym);
+		continue;
+		if (!sm)
+			continue;
+		if (slist_has_state(sm->possible, &modified))
+			continue;
+
+		sm_printf("%s:%d %s() ", get_filename(), get_check_line(sm), get_function());
+		sm_printf("warn: we tested '%s' already\n", check->name);
+	} END_FOR_EACH_SM(check);
+
+	free_stree(&to_check);
+}
+
+static void match_func_end(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	if (to_check)
+		sm_msg("debug: odd...  found an function without an end.");
+	free_stree(&to_check);
+}
+
+void check_double_checking(int id)
+{
+	my_id = id;
+
+	if (!option_spammy)
+		return;
+
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_modification_hook(my_id, &set_modified);
+	add_hook(after_loop, STMT_HOOK_AFTER);
+	add_hook(&match_func_end, AFTER_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_err_ptr.c b/usr/src/tools/smatch/src/check_err_ptr.c
new file mode 100644
index 0000000000..c3d0f7e9ae
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_err_ptr.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static int err_ptr = 0;
+static int returns_null = 0;
+
+static void match_err_ptr(struct expression *expr)
+{
+	expr = strip_expr(expr);
+	if (!expr)
+		return;
+	if (expr->type != EXPR_CALL)
+		return;
+
+	if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol)
+		return;
+	if (!strcmp(expr->fn->symbol->ident->name, "ERR_PTR"))
+		err_ptr = 1;
+}
+
+extern int check_assigned_expr_id;
+static void match_return(struct expression *ret_value)
+{
+	struct state_list *slist;
+	struct sm_state *tmp;
+	sval_t sval;
+
+	if (__inline_fn)
+		return;
+	match_err_ptr(ret_value);
+	slist = get_possible_states_expr(check_assigned_expr_id, ret_value);
+	FOR_EACH_PTR(slist, tmp) {
+		if (tmp->state == &undefined || tmp->state == &merged)
+			continue;
+		match_err_ptr((struct expression *)tmp->state->data);
+	} END_FOR_EACH_PTR(tmp);
+
+	if (get_implied_value(ret_value, &sval)) {
+		if (sval.value == 0)
+			returns_null = 1;
+	}
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	if (err_ptr)
+		sm_info("returns_err_ptr");
+	err_ptr = 0;
+	returns_null = 0;
+}
+
+void check_err_ptr(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	if (!option_info)
+		return;
+
+	my_id = id;
+	add_hook(&match_return, RETURN_HOOK);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_err_ptr_deref.c b/usr/src/tools/smatch/src/check_err_ptr_deref.c
new file mode 100644
index 0000000000..50a79cd3ad
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_err_ptr_deref.c
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(err_ptr);
+STATE(checked);
+
+static sval_t err_ptr_min = {
+	.type = &int_ctype,
+	{.value = -4095},
+};
+
+static sval_t err_ptr_max = {
+	.type = &int_ctype,
+	{.value = -1},
+};
+
+struct range_list *err_ptr_rl;
+
+static void ok_to_use(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state != &checked)
+		set_state(my_id, sm->name, sm->sym, &checked);
+}
+
+static void check_is_err_ptr(struct expression *expr)
+{
+	struct sm_state *sm;
+	struct range_list *rl;
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return;
+
+	if (!slist_has_state(sm->possible, &err_ptr))
+		return;
+
+	get_absolute_rl(expr, &rl);
+	if (!possibly_true_rl(rl, SPECIAL_EQUAL, err_ptr_rl))
+		return;
+
+	sm_error("'%s' dereferencing possible ERR_PTR()", sm->name);
+	set_state(my_id, sm->name, sm->sym, &checked);
+}
+
+static void match_returns_err_ptr(const char *fn, struct expression *expr,
+				void *info)
+{
+	set_state_expr(my_id, expr->left, &err_ptr);
+}
+
+static void set_param_dereferenced(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	struct sm_state *sm;
+	struct smatch_state *estate;
+	struct symbol *sym;
+	char *name;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	sm = get_sm_state(my_id, name, sym);
+	if (!sm)
+		goto free;
+
+	if (!slist_has_state(sm->possible, &err_ptr))
+		goto free;
+
+	estate = get_state(SMATCH_EXTRA, name, sym);
+	if (!estate || !possibly_true_rl(estate_rl(estate), SPECIAL_EQUAL, err_ptr_rl))
+		goto free;
+
+	sm_error("'%s' dereferencing possible ERR_PTR()", sm->name);
+	set_state(my_id, sm->name, sm->sym, &checked);
+
+free:
+	free_string(name);
+}
+
+static void match_checked(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *unused)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(call_expr->args, 0);
+	arg = strip_expr(arg);
+	while (arg->type == EXPR_ASSIGNMENT)
+		arg = strip_expr(arg->left);
+	set_state_expr(my_id, arg, &checked);
+}
+
+static void match_err(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *unused)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(call_expr->args, 0);
+	arg = strip_expr(arg);
+	while (arg->type == EXPR_ASSIGNMENT)
+		arg = strip_expr(arg->left);
+	set_state_expr(my_id, arg, &err_ptr);
+}
+
+static void match_dereferences(struct expression *expr)
+{
+	if (expr->type != EXPR_PREOP)
+		return;
+	check_is_err_ptr(expr->unop);
+}
+
+static void match_kfree(const char *fn, struct expression *expr, void *_arg_nr)
+{
+	int arg_nr = PTR_INT(_arg_nr);
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(expr->args, arg_nr);
+	check_is_err_ptr(arg);
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (expr->type == EXPR_ASSIGNMENT) {
+		match_condition(expr->right);
+		match_condition(expr->left);
+	}
+	if (!get_state_expr(my_id, expr))
+		return;
+	/* If we know the variable is zero that means it's not an ERR_PTR */
+	set_true_false_states_expr(my_id, expr, NULL, &checked);
+}
+
+static void register_err_ptr_funcs(void)
+{
+	struct token *token;
+	const char *func;
+
+	token = get_tokens_file("kernel.returns_err_ptr");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		add_function_assign_hook(func, &match_returns_err_ptr, NULL);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void match_err_ptr_positive_const(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *arg;
+	sval_t sval;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+
+	if (!get_value(arg, &sval))
+		return;
+	if (sval_is_positive(sval) && sval_cmp_val(sval, 0) != 0)
+		sm_error("passing non negative %s to ERR_PTR", sval_to_str(sval));
+}
+
+static void match_err_ptr(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *arg;
+	struct sm_state *sm;
+	struct sm_state *tmp;
+	sval_t tmp_min;
+	sval_t tmp_max;
+	sval_t min = sval_type_max(&llong_ctype);
+	sval_t max = sval_type_min(&llong_ctype);
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	sm = get_sm_state_expr(SMATCH_EXTRA, arg);
+	if (!sm)
+		return;
+	FOR_EACH_PTR(sm->possible, tmp) {
+		tmp_min = estate_min(tmp->state);
+		if (!sval_is_a_min(tmp_min) && sval_cmp(tmp_min, min) < 0)
+			min = tmp_min;
+		tmp_max = estate_max(tmp->state);
+		if (!sval_is_a_max(tmp_max) && sval_cmp(tmp_max, max) > 0)
+			max = tmp_max;
+	} END_FOR_EACH_PTR(tmp);
+	if (sval_is_negative(min) && sval_cmp_val(min, -4095) < 0)
+		sm_error("%s too low for ERR_PTR", sval_to_str(min));
+	if (sval_is_positive(max) && sval_cmp_val(max, 0) != 0)
+		sm_error("passing non negative %s to ERR_PTR", sval_to_str(max));
+}
+
+void check_err_ptr_deref(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	return_implies_state("IS_ERR", 0, 0, &match_checked, NULL);
+	return_implies_state("IS_ERR", 1, 1, &match_err, NULL);
+	return_implies_state("IS_ERR_OR_NULL", 0, 0, &match_checked, NULL);
+	return_implies_state("IS_ERR_OR_NULL", 1, 1, &match_err, NULL);
+	return_implies_state("PTR_RET", 0, 0, &match_checked, NULL);
+	return_implies_state("PTR_RET", -4096, -1, &match_err, NULL);
+	register_err_ptr_funcs();
+	add_hook(&match_dereferences, DEREF_HOOK);
+	add_function_hook("ERR_PTR", &match_err_ptr_positive_const, NULL);
+	add_function_hook("ERR_PTR", &match_err_ptr, NULL);
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_modification_hook(my_id, &ok_to_use);
+	add_function_hook("kfree", &match_kfree, INT_PTR(0));
+	add_function_hook("brelse", &match_kfree, INT_PTR(0));
+	add_function_hook("kmem_cache_free", &match_kfree, INT_PTR(1));
+	add_function_hook("vfree", &match_kfree, INT_PTR(0));
+
+	err_ptr_rl = clone_rl_permanent(alloc_rl(err_ptr_min, err_ptr_max));
+
+	select_return_implies_hook(DEREFERENCE, &set_param_dereferenced);
+}
+
diff --git a/usr/src/tools/smatch/src/check_expects_err_ptr.c b/usr/src/tools/smatch/src/check_expects_err_ptr.c
new file mode 100644
index 0000000000..2102cde80c
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_expects_err_ptr.c
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+static struct symbol *func_sym;
+
+STATE(argument);
+STATE(ok);
+
+static void set_ok(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state != &ok)
+		set_state(my_id, sm->name, sm->sym, &ok);
+}
+
+static void match_function_def(struct symbol *sym)
+{
+	struct symbol *arg;
+
+	func_sym = sym;
+	FOR_EACH_PTR(func_sym->ctype.base_type->arguments, arg) {
+		if (!arg->ident) {
+			continue;
+		}
+		set_state(my_id, arg->ident->name, arg, &argument);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static int get_arg_num(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct symbol *arg;
+	struct symbol *this_arg;
+	int i;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_SYMBOL)
+		return -1;
+	this_arg = expr->symbol;
+
+	state = get_state_expr(my_id, expr);
+	if (!state || state != &argument)
+		return -1;
+	
+	i = 0;
+	FOR_EACH_PTR(func_sym->ctype.base_type->arguments, arg) {
+		if (arg == this_arg)
+			return i;
+		i++;
+	} END_FOR_EACH_PTR(arg);
+
+	return -1;
+}
+
+static void match_is_err(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *arg;
+	int arg_num;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	arg_num = get_arg_num(arg);
+	if (arg_num < 0)
+		return;
+	sm_msg("info: expects ERR_PTR %d", arg_num);
+}
+
+void check_expects_err_ptr(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	if (!option_info)
+		return;
+
+	my_id = id;
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+	add_modification_hook(my_id, &set_ok);
+	add_function_hook("IS_ERR", &match_is_err, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_free.c b/usr/src/tools/smatch/src/check_free.c
new file mode 100644
index 0000000000..44df17e0d3
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_free.c
@@ -0,0 +1,302 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * check_memory() is getting too big and messy.
+ *
+ */
+
+#include <string.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(freed);
+STATE(ok);
+
+static void ok_to_use(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state != &ok)
+		set_state(my_id, sm->name, sm->sym, &ok);
+}
+
+static void pre_merge_hook(struct sm_state *sm)
+{
+	if (is_impossible_path())
+		set_state(my_id, sm->name, sm->sym, &ok);
+}
+
+static int is_freed(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (sm && slist_has_state(sm->possible, &freed))
+		return 1;
+	return 0;
+}
+
+static void match_symbol(struct expression *expr)
+{
+	struct expression *parent;
+	char *name;
+
+	if (is_impossible_path())
+		return;
+	if (__in_fake_parameter_assign)
+		return;
+
+	parent = expr_get_parent_expr(expr);
+	while (parent && parent->type == EXPR_PREOP && parent->op == '(')
+		parent = expr_get_parent_expr(parent);
+	if (parent && parent->type == EXPR_PREOP && parent->op == '&')
+		return;
+
+	if (!is_freed(expr))
+		return;
+	name = expr_to_var(expr);
+	sm_warning("'%s' was already freed.", name);
+	free_string(name);
+}
+
+static void match_dereferences(struct expression *expr)
+{
+	char *name;
+
+	if (__in_fake_parameter_assign)
+		return;
+
+	if (expr->type != EXPR_PREOP)
+		return;
+
+	if (is_impossible_path())
+		return;
+
+	expr = strip_expr(expr->unop);
+	if (!is_freed(expr))
+		return;
+	name = expr_to_var(expr);
+	sm_error("dereferencing freed memory '%s'", name);
+	set_state_expr(my_id, expr, &ok);
+	free_string(name);
+}
+
+static int ignored_params[16];
+
+static void set_ignored_params(struct expression *call)
+{
+	struct expression *arg;
+	const char *p;
+	int i;
+
+	memset(&ignored_params, 0, sizeof(ignored_params));
+
+	i = -1;
+	FOR_EACH_PTR(call->args, arg) {
+		i++;
+		if (arg->type != EXPR_STRING)
+			continue;
+		goto found;
+	} END_FOR_EACH_PTR(arg);
+
+	return;
+
+found:
+	i++;
+	p = arg->string->data;
+	while ((p = strchr(p, '%'))) {
+		if (i >= ARRAY_SIZE(ignored_params))
+			return;
+		p++;
+		if (*p == '%') {
+			p++;
+			continue;
+		}
+		if (*p == '.')
+			p++;
+		if (*p == '*')
+			i++;
+		if (*p == 'p')
+			ignored_params[i] = 1;
+		i++;
+	}
+}
+
+static int is_free_func(struct expression *fn)
+{
+	char *name;
+	int ret = 0;
+
+	name = expr_to_str(fn);
+	if (!name)
+		return 0;
+	if (strstr(name, "free"))
+		ret = 1;
+	free_string(name);
+
+	return ret;
+}
+
+static void match_call(struct expression *expr)
+{
+	struct expression *arg;
+	char *name;
+	int i;
+
+	if (is_impossible_path())
+		return;
+
+	set_ignored_params(expr);
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+		if (!is_pointer(arg))
+			continue;
+		if (!is_freed(arg))
+			continue;
+		if (ignored_params[i])
+			continue;
+
+		name = expr_to_var(arg);
+		if (is_free_func(expr->fn))
+			sm_error("double free of '%s'", name);
+		else
+			sm_warning("passing freed memory '%s'", name);
+		set_state_expr(my_id, arg, &ok);
+		free_string(name);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void match_return(struct expression *expr)
+{
+	char *name;
+
+	if (is_impossible_path())
+		return;
+	if (__in_fake_parameter_assign)
+		return;
+
+	if (!expr)
+		return;
+	if (!is_freed(expr))
+		return;
+
+	name = expr_to_var(expr);
+	sm_warning("returning freed memory '%s'", name);
+	set_state_expr(my_id, expr, &ok);
+	free_string(name);
+}
+
+static void match_free(const char *fn, struct expression *expr, void *param)
+{
+	struct expression *arg;
+
+	if (is_impossible_path())
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, PTR_INT(param));
+	if (!arg)
+		return;
+	if (is_freed(arg)) {
+		char *name = expr_to_var(arg);
+
+		sm_error("double free of '%s'", name);
+		free_string(name);
+	}
+	set_state_expr(my_id, arg, &freed);
+}
+
+static void set_param_freed(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	set_state(my_id, name, sym, &freed);
+free:
+	free_string(name);
+}
+
+int parent_is_free_var_sym(const char *name, struct symbol *sym)
+{
+	char buf[256];
+	char *start;
+	char *end;
+	struct smatch_state *state;
+
+	if (option_project == PROJ_KERNEL)
+		return parent_is_free_var_sym_strict(name, sym);
+
+	strncpy(buf, name, sizeof(buf) - 1);
+	buf[sizeof(buf) - 1] = '\0';
+
+	start = &buf[0];
+	while ((*start == '&'))
+		start++;
+
+	while ((end = strrchr(start, '-'))) {
+		*end = '\0';
+		state = __get_state(my_id, start, sym);
+		if (state == &freed)
+			return 1;
+	}
+	return 0;
+}
+
+int parent_is_free(struct expression *expr)
+{
+	struct symbol *sym;
+	char *var;
+	int ret = 0;
+
+	expr = strip_expr(expr);
+	var = expr_to_var_sym(expr, &sym);
+	if (!var || !sym)
+		goto free;
+	ret = parent_is_free_var_sym(var, sym);
+free:
+	free_string(var);
+	return ret;
+}
+
+void check_free(int id)
+{
+	my_id = id;
+
+	if (option_project == PROJ_KERNEL) {
+		/* The kernel use check_free_strict.c */
+		return;
+	}
+
+	add_function_hook("free", &match_free, INT_PTR(0));
+
+	if (option_spammy)
+		add_hook(&match_symbol, SYM_HOOK);
+	add_hook(&match_dereferences, DEREF_HOOK);
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+	add_hook(&match_return, RETURN_HOOK);
+
+	add_modification_hook(my_id, &ok_to_use);
+	select_return_implies_hook(PARAM_FREED, &set_param_freed);
+	add_pre_merge_hook(my_id, &pre_merge_hook);
+}
diff --git a/usr/src/tools/smatch/src/check_free_strict.c b/usr/src/tools/smatch/src/check_free_strict.c
new file mode 100644
index 0000000000..dd551cba52
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_free_strict.c
@@ -0,0 +1,314 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * check_memory() is getting too big and messy.
+ *
+ */
+
+#include <string.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(freed);
+STATE(ok);
+
+static void ok_to_use(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state != &ok)
+		set_state(my_id, sm->name, sm->sym, &ok);
+}
+
+static void pre_merge_hook(struct sm_state *sm)
+{
+	if (is_impossible_path())
+		set_state(my_id, sm->name, sm->sym, &ok);
+}
+
+static int is_freed(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (sm && slist_has_state(sm->possible, &freed))
+		return 1;
+	return 0;
+}
+
+static void match_symbol(struct expression *expr)
+{
+	struct expression *parent;
+	char *name;
+
+	if (is_impossible_path())
+		return;
+	if (__in_fake_parameter_assign)
+		return;
+
+	parent = expr_get_parent_expr(expr);
+	while (parent && parent->type == EXPR_PREOP && parent->op == '(')
+		parent = expr_get_parent_expr(parent);
+	if (parent && parent->type == EXPR_PREOP && parent->op == '&')
+		return;
+
+	if (!is_freed(expr))
+		return;
+	name = expr_to_var(expr);
+	sm_warning("'%s' was already freed.", name);
+	free_string(name);
+}
+
+static void match_dereferences(struct expression *expr)
+{
+	char *name;
+
+	if (expr->type != EXPR_PREOP)
+		return;
+
+	if (is_impossible_path())
+		return;
+	if (__in_fake_parameter_assign)
+		return;
+
+	expr = strip_expr(expr->unop);
+	if (!is_freed(expr))
+		return;
+	name = expr_to_var(expr);
+	sm_error("dereferencing freed memory '%s'", name);
+	set_state_expr(my_id, expr, &ok);
+	free_string(name);
+}
+
+static int ignored_params[16];
+
+static void set_ignored_params(struct expression *call)
+{
+	struct expression *arg;
+	const char *p;
+	int i;
+
+	memset(&ignored_params, 0, sizeof(ignored_params));
+
+	i = -1;
+	FOR_EACH_PTR(call->args, arg) {
+		i++;
+		if (arg->type != EXPR_STRING)
+			continue;
+		goto found;
+	} END_FOR_EACH_PTR(arg);
+
+	return;
+
+found:
+	i++;
+	p = arg->string->data;
+	while ((p = strchr(p, '%'))) {
+		if (i >= ARRAY_SIZE(ignored_params))
+			return;
+		p++;
+		if (*p == '%') {
+			p++;
+			continue;
+		}
+		if (*p == '.')
+			p++;
+		if (*p == '*')
+			i++;
+		if (*p == 'p')
+			ignored_params[i] = 1;
+		i++;
+	}
+}
+
+static int is_free_func(struct expression *fn)
+{
+	char *name;
+	int ret = 0;
+
+	name = expr_to_str(fn);
+	if (!name)
+		return 0;
+	if (strstr(name, "free"))
+		ret = 1;
+	free_string(name);
+
+	return ret;
+}
+
+static void match_call(struct expression *expr)
+{
+	struct expression *arg;
+	char *name;
+	int i;
+
+	if (is_impossible_path())
+		return;
+
+	set_ignored_params(expr);
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+		if (!is_pointer(arg))
+			continue;
+		if (!is_freed(arg))
+			continue;
+		if (ignored_params[i])
+			continue;
+
+		name = expr_to_var(arg);
+		if (is_free_func(expr->fn))
+			sm_error("double free of '%s'", name);
+		else
+			sm_warning("passing freed memory '%s'", name);
+		set_state_expr(my_id, arg, &ok);
+		free_string(name);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void match_return(struct expression *expr)
+{
+	char *name;
+
+	if (is_impossible_path())
+		return;
+
+	if (!expr)
+		return;
+	if (!is_freed(expr))
+		return;
+
+	name = expr_to_var(expr);
+	sm_warning("returning freed memory '%s'", name);
+	set_state_expr(my_id, expr, &ok);
+	free_string(name);
+}
+
+static void match_free(const char *fn, struct expression *expr, void *param)
+{
+	struct expression *arg;
+
+	if (is_impossible_path())
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, PTR_INT(param));
+	if (!arg)
+		return;
+	if (is_freed(arg)) {
+		char *name = expr_to_var(arg);
+
+		sm_error("double free of '%s'", name);
+		free_string(name);
+	}
+	set_state_expr(my_id, arg, &freed);
+}
+
+static void set_param_freed(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+	char *name;
+	struct symbol *sym;
+	struct sm_state *sm;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	if (!is_impossible_path()) {
+		sm = get_sm_state(my_id, name, sym);
+		if (sm && slist_has_state(sm->possible, &freed)) {
+			sm_warning("'%s' double freed", name);
+			set_state(my_id, name, sym, &ok);  /* fixme: doesn't silence anything.  I know */
+		}
+	}
+
+	set_state(my_id, name, sym, &freed);
+free:
+	free_string(name);
+}
+
+int parent_is_free_var_sym_strict(const char *name, struct symbol *sym)
+{
+	char buf[256];
+	char *start;
+	char *end;
+	struct smatch_state *state;
+
+	strncpy(buf, name, sizeof(buf) - 1);
+	buf[sizeof(buf) - 1] = '\0';
+
+	start = &buf[0];
+	while ((*start == '&'))
+		start++;
+
+	while ((end = strrchr(start, '-'))) {
+		*end = '\0';
+		state = __get_state(my_id, start, sym);
+		if (state == &freed)
+			return 1;
+	}
+	return 0;
+}
+
+int parent_is_free_strict(struct expression *expr)
+{
+	struct symbol *sym;
+	char *var;
+	int ret = 0;
+
+	expr = strip_expr(expr);
+	var = expr_to_var_sym(expr, &sym);
+	if (!var || !sym)
+		goto free;
+	ret = parent_is_free_var_sym_strict(var, sym);
+free:
+	free_string(var);
+	return ret;
+}
+
+void check_free_strict(int id)
+{
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_function_hook("kfree", &match_free, INT_PTR(0));
+	add_function_hook("kmem_cache_free", &match_free, INT_PTR(1));
+
+	if (option_spammy)
+		add_hook(&match_symbol, SYM_HOOK);
+	add_hook(&match_dereferences, DEREF_HOOK);
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+	add_hook(&match_return, RETURN_HOOK);
+
+	add_modification_hook_late(my_id, &ok_to_use);
+	add_pre_merge_hook(my_id, &pre_merge_hook);
+
+	select_return_states_hook(PARAM_FREED, &set_param_freed);
+}
diff --git a/usr/src/tools/smatch/src/check_freeing_devm.c b/usr/src/tools/smatch/src/check_freeing_devm.c
new file mode 100644
index 0000000000..02587bcf5d
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_freeing_devm.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+STATE(devm);
+
+static int my_id;
+
+static void match_assign(const char *fn, struct expression *expr, void *unused)
+{
+	set_state_expr(my_id, expr->left, &devm);
+}
+
+static void match_free_func(const char *fn, struct expression *expr, void *_arg)
+{
+	struct expression *arg_expr;
+	int arg = PTR_INT(_arg);
+	char *name;
+
+	arg_expr = get_argument_from_call_expr(expr->args, arg);
+	if (!get_state_expr(my_id, arg_expr))
+		return;
+	name = expr_to_str(arg_expr);
+	sm_warning("passing devm_ allocated variable to kfree. '%s'", name);
+	free_string(name);
+}
+
+static void register_funcs_from_file(void)
+{
+	struct token *token;
+	const char *func;
+	int arg;
+
+	token = get_tokens_file("kernel.frees_argument");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		arg = atoi(token->number);
+		add_function_hook(func, &match_free_func, INT_PTR(arg));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_freeing_devm(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+
+	add_function_assign_hook("devm_kmalloc", &match_assign, NULL);
+	add_function_assign_hook("devm_kzalloc", &match_assign, NULL);
+	add_function_assign_hook("devm_kcalloc", &match_assign, NULL);
+	add_function_assign_hook("devm_kmalloc_array", &match_assign, NULL);
+
+
+	add_function_hook("kfree", &match_free_func, INT_PTR(0));
+	add_function_hook("krealloc", &match_free_func, INT_PTR(0));
+	register_funcs_from_file();
+}
diff --git a/usr/src/tools/smatch/src/check_freeing_null.c b/usr/src/tools/smatch/src/check_freeing_null.c
new file mode 100644
index 0000000000..082f6250ad
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_freeing_null.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_free(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg_expr;
+	char *name;
+	sval_t sval;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 0);
+	if (!get_implied_value(arg_expr, &sval))
+		return;
+	if (sval.value != 0)
+		return;
+	name = expr_to_var(arg_expr);
+	sm_warning("calling %s() when '%s' is always NULL.", fn, name);
+	free_string(name);
+}
+
+void check_freeing_null(int id)
+{
+	my_id = id;
+	if (!option_spammy)
+		return;
+	if (option_project == PROJ_KERNEL)
+		add_function_hook("kfree", &match_free, NULL);
+	else
+		add_function_hook("free", &match_free, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_frees_argument.c b/usr/src/tools/smatch/src/check_frees_argument.c
new file mode 100644
index 0000000000..5b4d57c997
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_frees_argument.c
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/* 
+ * This script is for finding functions like hcd_buffer_free() which free
+ * their arguments.  After running it, add those functions to check_memory.c
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(freed);
+
+static struct symbol *this_func;
+static struct tracker_list *freed_args = NULL;
+
+static void match_function_def(struct symbol *sym)
+{
+	this_func = sym;
+}
+
+static int is_arg(char *name, struct symbol *sym)
+{
+	struct symbol *arg;
+	const char *arg_name;
+
+	FOR_EACH_PTR(this_func->ctype.base_type->arguments, arg) {
+		arg_name = (arg->ident?arg->ident->name:"-");
+		if (sym == arg && !strcmp(name, arg_name))
+			return 1;
+	} END_FOR_EACH_PTR(arg);
+	return 0;
+}
+
+static void match_kfree(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *tmp;
+	struct symbol *sym;
+	char *name;
+
+	tmp = get_argument_from_call_expr(expr->args, 0);
+	tmp = strip_expr(tmp);
+	name = expr_to_var_sym(tmp, &sym);
+	if (is_arg(name, sym)) {
+		set_state(my_id, name, sym, &freed);
+	}
+	free_string(name);
+}
+
+static int return_count = 0;
+static void match_return(struct expression *ret_value)
+{
+	struct stree *stree;
+	struct sm_state *tmp;
+	struct tracker *tracker;
+
+	if (__inline_fn)
+		return;
+
+	if (!return_count) {
+		stree = __get_cur_stree();
+		FOR_EACH_MY_SM(my_id, stree, tmp) {
+			if (tmp->state == &freed)
+				add_tracker(&freed_args, my_id, tmp->name,
+					    tmp->sym);
+		} END_FOR_EACH_SM(tmp);
+	} else {
+		FOR_EACH_PTR(freed_args, tracker) {
+			tmp = get_sm_state(my_id, tracker->name, tracker->sym);
+			if (tmp && tmp->state != &freed)
+				del_tracker(&freed_args, my_id, tracker->name,
+					    tracker->sym);
+		} END_FOR_EACH_PTR(tracker);
+	}
+}
+
+static void print_arg(struct symbol *sym)
+{
+	struct symbol *arg;
+	int i = 0;
+
+	FOR_EACH_PTR(this_func->ctype.base_type->arguments, arg) {
+		if (sym == arg) {
+			sm_info("free_arg %s %d", get_function(), i);
+			return;
+		}
+		i++;
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	if (is_reachable())
+		match_return(NULL);
+}
+
+static void match_after_func(struct symbol *sym)
+{
+	struct tracker *tracker;
+
+	if (__inline_fn)
+		return;
+
+	FOR_EACH_PTR(freed_args, tracker) {
+		print_arg(tracker->sym);
+	} END_FOR_EACH_PTR(tracker);
+
+	free_trackers_and_list(&freed_args);
+	return_count = 0;
+}
+
+void check_frees_argument(int id)
+{
+	if (!option_info)
+		return;
+
+	my_id = id;
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+	if (option_project == PROJ_KERNEL)
+		add_function_hook("kfree", &match_kfree, NULL);
+	else
+		add_function_hook("free", &match_kfree, NULL);
+	add_hook(&match_return, RETURN_HOOK);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+	add_hook(&match_after_func, AFTER_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_frees_param.c b/usr/src/tools/smatch/src/check_frees_param.c
new file mode 100644
index 0000000000..712f1ca7d0
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_frees_param.c
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This file is sort of like check_dereferences_param.c.  In theory the one
+ * difference should be that the param is NULL it should still be counted as a
+ * free.  But for now I don't handle that case.
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(freed);
+STATE(ignore);
+STATE(param);
+
+static void set_ignore(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &ignore);
+}
+
+static void match_function_def(struct symbol *sym)
+{
+	struct symbol *arg;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(sym->ctype.base_type->arguments, arg) {
+		i++;
+		if (!arg->ident)
+			continue;
+		set_state(my_id, arg->ident->name, arg, &param);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void freed_variable(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	expr = strip_expr(expr);
+	if (get_param_num(expr) < 0)
+		return;
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (sm && slist_has_state(sm->possible, &ignore))
+		return;
+	set_state_expr(my_id, expr, &freed);
+}
+
+static void match_free(const char *fn, struct expression *expr, void *param)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(expr->args, PTR_INT(param));
+	if (!arg)
+		return;
+	freed_variable(arg);
+}
+
+static void set_param_freed(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	/* XXX FIXME: return_implies has been updated with more information */
+	if (strcmp(key, "$") != 0)
+		return;
+	freed_variable(arg);
+}
+
+static void process_states(void)
+{
+	struct sm_state *sm;
+	int param;
+	const char *param_name;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (sm->state != &freed)
+			continue;
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+		sql_insert_return_implies(PARAM_FREED, param, param_name, "1");
+	} END_FOR_EACH_SM(sm);
+
+}
+
+void check_frees_param(int id)
+{
+	my_id = id;
+
+	if (option_project == PROJ_KERNEL) {
+		/* The kernel uses check_frees_param_strict.c */
+		return;
+	}
+
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+
+	add_function_hook("free", &match_free, INT_PTR(0));
+
+	select_return_implies_hook(PARAM_FREED, &set_param_freed);
+	add_modification_hook(my_id, &set_ignore);
+
+	all_return_states_hook(&process_states);
+}
diff --git a/usr/src/tools/smatch/src/check_frees_param_strict.c b/usr/src/tools/smatch/src/check_frees_param_strict.c
new file mode 100644
index 0000000000..debad846fd
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_frees_param_strict.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This file is sort of like check_dereferences_param.c.  In theory the one
+ * difference should be that the param is NULL it should still be counted as a
+ * free.  But for now I don't handle that case.
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(freed);
+STATE(ignore);
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	if (sm->state != &freed)
+		return &undefined;
+	if (parent_is_null_var_sym(sm->name, sm->sym))
+		return &freed;
+	return &undefined;
+}
+
+static void set_ignore(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &ignore);
+}
+
+static int counter_was_inced(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	char buf[256];
+	int ret = 0;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+
+	snprintf(buf, sizeof(buf), "%s->users.counter", name);
+	ret = was_inced(buf, sym);
+free:
+	free_string(name);
+	return ret;
+}
+
+static void match_free(const char *fn, struct expression *expr, void *param)
+{
+	struct expression *arg, *tmp;
+	int cnt = 0;
+
+	arg = get_argument_from_call_expr(expr->args, PTR_INT(param));
+	if (!arg)
+		return;
+	while ((tmp = get_assigned_expr(arg))) {
+		arg = strip_expr(tmp);
+		if (cnt++ > 5)
+			break;
+	}
+
+	if (get_param_num(arg) < 0)
+		return;
+	if (param_was_set(arg))
+		return;
+	if (strcmp(fn, "kfree_skb") == 0 && counter_was_inced(arg))
+		return;
+
+	set_state_expr(my_id, arg, &freed);
+}
+
+static void set_param_freed(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+	char *name;
+	struct symbol *sym;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+	if (get_param_num_from_sym(sym) < 0)
+		goto free;
+
+	if (param_was_set_var_sym(name, sym))
+		goto free;
+
+	set_state(my_id, name, sym, &freed);
+free:
+	free_string(name);
+}
+
+static void param_freed_info(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *sm;
+	int param;
+	const char *param_name;
+
+	if (on_atomic_dec_path())
+		return;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (sm->state != &freed)
+			continue;
+
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+
+		sql_insert_return_states(return_id, return_ranges, PARAM_FREED,
+					 param, param_name, "");
+	} END_FOR_EACH_SM(sm);
+}
+
+void check_frees_param_strict(int id)
+{
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_function_hook("kfree", &match_free, INT_PTR(0));
+	add_function_hook("kmem_cache_free", &match_free, INT_PTR(1));
+	add_function_hook("kfree_skb", &match_free, INT_PTR(0));
+	add_function_hook("kfree_skbmem", &match_free, INT_PTR(0));
+	add_function_hook("dma_pool_free", &match_free, INT_PTR(1));
+	add_function_hook("spi_unregister_controller", &match_free, INT_PTR(0));
+
+	select_return_states_hook(PARAM_FREED, &set_param_freed);
+	add_modification_hook(my_id, &set_ignore);
+	add_split_return_callback(&param_freed_info);
+
+	add_unmatched_state_hook(my_id, &unmatched_state);
+}
diff --git a/usr/src/tools/smatch/src/check_get_user_overflow.c b/usr/src/tools/smatch/src/check_get_user_overflow.c
new file mode 100644
index 0000000000..20ec952c88
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_get_user_overflow.c
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Looks for integers that we get from the user which can be attacked
+ * with an integer overflow.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_max_id;
+static int my_min_id;
+
+STATE(capped);
+STATE(user_data);
+
+static void match_condition(struct expression *expr)
+{
+	struct smatch_state *left_max_true = NULL;
+	struct smatch_state *left_max_false = NULL;
+	struct smatch_state *right_max_true = NULL;
+	struct smatch_state *right_max_false = NULL;
+
+	struct smatch_state *left_min_true = NULL;
+	struct smatch_state *left_min_false = NULL;
+	struct smatch_state *right_min_true = NULL;
+	struct smatch_state *right_min_false = NULL;
+
+	if (expr->type != EXPR_COMPARE)
+		return;
+
+	switch (expr->op) {
+	case '<':
+	case SPECIAL_LTE:
+	case SPECIAL_UNSIGNED_LT:
+	case SPECIAL_UNSIGNED_LTE:
+		left_max_true = &capped;
+		right_max_false = &capped;
+		right_min_true = &capped;
+		left_min_false = &capped;
+		break;
+	case '>':
+	case SPECIAL_GTE:
+	case SPECIAL_UNSIGNED_GT:
+	case SPECIAL_UNSIGNED_GTE:
+		left_max_false = &capped;
+		right_max_true = &capped;
+		left_min_true = &capped;
+		right_min_false = &capped;
+		break;
+	case SPECIAL_EQUAL:
+		left_max_true = &capped;
+		right_max_true = &capped;
+		left_min_true = &capped;
+		right_min_true = &capped;
+		break;
+	case SPECIAL_NOTEQUAL:
+		left_max_false = &capped;
+		right_max_false = &capped;
+		left_min_false = &capped;
+		right_min_false = &capped;
+		break;
+	default:
+		return;
+	}
+
+	if (get_state_expr(my_max_id, expr->left)) {
+		set_true_false_states_expr(my_max_id, expr->left, left_max_true, left_max_false);
+		set_true_false_states_expr(my_min_id, expr->left, left_min_true, left_min_false);
+	}
+	if (get_state_expr(my_max_id, expr->right)) {
+		set_true_false_states_expr(my_max_id, expr->right, right_max_true, right_max_false);
+		set_true_false_states_expr(my_min_id, expr->right, right_min_true, right_min_false);
+	}
+}
+
+static void match_normal_assign(struct expression *expr)
+{
+	if (get_state_expr(my_max_id, expr->left)) {
+		set_state_expr(my_max_id, expr->left, &capped);
+		set_state_expr(my_min_id, expr->left, &capped);
+	}
+}
+
+static void match_assign(struct expression *expr)
+{
+	char *name;
+
+	name = get_macro_name(expr->pos);
+	if (!name || strcmp(name, "get_user") != 0) {
+		match_normal_assign(expr);
+		return;
+	}
+	name = expr_to_var(expr->right);
+	if (!name || strcmp(name, "__val_gu") != 0)
+		goto free;
+	set_state_expr(my_max_id, expr->left, &user_data);
+	set_state_expr(my_min_id, expr->left, &user_data);
+free:
+	free_string(name);
+}
+
+static void check_expr(struct expression *expr)
+{
+	struct sm_state *sm;
+	sval_t max;
+	sval_t sval;
+	char *name;
+	int overflow = 0;
+	int underflow = 0;
+
+	sm = get_sm_state_expr(my_max_id, expr);
+	if (sm && slist_has_state(sm->possible, &user_data)) {
+		if (!get_absolute_max(expr, &max) || sval_cmp_val(max, 20000) > 0)
+			overflow = 1;
+	}
+
+	sm = get_sm_state_expr(my_min_id, expr);
+	if (sm && slist_has_state(sm->possible, &user_data)) {
+		if (!get_absolute_min(expr, &sval) ||
+		    (sval_is_negative(sval) && sval_cmp_val(sval, -20000) < 0))
+			underflow = 1;
+	}
+
+	if (!overflow && !underflow)
+		return;
+
+	name = expr_to_var_sym(expr, NULL);
+	if (overflow && underflow)
+		sm_warning("check for integer over/underflow '%s'", name);
+	else if (underflow)
+		sm_warning("check for integer underflow '%s'", name);
+	else
+		sm_warning("check for integer overflow '%s'", name);
+	free_string(name);
+
+	set_state_expr(my_max_id, expr, &capped);
+	set_state_expr(my_min_id, expr, &capped);
+}
+
+static void match_binop(struct expression *expr)
+{
+	if (expr->op == '^')
+		return;
+	if (expr->op == '&')
+		return;
+	if (expr->op == '|')
+		return;
+	if (expr->op == SPECIAL_RIGHTSHIFT)
+		return;
+	if (expr->op == SPECIAL_LEFTSHIFT)
+		return;
+
+	check_expr(expr->left);
+	check_expr(expr->right);
+}
+
+void check_get_user_overflow(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	my_max_id = id;
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_binop, BINOP_HOOK);
+}
+
+void check_get_user_overflow2(int id)
+{
+	my_min_id = id;
+}
diff --git a/usr/src/tools/smatch/src/check_gfp_dma.c b/usr/src/tools/smatch/src/check_gfp_dma.c
new file mode 100644
index 0000000000..aeeb7b31df
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_gfp_dma.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+/* this is stolen from the kernel but it's totally fair use dude...  */
+#define __GFP_DMA       (0x01u)
+#define __GFP_HIGHMEM   (0x02u)
+#define __GFP_DMA32     (0x04u)
+#define __GFP_MOVABLE   (0x08u)
+#define GFP_ZONEMASK    (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)
+
+static void match_alloc(const char *fn, struct expression *expr, void *_arg)
+{
+	int arg_nr = PTR_INT(_arg);
+	struct expression *arg_expr;
+	sval_t sval;
+
+	arg_expr = get_argument_from_call_expr(expr->args, arg_nr);
+	if (!get_value(arg_expr, &sval))
+		return;
+	if (sval.uvalue == 0) /* GFP_NOWAIT */
+		return;
+	if (!(sval.uvalue & ~GFP_ZONEMASK))
+		sm_error("no modifiers for allocation.");
+}
+
+void check_gfp_dma(int id)
+{
+	my_id = id;
+	if (option_project != PROJ_KERNEL)
+		return;
+	add_function_hook("kmalloc", &match_alloc, INT_PTR(1));
+	add_function_hook("kzalloc", &match_alloc, INT_PTR(1));
+}
diff --git a/usr/src/tools/smatch/src/check_held_dev.c b/usr/src/tools/smatch/src/check_held_dev.c
new file mode 100644
index 0000000000..43f61d7712
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_held_dev.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This check is supposed to find bugs in reference counting using dev_hold()
+ * and dev_put().
+ *
+ * When a device is first held, if an error happens later in the function
+ * it needs to be released on all the error paths.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(held);
+STATE(released);
+
+static void match_dev_hold(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg_expr;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 0);
+	set_state_expr(my_id, arg_expr, &held);
+}
+
+static void match_dev_put(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg_expr;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 0);
+	set_state_expr(my_id, arg_expr, &released);
+}
+
+static void match_returns_held(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *unused)
+{
+	if (assign_expr)
+		set_state_expr(my_id, assign_expr->left, &held);
+}
+
+static void match_returns_null(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *unused)
+{
+	if (assign_expr)
+		set_state_expr(my_id, assign_expr->left, &released);
+}
+
+static void check_for_held(void)
+{
+	struct stree *stree;
+	struct sm_state *tmp;
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(my_id, stree, tmp) {
+		if (slist_has_state(tmp->possible, &held)) {
+			sm_warning("'%s' held on error path.",
+				tmp->name);
+		}
+	} END_FOR_EACH_SM(tmp);
+}
+
+static void print_returns_held(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	if (!option_info)
+		return;
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return;
+	if (slist_has_state(sm->possible, &held))
+		sm_info("returned dev is held.");
+}
+
+static void match_return(struct expression *ret_value)
+{
+	print_returns_held(ret_value);
+	if (!is_error_return(ret_value))
+		return;
+	check_for_held();
+}
+
+static void register_returns_held_funcs(void)
+{
+	struct token *token;
+	const char *func;
+
+	token = get_tokens_file("kernel.returns_held_funcs");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		return_implies_state(func, valid_ptr_min, valid_ptr_max,
+				     &match_returns_held, NULL);
+		return_implies_state(func, 0, 0, &match_returns_null,
+					 NULL);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_held_dev(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_function_hook("dev_hold", &match_dev_hold, NULL);
+	add_function_hook("dev_put", &match_dev_put, NULL);
+	register_returns_held_funcs();
+	add_hook(&match_return, RETURN_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_implicit_dependencies.c b/usr/src/tools/smatch/src/check_implicit_dependencies.c
new file mode 100644
index 0000000000..7d776fc2ed
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_implicit_dependencies.c
@@ -0,0 +1,309 @@
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+/* If set, we ignore struct type symbols as implicit dependencies */
+static int ignore_structs;
+
+static struct symbol *cur_syscall;
+/* note: cannot track return type and remove from implicit dependencies,
+ * because every syscall returns a long, and we don't have a good way to know
+ * whether or not this is a resource. The only example I can think of is open
+ * returning a filedescriptor, so in the implicit dep parsing, we will just
+ * blacklist struct fd --> file
+ */
+static struct symbol *cur_return_type;
+static char *syscall_name;
+
+static struct tracker_list *read_list;	// what fields does syscall branch on?
+static struct tracker_list *write_list; // what fields does syscall modify?
+static struct tracker_list *arg_list;	// what struct arguments does the syscall take?
+static struct tracker_list *parsed_syscalls; // syscalls we have already checked
+
+static inline void prefix(void)
+{
+	printf("%s:%d %s() ", get_filename(), get_lineno(), get_function());
+}
+
+static void match_syscall_definition(struct symbol *sym)
+{
+	struct symbol *arg;
+	struct tracker *tracker;
+	char *macro;
+	char *name;
+	int is_syscall = 0;
+
+	macro = get_macro_name(sym->pos);
+	if (macro &&
+	    (strncmp("SYSCALL_DEFINE", macro, strlen("SYSCALL_DEFINE")) == 0 ||
+	     strncmp("COMPAT_SYSCALL_DEFINE", macro, strlen("COMPAT_SYSCALL_DEFINE")) == 0))
+		is_syscall = 1;
+
+	name = get_function();
+
+	if (name && strncmp(name, "sys_", 4) == 0)
+		is_syscall = 1;
+
+	if (name && strncmp(name, "compat_sys_", 11) == 0)
+		is_syscall = 1;
+
+	if (!is_syscall)
+		return;
+
+	FOR_EACH_PTR(parsed_syscalls, tracker) {
+		if (tracker->sym == sym) // don't re-parse
+			return;
+	} END_FOR_EACH_PTR(tracker);
+
+	syscall_name = name;
+	cur_syscall = sym;
+
+	cur_return_type = cur_func_return_type();
+	if (cur_return_type && cur_return_type->ident)
+		sm_msg("return type: %s\n", cur_return_type->ident->name);
+
+
+	FOR_EACH_PTR(sym->ctype.base_type->arguments, arg) {
+		// set_state(my_id, arg->ident->name, arg, &user_data_set);
+		sm_msg("=======check_impl: arguments for call %s=========\n", syscall_name);
+		if (arg->type == SYM_STRUCT)
+			arg = get_real_base_type(arg);
+		if (cur_return_type && cur_return_type->ident)
+			sm_msg("arg type: %s\n", cur_return_type->ident->name);
+		// add_tracker(&arg_list, my_id, member, arg);
+		sm_msg("=================================\n");
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void print_read_list(void)
+{
+    struct tracker *tracker;
+    int i = 0;
+
+    FOR_EACH_PTR(read_list, tracker) {
+	    if (i == 0)
+		    sm_printf("%s read_list: [", syscall_name);
+	    sm_printf("%s, ", tracker->name);
+	    i++;
+    } END_FOR_EACH_PTR(tracker);
+
+    if (i > 0)
+	    sm_printf("]\n");
+}
+
+static void print_write_list(void)
+{
+	struct tracker *tracker;
+	int i = 0;
+
+	FOR_EACH_PTR(write_list, tracker) {
+		if (i == 0)
+			sm_printf("%s write_list: [", syscall_name);
+		sm_printf("%s, ", tracker->name);
+		i++;
+	} END_FOR_EACH_PTR(tracker);
+
+	if (i > 0)
+		sm_printf("]\n");
+}
+
+static void print_arg_list(void)
+{
+	struct tracker *tracker;
+	int i = 0;
+
+	FOR_EACH_PTR(write_list, tracker) {
+		if (i == 0)
+			sm_printf("%s arg_list: [", syscall_name);
+		sm_printf("%s, ", tracker->name);
+		i++;
+	} END_FOR_EACH_PTR(tracker);
+
+	if (i > 0)
+		sm_printf("]\n");
+}
+
+static void match_after_syscall(struct symbol *sym)
+{
+	if (!cur_syscall || sym != cur_syscall)
+		return;
+	// printf("\n"); prefix();
+	// printf("exiting scope of syscall %s\n", get_function());
+	// printf("-------------------------\n");
+	print_read_list();
+	print_write_list();
+	print_arg_list();
+	free_trackers_and_list(&read_list);
+	free_trackers_and_list(&write_list);
+	free_trackers_and_list(&arg_list);
+	add_tracker(&parsed_syscalls, my_id, syscall_name, sym);
+	cur_syscall = NULL;
+	cur_return_type = NULL;
+	syscall_name = NULL;
+}
+
+static void print_read_member_type(struct expression *expr)
+{
+	char *member;
+	struct symbol *sym;
+	struct symbol *member_sym;
+
+	member = get_member_name(expr);
+	if (!member)
+		return;
+
+	sym = get_type(expr->deref);
+	member_sym = get_type(expr);
+
+	if (member_sym->type == SYM_PTR)
+		member_sym = get_real_base_type(member_sym);
+
+	/*
+	if (member_sym->type == SYM_STRUCT)
+		printf("found struct type %s\n", member);
+	else
+		printf("found non-struct type %s with enum value%d\n", member, member_sym->type);
+	*/
+
+	if (ignore_structs && member_sym->type == SYM_STRUCT) {
+		// printf("ignoring %s\n", member);
+		return;
+	}
+
+	add_tracker(&read_list, my_id, member, sym);
+	// sm_msg("info: uses %s", member);
+	// prefix();
+	// printf("info: uses %s\n", member);
+	free_string(member);
+}
+
+static void print_write_member_type(struct expression *expr)
+{
+	char *member;
+	struct symbol *sym;
+	struct symbol *member_sym;
+
+	member = get_member_name(expr);
+	if (!member)
+		return;
+
+	sym = get_type(expr->deref);
+	member_sym = get_type(expr);
+
+	if (member_sym->type == SYM_PTR)
+		member_sym = get_real_base_type(member_sym);
+
+	/*
+	if (member_sym->type == SYM_STRUCT)
+		printf("found struct type %s\n", member);
+	else
+		printf("found non-struct type %s with enum value%d\n", member, member_sym->type);
+	*/
+
+	if (ignore_structs && member_sym->type == SYM_STRUCT) {
+		// printf("ignoring %s\n", member);
+		return;
+	}
+
+	add_tracker(&write_list, my_id, member, sym);
+	free_string(member);
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct expression *arg;
+
+	if (!cur_syscall)
+		return;
+
+	// prefix(); printf("-- condition found\n");
+
+	if (expr->type == EXPR_COMPARE ||
+	    expr->type == EXPR_BINOP ||
+	    expr->type == EXPR_LOGICAL ||
+	    expr->type == EXPR_ASSIGNMENT ||
+	    expr->type == EXPR_COMMA) {
+		match_condition(expr->left);
+		match_condition(expr->right);
+		return;
+	}
+
+	if (expr->type == EXPR_CALL) {
+		FOR_EACH_PTR(expr->args, arg) {
+			// if we find deref in conditional call,
+			// mark it as a read dependency
+			print_read_member_type(arg);
+		} END_FOR_EACH_PTR(arg);
+		return;
+	}
+
+	print_read_member_type(expr);
+}
+
+
+/* when we are parsing an inline function and can no longer nest,
+ * assume that all struct fields passed to nested inline functions
+ * are read dependencies
+ */
+static void match_call_info(struct expression *expr)
+{
+	struct expression *arg;
+	int i;
+
+	if (!__inline_fn || !cur_syscall)
+		return;
+
+	// prefix(); printf("fn: %s\n", expr->fn->symbol->ident->name);
+
+	i = 0;
+	FOR_EACH_PTR(expr->args, arg) {
+		/*
+		   if (arg->type == EXPR_DEREF)
+		   printf("arg %d is deref\n", i);
+		 */
+		print_read_member_type(arg);
+		i++;
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void match_assign_value(struct expression *expr)
+{
+	if (!cur_syscall)
+		return;
+	print_write_member_type(expr->left);
+}
+
+static void unop_expr(struct expression *expr)
+{
+	if (!cur_syscall)
+		return;
+
+	if (expr->op == SPECIAL_ADD_ASSIGN || expr->op == SPECIAL_INCREMENT ||
+	    expr->op == SPECIAL_SUB_ASSIGN || expr->op == SPECIAL_DECREMENT ||
+	    expr->op == SPECIAL_MUL_ASSIGN || expr->op == SPECIAL_DIV_ASSIGN ||
+	    expr->op == SPECIAL_MOD_ASSIGN || expr->op == SPECIAL_AND_ASSIGN ||
+	    expr->op == SPECIAL_OR_ASSIGN || expr->op == SPECIAL_XOR_ASSIGN ||
+	    expr->op == SPECIAL_SHL_ASSIGN || expr->op == SPECIAL_SHR_ASSIGN)
+		print_write_member_type(strip_expr(expr->unop));
+}
+
+void check_implicit_dependencies(int id)
+{
+	my_id = id;
+	ignore_structs = 0;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+	if (!option_info)
+		return;
+
+	add_hook(&match_syscall_definition, AFTER_DEF_HOOK);
+	add_hook(&match_after_syscall, AFTER_FUNC_HOOK);
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_call_info, FUNCTION_CALL_HOOK);
+
+	/* hooks to track written fields */
+	add_hook(&match_assign_value, ASSIGNMENT_HOOK_AFTER);
+	add_hook(&unop_expr, OP_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_implicit_dependencies_tester.c b/usr/src/tools/smatch/src/check_implicit_dependencies_tester.c
new file mode 100644
index 0000000000..6dcb4b52d1
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_implicit_dependencies_tester.c
@@ -0,0 +1,168 @@
+#include "smatch.h"
+#include "linearize.h"
+
+static int my_id;
+static struct symbol *cur_syscall;
+
+static const char *expression_type_name(enum expression_type type)
+{
+	static const char *expression_type_name[] = {
+		[EXPR_VALUE] = "EXPR_VALUE",
+		[EXPR_STRING] = "EXPR_STRING",
+		[EXPR_SYMBOL] = "EXPR_SYMBOL",
+		[EXPR_TYPE] = "EXPR_TYPE",
+		[EXPR_BINOP] = "EXPR_BINOP",
+		[EXPR_ASSIGNMENT] = "EXPR_ASSIGNMENT",
+		[EXPR_LOGICAL] = "EXPR_LOGICAL",
+		[EXPR_DEREF] = "EXPR_DEREF",
+		[EXPR_PREOP] = "EXPR_PREOP",
+		[EXPR_POSTOP] = "EXPR_POSTOP",
+		[EXPR_CAST] = "EXPR_CAST",
+		[EXPR_FORCE_CAST] = "EXPR_FORCE_CAST",
+		[EXPR_IMPLIED_CAST] = "EXPR_IMPLIED_CAST",
+		[EXPR_SIZEOF] = "EXPR_SIZEOF",
+		[EXPR_ALIGNOF] = "EXPR_ALIGNOF",
+		[EXPR_PTRSIZEOF] = "EXPR_PTRSIZEOF",
+		[EXPR_CONDITIONAL] = "EXPR_CONDITIONAL",
+		[EXPR_SELECT] = "EXPR_SELECT",
+		[EXPR_STATEMENT] = "EXPR_STATEMENT",
+		[EXPR_CALL] = "EXPR_CALL",
+		[EXPR_COMMA] = "EXPR_COMMA",
+		[EXPR_COMPARE] = "EXPR_COMPARE",
+		[EXPR_LABEL] = "EXPR_LABEL",
+		[EXPR_INITIALIZER] = "EXPR_INITIALIZER",
+		[EXPR_IDENTIFIER] = "EXPR_IDENTIFIER",
+		[EXPR_INDEX] = "EXPR_INDEX",
+		[EXPR_POS] = "EXPR_POS",
+		[EXPR_FVALUE] = "EXPR_FVALUE",
+		[EXPR_SLICE] = "EXPR_SLICE",
+		[EXPR_OFFSETOF] = "EXPR_OFFSETOF",
+	};
+	return expression_type_name[type] ?: "UNKNOWN_EXPRESSION_TYPE";
+}
+
+static inline void prefix() {
+	printf("%s:%d %s() ", get_filename(), get_lineno(), get_function());
+}
+
+static void match_syscall_definition(struct symbol *sym)
+{
+	// struct symbol *arg;
+	char *macro;
+	char *name;
+	int is_syscall = 0;
+
+	macro = get_macro_name(sym->pos);
+	if (macro &&
+	    (strncmp("SYSCALL_DEFINE", macro, strlen("SYSCALL_DEFINE")) == 0 ||
+	     strncmp("COMPAT_SYSCALL_DEFINE", macro, strlen("COMPAT_SYSCALL_DEFINE")) == 0))
+		is_syscall = 1;
+
+	name = get_function();
+	
+	/* 
+	if (!option_no_db && get_state(my_id, "this_function", NULL) != &called) {
+		if (name && strncmp(name, "sys_", 4) == 0)
+			is_syscall = 1;
+	}
+	*/
+
+	/* Ignore compat_sys b/c syzkaller doesn't fuzz these?
+	if (name && strncmp(name, "compat_sys_", 11) == 0)
+		is_syscall = 1;
+	*/
+
+	if (!is_syscall)
+		return;
+	printf("-------------------------\n");	
+	printf("\nsyscall found: %s at: ", name);
+	prefix(); printf("\n");
+	cur_syscall = sym;
+
+	/*
+	FOR_EACH_PTR(sym->ctype.base_type->arguments, arg) {
+		set_state(my_id, arg->ident->name, arg, &user_data_set);
+	} END_FOR_EACH_PTR(arg);
+	*/
+}
+
+static void match_after_syscall(struct symbol *sym) {
+    if (cur_syscall && sym == cur_syscall) {
+	printf("\n"); prefix();
+	printf("exiting scope of syscall %s\n", get_function());
+	printf("-------------------------\n");	
+	cur_syscall = NULL;
+    }
+}
+
+static void print_member_type(struct expression *expr)
+{
+	char *member;
+
+	member = get_member_name(expr);
+	if (!member)
+		return;
+	// sm_msg("info: uses %s", member);
+	prefix();
+	printf("info: uses %s\n", member);
+	free_string(member);
+}
+
+static void match_condition(struct expression *expr) {
+    if (!cur_syscall)
+	return;
+    
+    /*
+    prefix();
+    printf("found conditional %s on line %d\n", expression_type_name(expr->type), get_lineno());
+    printf("expr_str: %s\n", expr_to_str(expr));
+    */
+
+    /* 
+    switch (expr->type) {
+	case EXPR_COMPARE:
+	    match_condition(expr->left);
+	    match_condition(expr->right);
+	    break;
+	case EXPR_SYMBOL:
+	    printf("symbol: %s\n", expr->symbol_name->name);
+	    break;
+	case EXPR_CALL:
+	    break;
+    }
+    */
+
+    prefix(); printf("-- condition found\n");
+
+    if (expr->type == EXPR_COMPARE || expr->type == EXPR_BINOP
+	    || expr->type == EXPR_LOGICAL
+	    || expr->type == EXPR_ASSIGNMENT
+	    || expr->type == EXPR_COMMA) {
+	    match_condition(expr->left);
+	    match_condition(expr->right);
+	    return;
+    }
+    print_member_type(expr);
+
+}
+
+static void match_function_call(struct expression *expr) {
+    if (!cur_syscall)
+	return;
+    prefix();
+    printf("function call %s\n", expression_type_name(expr->type)); 
+}
+
+void check_implicit_dependencies_tester(int id)
+{
+    my_id = id;
+
+    if (option_project != PROJ_KERNEL)
+	return;
+
+    add_hook(&match_syscall_definition, AFTER_DEF_HOOK);
+    add_hook(&match_after_syscall, AFTER_FUNC_HOOK);
+    add_hook(&match_condition, CONDITION_HOOK);
+    add_hook(&match_function_call, FUNCTION_CALL_HOOK);
+}
+
diff --git a/usr/src/tools/smatch/src/check_impossible_mask.c b/usr/src/tools/smatch/src/check_impossible_mask.c
new file mode 100644
index 0000000000..b33e846e63
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_impossible_mask.c
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+#if 0
+static unsigned long long find_possible_bits(struct expression *expr)
+{
+	sval_t sval;
+	unsigned long long ret;
+	int set;
+	int i;
+
+	expr = strip_expr(expr);
+
+	if (get_implied_value(expr, &sval))
+		return sval.uvalue;
+
+	if (expr->type == EXPR_BINOP && (expr->op == '&' || expr->op == '|')) {
+		unsigned long long left, right;
+
+		left = find_possible_bits(expr->left);
+		if (!left)
+			return 0;
+		right = find_possible_bits(expr->right);
+		if (!right)
+			return 0;
+
+		if (expr->op == '&')
+			return left & right;
+		return left | right;
+	}
+
+	get_absolute_max(expr, &sval);
+	ret = sval.value;
+
+	set = false;
+	for (i = 63; i >= 0; i--) {
+		if (ret & 1 << i)
+			set = true;
+		if (set)
+			ret |= 1 << i;
+	}
+	return ret;
+}
+#endif
+
+static unsigned long long get_possible_bits(struct expression *expr)
+{
+	sval_t sval;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_BINOP)
+		return 0;
+	if (expr->op != '&')
+		return 0;
+	if (!get_implied_value(expr->right, &sval))
+		return 0;
+
+	return sval.uvalue;
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct symbol *type;
+	sval_t sval;
+	unsigned long long left_mask, right_mask;
+	char *str;
+
+	type = get_type(expr);
+	if (!type)
+		type = &int_ctype;
+
+	if (expr->type != EXPR_COMPARE)
+		return;
+	if (expr->op != SPECIAL_EQUAL && expr->op != SPECIAL_NOTEQUAL)
+		return;
+
+	if (!get_value(expr->right, &sval))
+		return;
+	right_mask = sval.uvalue;
+
+	left_mask = get_possible_bits(expr->left);
+	if (!left_mask)
+		return;
+
+	if (type_bits(type) < 64) {
+		left_mask &= (1ULL << type_bits(type)) - 1;
+		right_mask &= (1ULL << type_bits(type)) - 1;
+	}
+
+	if ((left_mask & right_mask) == right_mask)
+		return;
+
+	str = expr_to_str(expr);
+	sm_warning("masked condition '%s' is always %s.", str,
+	       expr->op == SPECIAL_EQUAL ? "false" : "true");
+	free_string(str);
+}
+
+void check_impossible_mask(int id)
+{
+	my_id = id;
+
+	add_hook(&match_condition, CONDITION_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_indenting.c b/usr/src/tools/smatch/src/check_indenting.c
new file mode 100644
index 0000000000..76a52f8210
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_indenting.c
@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static struct string_list *ignored_macros;
+
+static int in_ignored_macro(struct statement *stmt)
+{
+	const char *macro;
+	char *tmp;
+
+	macro = get_macro_name(stmt->pos);
+	if (!macro)
+		return 0;
+
+	FOR_EACH_PTR(ignored_macros, tmp) {
+		if (!strcmp(tmp, macro))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static int missing_curly_braces(struct statement *stmt)
+{
+	int inside_pos;
+
+	if (stmt->pos.pos == __prev_stmt->pos.pos)
+		return 0;
+
+	if (__prev_stmt->type == STMT_IF) {
+		if (__prev_stmt->if_true->type == STMT_COMPOUND)
+			return 0;
+		inside_pos = __prev_stmt->if_true->pos.pos;
+	} else if (__prev_stmt->type == STMT_ITERATOR) {
+		if (!__prev_stmt->iterator_pre_condition)
+			return 0;
+		if (__prev_stmt->iterator_statement->type == STMT_COMPOUND)
+			return 0;
+		inside_pos = __prev_stmt->iterator_statement->pos.pos;
+	} else {
+		return 0;
+	}
+
+	if (stmt->pos.pos != inside_pos)
+		return 0;
+
+	sm_warning("curly braces intended?");
+	return 1;
+}
+
+static int prev_lines_say_endif(struct statement *stmt)
+{
+	struct token *token;
+	struct position pos = stmt->pos;
+	int i;
+
+	pos.pos = 2;
+
+	for (i = 0; i < 4; i++) {
+		pos.line--;
+		token = pos_get_token(pos);
+		if (token && token_type(token) == TOKEN_IDENT &&
+		    strcmp(show_ident(token->ident), "endif") == 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+static int is_pre_or_post_statement(struct statement *stmt)
+{
+	if (!stmt->parent)
+		return 0;
+	if (stmt->parent->type != STMT_ITERATOR)
+		return 0;
+	if (stmt->parent->iterator_pre_statement == stmt ||
+	    stmt->parent->iterator_post_statement == stmt)
+		return 1;
+	return 0;
+}
+
+/*
+ * If we go out of position, then warn, but don't warn when we go back
+ * into the correct position.
+ */
+static int orig_pos;
+
+/*
+ * If the code has two statements on the same line then don't complain
+ * on the following line.  This is a bit of hack because it relies on the
+ * quirk that we don't process nested inline functions.
+ */
+static struct position ignore_prev;
+static struct position ignore_prev_inline;
+
+static void match_stmt(struct statement *stmt)
+{
+	if (stmt != __cur_stmt)
+		return;
+	if (!__prev_stmt)
+		return;
+
+	if (prev_lines_say_endif(stmt))
+		return;
+
+	if (is_pre_or_post_statement(stmt))
+		return;
+	/* ignore empty statements if (foo) frob();; */
+	if (stmt->type == STMT_EXPRESSION && !stmt->expression)
+		return;
+	if (__prev_stmt->type == STMT_EXPRESSION && !__prev_stmt->expression)
+		return;
+
+	if (__prev_stmt->type == STMT_LABEL || __prev_stmt->type == STMT_CASE)
+		return;
+	/*
+	 * This is sort of ugly.  The first statement after a case/label is
+	 * special.  Probably we should handle this in smatch_flow.c so that
+	 * this is not a special case.  Anyway it's like this:
+	 * "foo: one++; two++;"  The code is on the same line.
+	 * Also there is still a false positive here, if the first case
+	 * statement has two statements on the same line.  I'm not sure what the
+	 * deal is with that.
+	 */
+	if (stmt->type == STMT_CASE) {
+		if (__next_stmt &&
+		    __next_stmt->pos.line == stmt->case_statement->pos.line)
+			ignore_prev = __next_stmt->pos;
+		return;
+	}
+	if (stmt->type == STMT_LABEL) {
+		if (__next_stmt &&
+		    __next_stmt->pos.line == stmt->label_statement->pos.line)
+			ignore_prev = __next_stmt->pos;
+		return;
+	}
+
+	if (missing_curly_braces(stmt))
+		return;
+
+	if (stmt->pos.line == __prev_stmt->pos.line) {
+		if (__inline_fn)
+			ignore_prev_inline = stmt->pos;
+		else
+			ignore_prev = stmt->pos;
+		return;
+	}
+	if (stmt->pos.pos == __prev_stmt->pos.pos)
+		return;
+
+	/* some people like to line up their break and case statements. */
+	if (stmt->type == STMT_GOTO && stmt->goto_label &&
+	    stmt->goto_label->type == SYM_NODE &&
+	    strcmp(stmt->goto_label->ident->name, "break") == 0) {
+		if (__next_stmt && __next_stmt->type == STMT_CASE &&
+		    (stmt->pos.line == __next_stmt->pos.line ||
+		     stmt->pos.pos == __next_stmt->pos.pos))
+			return;
+		/*
+		 * If we have a compound and the last statement is a break then
+		 * it's probably intentional.  This is most likely inside a
+		 * case statement.
+		 */
+		if (!__next_stmt)
+			return;
+	}
+
+	if (cmp_pos(__prev_stmt->pos, ignore_prev) == 0 ||
+	    cmp_pos(__prev_stmt->pos, ignore_prev_inline) == 0)
+		return;
+
+	if (in_ignored_macro(stmt))
+		return;
+
+	if (stmt->pos.pos == orig_pos) {
+		orig_pos = 0;
+		return;
+	}
+	sm_warning("inconsistent indenting");
+	orig_pos = __prev_stmt->pos.pos;
+}
+
+static void match_end_func(void)
+{
+	if (__inline_fn)
+		return;
+	orig_pos = 0;
+}
+
+static void register_ignored_macros(void)
+{
+	struct token *token;
+	char *macro;
+	char name[256];
+
+	snprintf(name, 256, "%s.ignore_macro_indenting", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		macro = alloc_string(show_ident(token->ident));
+		add_ptr_list(&ignored_macros, macro);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_indenting(int id)
+{
+	my_id = id;
+	add_hook(&match_stmt, STMT_HOOK);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+	register_ignored_macros();
+}
diff --git a/usr/src/tools/smatch/src/check_index_overflow.c b/usr/src/tools/smatch/src/check_index_overflow.c
new file mode 100644
index 0000000000..39815e657c
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_index_overflow.c
@@ -0,0 +1,367 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdlib.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int loop_id;
+
+STATE(loop_end);
+
+static int definitely_just_used_as_limiter(struct expression *array, struct expression *offset)
+{
+	sval_t sval;
+	struct expression *tmp;
+
+	if (!get_implied_value(offset, &sval))
+		return 0;
+	if (get_array_size(array) != sval.value)
+		return 0;
+
+	tmp = array;
+	while ((tmp = expr_get_parent_expr(tmp))) {
+		if (tmp->type == EXPR_PREOP && tmp->op == '&')
+			return 1;
+	}
+
+	return 0;
+}
+
+static int fake_get_hard_max(struct expression *expr, sval_t *sval)
+{
+	struct range_list *implied_rl;
+
+	if (!get_hard_max(expr, sval))
+		return 0;
+
+	/*
+	 * The problem is that hard_max doesn't care about minimums
+	 * properly.  So if you give it thing like:
+	 *	err = (-10)-(-1)
+	 *	__smatch_hard_max(-err);
+	 *
+	 * Then it returns s32max instead of 10.
+	 */
+
+	if (get_implied_rl(expr, &implied_rl) &&
+	    sval_cmp(rl_max(implied_rl), *sval) < 0)
+		*sval = rl_max(implied_rl);
+	return 1;
+}
+
+static int get_the_max(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+
+	if (get_hard_max(expr, sval)) {
+		struct range_list *implied_rl;
+
+		/*
+		 * The problem is that hard_max doesn't care about minimums
+		 * properly.  So if you give it thing like:
+		 *	err = (-10)-(-1)
+		 *	__smatch_hard_max(-err);
+		 *
+		 * Then it returns s32max instead of 10.
+		 */
+
+		if (get_implied_rl(expr, &implied_rl) &&
+		    sval_cmp(rl_max(implied_rl), *sval) < 0)
+			*sval = rl_max(implied_rl);
+		return 1;
+	}
+	if (!option_spammy)
+		return 0;
+
+	/* Fixme:  use fuzzy max */
+
+	if (!get_user_rl(expr, &rl))
+		return 0;
+	if (rl_max(rl).uvalue > sval_type_max(rl_type(rl)).uvalue - 4 &&
+	    is_capped(expr))
+		return 0;
+
+	*sval = rl_max(rl);
+	return 1;
+}
+
+static int common_false_positives(struct expression *array, sval_t max)
+{
+	char *name;
+	int ret;
+
+	name = expr_to_str(array);
+
+	/* Smatch can't figure out glibc's strcmp __strcmp_cg()
+	 * so it prints an error every time you compare to a string
+	 * literal array with 4 or less chars.
+	 */
+	if (name &&
+	    (strcmp(name, "__s1") == 0 || strcmp(name, "__s2") == 0)) {
+		ret = 1;
+		goto free;
+	}
+
+	/* Ugh... People are saying that Smatch still barfs on glibc strcmp()
+	 * functions.
+	 */
+	if (array) {
+		char *macro;
+
+		/* why is this again??? */
+		if (array->type == EXPR_STRING &&
+		    max.value == array->string->length) {
+			ret = 1;
+			goto free;
+		}
+
+		macro = get_macro_name(array->pos);
+		if (macro && max.uvalue < 4 &&
+		    (strcmp(macro, "strcmp")  == 0 ||
+		     strcmp(macro, "strncmp") == 0 ||
+		     strcmp(macro, "streq")   == 0 ||
+		     strcmp(macro, "strneq")  == 0 ||
+		     strcmp(macro, "strsep")  == 0)) {
+			ret = 1;
+			goto free;
+		}
+	}
+
+	/*
+	 * passing WORK_CPU_UNBOUND is idiomatic but Smatch doesn't understand
+	 * how it's used so it causes a bunch of false positives.
+	 */
+	if (option_project == PROJ_KERNEL && name &&
+	    strcmp(name, "__per_cpu_offset") == 0) {
+		ret = 1;
+		goto free;
+	}
+	ret = 0;
+
+free:
+	free_string(name);
+	return ret;
+}
+
+static int is_subtract(struct expression *expr)
+{
+	struct expression *tmp;
+	int cnt = 0;
+
+	expr = strip_expr(expr);
+	while ((tmp = get_assigned_expr(expr))) {
+		expr = strip_expr(tmp);
+		if (++cnt > 5)
+			break;
+	}
+
+	if (expr->type == EXPR_BINOP && expr->op == '-')
+		return 1;
+	return 0;
+}
+
+static int constraint_met(struct expression *array_expr, struct expression *offset)
+{
+	char *data_str, *required, *unmet;
+	int ret = 0;
+
+	data_str = get_constraint_str(array_expr);
+	if (!data_str)
+		return 0;
+
+	required = get_required_constraint(data_str);
+	if (!required)
+		goto free_data_str;
+
+	unmet = unmet_constraint(array_expr, offset);
+	if (!unmet)
+		ret = 1;
+	free_string(unmet);
+	free_string(required);
+
+free_data_str:
+	free_string(data_str);
+	return ret;
+}
+
+
+static int should_warn(struct expression *expr)
+{
+	struct expression *array_expr;
+	struct range_list *abs_rl;
+	sval_t hard_max = { .type = &int_ctype, };
+	sval_t fuzzy_max = { .type = &int_ctype, };
+	int array_size;
+	struct expression *offset;
+	sval_t max;
+
+	expr = strip_expr(expr);
+	if (!is_array(expr))
+		return 0;
+
+	if (is_impossible_path())
+		return 0;
+	array_expr = get_array_base(expr);
+	array_size = get_array_size(array_expr);
+	if (!array_size || array_size == 1)
+		return 0;
+
+	offset = get_array_offset(expr);
+	get_absolute_rl(offset, &abs_rl);
+	fake_get_hard_max(offset, &hard_max);
+	get_fuzzy_max(offset, &fuzzy_max);
+
+	if (!get_the_max(offset, &max))
+		return 0;
+	if (array_size > max.value)
+		return 0;
+	if (constraint_met(array_expr, offset))
+		return 0;
+
+	if (array_size > rl_max(abs_rl).uvalue)
+		return 0;
+
+	if (definitely_just_used_as_limiter(array_expr, offset))
+		return 0;
+
+	array_expr = strip_expr(array_expr);
+	if (common_false_positives(array_expr, max))
+		return 0;
+
+	if (impossibly_high_comparison(offset))
+		return 0;
+
+	return 1;
+
+}
+
+static int is_because_of_no_break(struct expression *offset)
+{
+	if (get_state_expr(loop_id, offset) == &loop_end)
+		return 1;
+	return 0;
+}
+
+static void array_check(struct expression *expr)
+{
+	struct expression *array_expr;
+	struct range_list *abs_rl;
+	struct range_list *user_rl = NULL;
+	sval_t hard_max = { .type = &int_ctype, };
+	sval_t fuzzy_max = { .type = &int_ctype, };
+	int array_size;
+	struct expression *array_size_value, *comparison;
+	struct expression *offset;
+	sval_t max;
+	char *name;
+	int no_break = 0;
+
+	if (!should_warn(expr))
+		return;
+
+	expr = strip_expr(expr);
+	array_expr = get_array_base(expr);
+	array_size = get_array_size(array_expr);
+	offset = get_array_offset(expr);
+
+	/*
+	 * Perhaps if the offset is out of bounds that means a constraint
+	 * applies or maybe it means we are on an impossible path.  So test
+	 * again based on that assumption.
+	 *
+	 */
+	array_size_value = value_expr(array_size);
+	comparison = compare_expression(offset, SPECIAL_GTE, array_size_value);
+	if (assume(comparison)) {
+		if (!should_warn(expr)) {
+			end_assume();
+			return;
+		}
+		no_break = is_because_of_no_break(offset);
+		end_assume();
+	}
+
+	get_absolute_rl(offset, &abs_rl);
+	get_user_rl(offset, &user_rl);
+	fake_get_hard_max(offset, &hard_max);
+	get_fuzzy_max(offset, &fuzzy_max);
+
+	array_expr = strip_expr(array_expr);
+	name = expr_to_str(array_expr);
+
+	if (user_rl)
+		max = rl_max(user_rl);
+	else
+		max = rl_max(abs_rl);
+
+	if (!option_spammy && is_subtract(offset))
+		return;
+
+	if (no_break) {
+		sm_error("buffer overflow '%s' %d <= %s (assuming for loop doesn't break)",
+			name, array_size, sval_to_str(max));
+	} else if (user_rl) {
+		sm_error("buffer overflow '%s' %d <= %s user_rl='%s'%s",
+			name, array_size, sval_to_str(max), show_rl(user_rl),
+			is_subtract(offset) ? " subtract" : "");
+	} else {
+		sm_error("buffer overflow '%s' %d <= %s%s",
+			name, array_size, sval_to_str(max),
+			is_subtract(offset) ? " subtract" : "");
+	}
+
+	free_string(name);
+}
+
+void check_index_overflow(int id)
+{
+	add_hook(&array_check, OP_HOOK);
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct statement *stmt;
+
+	if (expr->type != EXPR_COMPARE)
+		return;
+	if (expr->op != '<' && expr->op != SPECIAL_UNSIGNED_LT)
+		return;
+
+	stmt = expr_get_parent_stmt(expr);
+	if (!stmt || stmt->type != STMT_ITERATOR)
+		return;
+
+	set_true_false_states_expr(loop_id, expr->left, NULL, &loop_end);
+}
+
+static void set_undefined(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state == &loop_end)
+		set_state(loop_id, sm->name, sm->sym, &undefined);
+}
+
+void check_index_overflow_loop_marker(int id)
+{
+	loop_id = id;
+
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_modification_hook(loop_id, &set_undefined);
+}
+
diff --git a/usr/src/tools/smatch/src/check_info_leak.c b/usr/src/tools/smatch/src/check_info_leak.c
new file mode 100644
index 0000000000..4059270a21
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_info_leak.c
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(alloced);
+STATE(string);
+
+static char *my_get_variable(struct expression *expr, struct symbol **sym)
+{
+	char *name;
+
+	name = expr_to_var_sym(expr, sym);
+	free_string(name);
+	if (!name || !*sym)
+		return NULL;
+
+	return (*sym)->ident->name;
+}
+
+static void match_kmalloc(const char *fn, struct expression *expr, void *unused)
+{
+	char *name;
+	struct symbol *sym;
+
+	name = my_get_variable(expr->left, &sym);
+	if (!name)
+		return;
+	set_state(my_id, name, sym, &alloced);
+}
+
+static void match_strcpy(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *dest;
+	char *name;
+	struct symbol *sym;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	name = my_get_variable(dest, &sym);
+	if (!name || !sym)
+		return;
+	if (!get_state(my_id, name, sym))
+		return;
+	set_state(my_id, name, sym, &string);
+}
+
+static void match_copy_to_user(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *src;
+	char *name;
+	struct symbol *sym;
+	struct sm_state *sm;
+
+	src = get_argument_from_call_expr(expr->args, 1);
+	name = my_get_variable(src, &sym);
+	if (!name || !sym)
+		return;
+	sm = get_sm_state(my_id, name, sym);
+	if (!sm || !slist_has_state(sm->possible, &string))
+		return;
+	name = expr_to_var(src);
+	sm_warning("possible info leak '%s'", name);
+	free_string(name);
+}
+
+void check_info_leak(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	my_id = id;
+	add_function_assign_hook("kmalloc", &match_kmalloc, NULL);
+	add_function_hook("strcpy", &match_strcpy, NULL);
+	add_function_hook("strlcpy", &match_strcpy, NULL);
+	add_function_hook("strlcat", &match_strcpy, NULL);
+	add_function_hook("strncpy", &match_strcpy, NULL);
+	add_function_hook("copy_to_user", &match_copy_to_user, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_input_free_device.c b/usr/src/tools/smatch/src/check_input_free_device.c
new file mode 100644
index 0000000000..b450670a74
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_input_free_device.c
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Don't call input_free_device() after calling
+ * input_unregister_device()
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+STATE(no_free);
+STATE(ok);
+
+static int my_id;
+
+static void match_assign(struct expression *expr)
+{
+	if (get_state_expr(my_id, expr->left)) {
+		set_state_expr(my_id, expr->left, &ok);
+	}
+}
+
+static void match_input_unregister(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	set_state_expr(my_id, arg, &no_free);
+}
+
+static void match_input_free(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg;
+	struct sm_state *sm;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	sm = get_sm_state_expr(my_id, arg);
+	if (!sm)
+		return;
+	if (!slist_has_state(sm->possible, &no_free))
+		return;
+	sm_error("don't call input_free_device() after input_unregister_device()");
+}
+
+void check_input_free_device(int id)
+{
+	my_id = id;
+	if (option_project != PROJ_KERNEL)
+		return;
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_function_hook("input_unregister_device", &match_input_unregister, NULL);
+	add_function_hook("input_free_device", &match_input_free, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_kernel.c b/usr/src/tools/smatch/src/check_kernel.c
new file mode 100644
index 0000000000..98a4342fe7
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_kernel.c
@@ -0,0 +1,416 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is kernel specific stuff for smatch_extra.
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int implied_err_cast_return(struct expression *call, void *unused, struct range_list **rl)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(call->args, 0);
+	if (!get_implied_rl(arg, rl))
+		*rl = alloc_rl(ll_to_sval(-4095), ll_to_sval(-1));
+	return 1;
+}
+
+static void hack_ERR_PTR(struct symbol *sym)
+{
+	struct symbol *arg;
+	struct smatch_state *estate;
+	struct range_list *after;
+	sval_t low_error;
+	sval_t minus_one;
+	sval_t zero;
+
+	low_error.type = &long_ctype;
+	low_error.value = -4095;
+
+	minus_one.type = &long_ctype;
+	minus_one.value = -1;
+
+	zero.type = &long_ctype;
+	zero.value = 0;
+
+	if (!sym || !sym->ident)
+		return;
+	if (strcmp(sym->ident->name, "ERR_PTR") != 0)
+		return;
+
+	arg = first_ptr_list((struct ptr_list *)sym->ctype.base_type->arguments);
+	if (!arg || !arg->ident)
+		return;
+
+	estate = get_state(SMATCH_EXTRA, arg->ident->name, arg);
+	if (!estate) {
+		after = alloc_rl(low_error, minus_one);
+	} else {
+		after = rl_intersection(estate_rl(estate), alloc_rl(low_error, zero));
+		if (rl_equiv(estate_rl(estate), after))
+			return;
+	}
+	set_state(SMATCH_EXTRA, arg->ident->name, arg, alloc_estate_rl(after));
+}
+
+static void match_param_valid_ptr(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *_param)
+{
+	int param = PTR_INT(_param);
+	struct expression *arg;
+	struct smatch_state *pre_state;
+	struct smatch_state *end_state;
+
+	arg = get_argument_from_call_expr(call_expr->args, param);
+	pre_state = get_state_expr(SMATCH_EXTRA, arg);
+	end_state = estate_filter_range(pre_state, ll_to_sval(-4095), ll_to_sval(0));
+	set_extra_expr_nomod(arg, end_state);
+}
+
+static void match_param_err_or_null(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *_param)
+{
+	int param = PTR_INT(_param);
+	struct expression *arg;
+	struct range_list *rl;
+	struct smatch_state *pre_state;
+	struct smatch_state *end_state;
+
+	arg = get_argument_from_call_expr(call_expr->args, param);
+	pre_state = get_state_expr(SMATCH_EXTRA, arg);
+	rl = alloc_rl(ll_to_sval(-4095), ll_to_sval(0));
+	rl = rl_intersection(estate_rl(pre_state), rl);
+	rl = cast_rl(estate_type(pre_state), rl);
+	end_state = alloc_estate_rl(rl);
+	set_extra_expr_nomod(arg, end_state);
+}
+
+static void match_not_err(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *unused)
+{
+	struct expression *arg;
+	struct smatch_state *pre_state;
+	struct smatch_state *new_state;
+
+	arg = get_argument_from_call_expr(call_expr->args, 0);
+	pre_state = get_state_expr(SMATCH_EXTRA, arg);
+	new_state = estate_filter_range(pre_state, sval_type_min(&long_ctype), ll_to_sval(-1));
+	set_extra_expr_nomod(arg, new_state);
+}
+
+static void match_err(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *unused)
+{
+	struct expression *arg;
+	struct smatch_state *pre_state;
+	struct smatch_state *new_state;
+
+	arg = get_argument_from_call_expr(call_expr->args, 0);
+	pre_state = get_state_expr(SMATCH_EXTRA, arg);
+	new_state = estate_filter_range(pre_state, sval_type_min(&long_ctype), ll_to_sval(-4096));
+	new_state = estate_filter_range(new_state, ll_to_sval(0), sval_type_max(&long_ctype));
+	set_extra_expr_nomod(arg, new_state);
+}
+
+static void match_container_of_macro(const char *fn, struct expression *expr, void *unused)
+{
+	set_extra_expr_mod(expr->left, alloc_estate_range(valid_ptr_min_sval, valid_ptr_max_sval));
+}
+
+static void match_container_of(struct expression *expr)
+{
+	struct expression *right = expr->right;
+	char *macro;
+
+	/*
+	 * The problem here is that sometimes the container_of() macro is itself
+	 * inside a macro and get_macro() only returns the name of the outside
+	 * macro.
+	 */
+
+	/*
+	 * This actually an expression statement assignment but smatch_flow
+	 * pre-mangles it for us so we only get the last chunk:
+	 * sk = (typeof(sk))((char *)__mptr - offsetof(...))
+	 */
+
+	macro = get_macro_name(right->pos);
+	if (!macro)
+		return;
+	if (right->type != EXPR_CAST)
+		return;
+	right = strip_expr(right);
+	if (right->type != EXPR_BINOP || right->op != '-' ||
+	    right->left->type != EXPR_CAST)
+		return;
+	right = strip_expr(right->left);
+	if (right->type != EXPR_SYMBOL)
+		return;
+	if (!right->symbol->ident ||
+	    strcmp(right->symbol->ident->name, "__mptr") != 0)
+		return;
+	set_extra_expr_mod(expr->left, alloc_estate_range(valid_ptr_min_sval, valid_ptr_max_sval));
+}
+
+static int match_next_bit(struct expression *call, void *unused, struct range_list **rl)
+{
+	struct expression *start_arg;
+	struct expression *size_arg;
+	struct symbol *type;
+	sval_t min, max, tmp;
+
+	size_arg = get_argument_from_call_expr(call->args, 1);
+	/* btw. there isn't a start_arg for find_first_bit() */
+	start_arg = get_argument_from_call_expr(call->args, 2);
+
+	type = get_type(call);
+	min = sval_type_val(type, 0);
+	max = sval_type_val(type, sizeof(long long) * 8);
+
+	if (get_implied_max(size_arg, &tmp) && tmp.uvalue < max.value)
+		max = tmp;
+	if (start_arg && get_implied_min(start_arg, &tmp) && !sval_is_negative(tmp))
+		min = tmp;
+	if (sval_cmp(min, max) > 0)
+		max = min;
+	min = sval_cast(type, min);
+	max = sval_cast(type, max);
+	*rl = alloc_rl(min, max);
+	return 1;
+}
+
+static int match_fls(struct expression *call, void *unused, struct range_list **rl)
+{
+	struct expression *arg;
+	struct range_list *arg_rl;
+	sval_t zero = {};
+	sval_t start, end, sval;
+
+	start.type = &int_ctype;
+	start.value = 0;
+	end.type = &int_ctype;
+	end.value = 32;
+
+	arg = get_argument_from_call_expr(call->args, 0);
+	if (!get_implied_rl(arg, &arg_rl))
+		return 0;
+	if (rl_to_sval(arg_rl, &sval)) {
+		int i;
+
+		for (i = 63; i >= 0; i--) {
+			if (sval.uvalue & 1ULL << i)
+				break;
+		}
+		sval.value = i + 1;
+		*rl = alloc_rl(sval, sval);
+		return 1;
+	}
+	zero.type = rl_type(arg_rl);
+	if (!rl_has_sval(arg_rl, zero))
+		start.value = 1;
+	*rl = alloc_rl(start, end);
+	return 1;
+}
+
+
+
+static void find_module_init_exit(struct symbol_list *sym_list)
+{
+	struct symbol *sym;
+	struct symbol *fn;
+	struct statement *stmt;
+	char *name;
+	int init;
+	int count;
+
+	/*
+	 * This is more complicated because Sparse ignores the "alias"
+	 * attribute.  I search backwards because module_init() is normally at
+	 * the end of the file.
+	 */
+	count = 0;
+	FOR_EACH_PTR_REVERSE(sym_list, sym) {
+		if (sym->type != SYM_NODE)
+			continue;
+		if (!(sym->ctype.modifiers & MOD_STATIC))
+			continue;
+		fn = get_base_type(sym);
+		if (!fn)
+			continue;
+		if (fn->type != SYM_FN)
+			continue;
+		if (!sym->ident)
+			continue;
+		if (!fn->inline_stmt)
+			continue;
+		if (strcmp(sym->ident->name, "__inittest") == 0)
+			init = 1;
+		else if (strcmp(sym->ident->name, "__exittest") == 0)
+			init = 0;
+		else
+			continue;
+
+		count++;
+
+		stmt = first_ptr_list((struct ptr_list *)fn->inline_stmt->stmts);
+		if (!stmt || stmt->type != STMT_RETURN)
+			continue;
+		name = expr_to_var(stmt->ret_value);
+		if (!name)
+			continue;
+		if (init)
+			sql_insert_function_ptr(name, "(struct module)->init");
+		else
+			sql_insert_function_ptr(name, "(struct module)->exit");
+		free_string(name);
+		if (count >= 2)
+			return;
+	} END_FOR_EACH_PTR_REVERSE(sym);
+}
+
+static void match_end_file(struct symbol_list *sym_list)
+{
+	struct symbol *sym;
+
+	/* find the last static symbol in the file */
+	FOR_EACH_PTR_REVERSE(sym_list, sym) {
+		if (!(sym->ctype.modifiers & MOD_STATIC))
+			continue;
+		if (!sym->scope)
+			continue;
+		find_module_init_exit(sym->scope->symbols);
+		return;
+	} END_FOR_EACH_PTR_REVERSE(sym);
+}
+
+static struct expression *get_val_expr(struct expression *expr)
+{
+	struct symbol *sym, *val;
+
+	if (expr->type != EXPR_DEREF)
+		return NULL;
+	expr = expr->deref;
+	if (expr->type != EXPR_SYMBOL)
+		return NULL;
+	if (strcmp(expr->symbol_name->name, "__u") != 0)
+		return NULL;
+	sym = get_base_type(expr->symbol);
+	val = first_ptr_list((struct ptr_list *)sym->symbol_list);
+	if (!val || strcmp(val->ident->name, "__val") != 0)
+		return NULL;
+	return member_expression(expr, '.', val->ident);
+}
+
+static void match__write_once_size(const char *fn, struct expression *call,
+			       void *unused)
+{
+	struct expression *dest, *data, *assign;
+	struct range_list *rl;
+
+	dest = get_argument_from_call_expr(call->args, 0);
+	if (dest->type != EXPR_PREOP || dest->op != '&')
+		return;
+	dest = strip_expr(dest->unop);
+
+	data = get_argument_from_call_expr(call->args, 1);
+	data = get_val_expr(data);
+	if (!data)
+		return;
+	get_absolute_rl(data, &rl);
+	assign = assign_expression(dest, '=', data);
+
+	__in_fake_assign++;
+	__split_expr(assign);
+	__in_fake_assign--;
+}
+
+static void match__read_once_size(const char *fn, struct expression *call,
+			       void *unused)
+{
+	struct expression *dest, *data, *assign;
+	struct symbol *type, *val_sym;
+
+	/*
+	 * We want to change:
+	 *	__read_once_size_nocheck(&(x), __u.__c, sizeof(x));
+	 * into a fake assignment:
+	 *	__u.val = x;
+	 *
+	 */
+
+	data = get_argument_from_call_expr(call->args, 0);
+	if (data->type != EXPR_PREOP || data->op != '&')
+		return;
+	data = strip_parens(data->unop);
+
+	dest = get_argument_from_call_expr(call->args, 1);
+	if (dest->type != EXPR_DEREF || dest->op != '.')
+		return;
+	if (!dest->member || strcmp(dest->member->name, "__c") != 0)
+		return;
+	dest = dest->deref;
+	type = get_type(dest);
+	if (!type)
+		return;
+	val_sym = first_ptr_list((struct ptr_list *)type->symbol_list);
+	dest = member_expression(dest, '.', val_sym->ident);
+
+	assign = assign_expression(dest, '=', data);
+	__in_fake_assign++;
+	__split_expr(assign);
+	__in_fake_assign--;
+}
+
+void check_kernel(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_implied_return_hook("ERR_PTR", &implied_err_cast_return, NULL);
+	add_implied_return_hook("ERR_CAST", &implied_err_cast_return, NULL);
+	add_implied_return_hook("PTR_ERR", &implied_err_cast_return, NULL);
+	add_hook(hack_ERR_PTR, AFTER_DEF_HOOK);
+	return_implies_state("IS_ERR_OR_NULL", 0, 0, &match_param_valid_ptr, (void *)0);
+	return_implies_state("IS_ERR_OR_NULL", 1, 1, &match_param_err_or_null, (void *)0);
+	return_implies_state("IS_ERR", 0, 0, &match_not_err, NULL);
+	return_implies_state("IS_ERR", 1, 1, &match_err, NULL);
+	return_implies_state("tomoyo_memory_ok", 1, 1, &match_param_valid_ptr, (void *)0);
+
+	add_macro_assign_hook_extra("container_of", &match_container_of_macro, NULL);
+	add_hook(match_container_of, ASSIGNMENT_HOOK);
+
+	add_implied_return_hook("find_next_bit", &match_next_bit, NULL);
+	add_implied_return_hook("find_next_zero_bit", &match_next_bit, NULL);
+	add_implied_return_hook("find_first_bit", &match_next_bit, NULL);
+	add_implied_return_hook("find_first_zero_bit", &match_next_bit, NULL);
+
+	add_implied_return_hook("fls", &match_fls, NULL);
+	add_implied_return_hook("fls64", &match_fls, NULL);
+
+	add_function_hook("__ftrace_bad_type", &__match_nullify_path_hook, NULL);
+	add_function_hook("__write_once_size", &match__write_once_size, NULL);
+
+	add_function_hook("__read_once_size", &match__read_once_size, NULL);
+	add_function_hook("__read_once_size_nocheck", &match__read_once_size, NULL);
+
+	if (option_info)
+		add_hook(match_end_file, END_FILE_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_kernel_printf.c b/usr/src/tools/smatch/src/check_kernel_printf.c
new file mode 100644
index 0000000000..c85dac1e20
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_kernel_printf.c
@@ -0,0 +1,1467 @@
+/*
+ * Copyright (C) 2015 Rasmus Villemoes.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <assert.h>
+#include <ctype.h>
+#include <string.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+
+#define spam(args...) do {			\
+	if (option_spammy)			\
+		sm_msg(args);			\
+	} while (0)
+
+static int my_id;
+
+/*
+ * Much of this is taken directly from the kernel (mostly vsprintf.c),
+ * with a few modifications here and there.
+ */
+
+#define KERN_SOH_ASCII  '\001'
+
+typedef unsigned char u8;
+typedef signed short s16;
+
+#define SIGN	1		/* unsigned/signed, must be 1 */
+#define LEFT	2		/* left justified */
+#define PLUS	4		/* show plus */
+#define SPACE	8		/* space if plus */
+#define ZEROPAD	16		/* pad with zero, must be 16 == '0' - ' ' */
+#define SMALL	32		/* use lowercase in hex (must be 32 == 0x20) */
+#define SPECIAL	64		/* prefix hex with "0x", octal with "0" */
+
+enum format_type {
+	FORMAT_TYPE_NONE, /* Just a string part */
+	FORMAT_TYPE_WIDTH,
+	FORMAT_TYPE_PRECISION,
+	FORMAT_TYPE_CHAR,
+	FORMAT_TYPE_STR,
+	FORMAT_TYPE_PTR,
+	FORMAT_TYPE_PERCENT_CHAR,
+	FORMAT_TYPE_INVALID,
+	FORMAT_TYPE_LONG_LONG,
+	FORMAT_TYPE_ULONG,
+	FORMAT_TYPE_LONG,
+	FORMAT_TYPE_UBYTE,
+	FORMAT_TYPE_BYTE,
+	FORMAT_TYPE_USHORT,
+	FORMAT_TYPE_SHORT,
+	FORMAT_TYPE_UINT,
+	FORMAT_TYPE_INT,
+	FORMAT_TYPE_SIZE_T,
+	FORMAT_TYPE_PTRDIFF,
+	FORMAT_TYPE_NRCHARS, /* Reintroduced for this checker */
+	FORMAT_TYPE_FLOAT, /* for various floating point formatters */
+};
+
+struct printf_spec {
+	unsigned int	type:8;		/* format_type enum */
+	signed int	field_width:24;	/* width of output field */
+	unsigned int	flags:8;	/* flags to number() */
+	unsigned int	base:8;		/* number base, 8, 10 or 16 only */
+	signed int	precision:16;	/* # of digits/chars */
+} __packed;
+#define FIELD_WIDTH_MAX ((1 << 23) - 1)
+#define PRECISION_MAX ((1 << 15) - 1)
+extern char __check_printf_spec[1-2*(sizeof(struct printf_spec) != 8)];
+
+static int
+skip_atoi(const char **s)
+{
+	int i = 0;
+
+	while (isdigit(**s))
+		i = i*10 + *((*s)++) - '0';
+
+	return i;
+}
+
+static int
+format_decode(const char *fmt, struct printf_spec *spec)
+{
+	const char *start = fmt;
+	char qualifier;
+
+	/* we finished early by reading the field width */
+	if (spec->type == FORMAT_TYPE_WIDTH) {
+		if (spec->field_width < 0) {
+			spec->field_width = -spec->field_width;
+			spec->flags |= LEFT;
+		}
+		spec->type = FORMAT_TYPE_NONE;
+		goto precision;
+	}
+
+	/* we finished early by reading the precision */
+	if (spec->type == FORMAT_TYPE_PRECISION) {
+		if (spec->precision < 0)
+			spec->precision = 0;
+
+		spec->type = FORMAT_TYPE_NONE;
+		goto qualifier;
+	}
+
+	/* By default */
+	spec->type = FORMAT_TYPE_NONE;
+
+	for (; *fmt ; ++fmt) {
+		if (*fmt == '%')
+			break;
+	}
+
+	/* Return the current non-format string */
+	if (fmt != start || !*fmt)
+		return fmt - start;
+
+	/* Process flags */
+	spec->flags = 0;
+
+	while (1) { /* this also skips first '%' */
+		bool found = true;
+
+		++fmt;
+
+		switch (*fmt) {
+		case '-': spec->flags |= LEFT;    break;
+		case '+': spec->flags |= PLUS;    break;
+		case ' ': spec->flags |= SPACE;   break;
+		case '#': spec->flags |= SPECIAL; break;
+		case '0': spec->flags |= ZEROPAD; break;
+		default:  found = false;
+		}
+
+		if (!found)
+			break;
+	}
+
+	/* get field width */
+	spec->field_width = -1;
+
+	if (isdigit(*fmt))
+		spec->field_width = skip_atoi(&fmt);
+	else if (*fmt == '*') {
+		/* it's the next argument */
+		spec->type = FORMAT_TYPE_WIDTH;
+		return ++fmt - start;
+	}
+
+precision:
+	/* get the precision */
+	spec->precision = -1;
+	if (*fmt == '.') {
+		++fmt;
+		if (isdigit(*fmt)) {
+			spec->precision = skip_atoi(&fmt);
+			if (spec->precision < 0)
+				spec->precision = 0;
+		} else if (*fmt == '*') {
+			/* it's the next argument */
+			spec->type = FORMAT_TYPE_PRECISION;
+			return ++fmt - start;
+		}
+	}
+
+qualifier:
+	/* get the conversion qualifier */
+	qualifier = 0;
+	if (*fmt == 'h' || _tolower(*fmt) == 'l' ||
+	    _tolower(*fmt) == 'z' || *fmt == 't') {
+		qualifier = *fmt++;
+		if (qualifier == *fmt) {
+			if (qualifier == 'l') {
+				qualifier = 'L';
+				++fmt;
+			} else if (qualifier == 'h') {
+				qualifier = 'H';
+				++fmt;
+			} else {
+				sm_warning("invalid repeated qualifier '%c'", *fmt);
+			}
+		}
+	}
+
+	/* default base */
+	spec->base = 10;
+	switch (*fmt) {
+	case 'c':
+		if (qualifier)
+			sm_warning("qualifier '%c' ignored for %%c specifier", qualifier);
+
+		spec->type = FORMAT_TYPE_CHAR;
+		return ++fmt - start;
+
+	case 's':
+		if (qualifier)
+			sm_warning("qualifier '%c' ignored for %%s specifier", qualifier);
+
+		spec->type = FORMAT_TYPE_STR;
+		return ++fmt - start;
+
+	case 'p':
+		spec->type = FORMAT_TYPE_PTR;
+		return ++fmt - start;
+
+	case '%':
+		spec->type = FORMAT_TYPE_PERCENT_CHAR;
+		return ++fmt - start;
+
+	/* integer number formats - set up the flags and "break" */
+	case 'o':
+		spec->base = 8;
+		break;
+
+	case 'x':
+		spec->flags |= SMALL;
+
+	case 'X':
+		spec->base = 16;
+		break;
+
+	case 'd':
+	case 'i':
+		spec->flags |= SIGN;
+	case 'u':
+		break;
+
+	case 'n':
+		spec->type = FORMAT_TYPE_NRCHARS;
+		return ++fmt - start;
+
+	case 'a': case 'A':
+	case 'e': case 'E':
+	case 'f': case 'F':
+	case 'g': case 'G':
+		spec->type = FORMAT_TYPE_FLOAT;
+		return ++fmt - start;
+
+	default:
+		spec->type = FORMAT_TYPE_INVALID;
+		/* Unlike the kernel code, we 'consume' the invalid
+		 * character so that it can get included in the
+		 * report. After that, we bail out. */
+		return ++fmt - start;
+	}
+
+	if (qualifier == 'L')
+		spec->type = FORMAT_TYPE_LONG_LONG;
+	else if (qualifier == 'l') {
+		if (spec->flags & SIGN)
+			spec->type = FORMAT_TYPE_LONG;
+		else
+			spec->type = FORMAT_TYPE_ULONG;
+	} else if (_tolower(qualifier) == 'z') {
+		spec->type = FORMAT_TYPE_SIZE_T;
+	} else if (qualifier == 't') {
+		spec->type = FORMAT_TYPE_PTRDIFF;
+	} else if (qualifier == 'H') {
+		if (spec->flags & SIGN)
+			spec->type = FORMAT_TYPE_BYTE;
+		else
+			spec->type = FORMAT_TYPE_UBYTE;
+	} else if (qualifier == 'h') {
+		if (spec->flags & SIGN)
+			spec->type = FORMAT_TYPE_SHORT;
+		else
+			spec->type = FORMAT_TYPE_USHORT;
+	} else {
+		if (spec->flags & SIGN)
+			spec->type = FORMAT_TYPE_INT;
+		else
+			spec->type = FORMAT_TYPE_UINT;
+	}
+
+	return ++fmt - start;
+}
+
+static int is_struct_tag(struct symbol *type, const char *tag)
+{
+	return type->type == SYM_STRUCT && type->ident && !strcmp(type->ident->name, tag);
+}
+
+static int has_struct_tag(struct symbol *type, const char *tag)
+{
+	struct symbol *tmp;
+
+	if (type->type == SYM_STRUCT)
+		return is_struct_tag(type, tag);
+	if (type->type == SYM_UNION) {
+		FOR_EACH_PTR(type->symbol_list, tmp) {
+			tmp = get_real_base_type(tmp);
+			if (tmp && is_struct_tag(tmp, tag))
+				return 1;
+		} END_FOR_EACH_PTR(tmp);
+	}
+	return 0;
+}
+
+static int is_char_type(struct symbol *type)
+{
+	return type == &uchar_ctype || type == &char_ctype || type == &schar_ctype;
+}
+
+/*
+ * I have absolutely no idea if this is how one is supposed to get the
+ * symbol representing a typedef, but it seems to work.
+ */
+struct typedef_lookup {
+	const char *name;
+	struct symbol *sym;
+	int failed;
+};
+
+static struct symbol *_typedef_lookup(const char *name)
+{
+	struct ident *id;
+	struct symbol *node;
+
+	id = built_in_ident(name);
+	if (!id)
+		return NULL;
+	node = lookup_symbol(id, NS_TYPEDEF);
+	if (!node || node->type != SYM_NODE)
+		return NULL;
+	return get_real_base_type(node);
+}
+
+static void typedef_lookup(struct typedef_lookup *tl)
+{
+	if (tl->sym || tl->failed)
+		return;
+	tl->sym = _typedef_lookup(tl->name);
+	if (!tl->sym) {
+		sm_perror(" could not find typedef '%s'", tl->name);
+		tl->failed = 1;
+	}
+}
+
+
+static void ip4(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	enum { ENDIAN_BIG, ENDIAN_LITTLE, ENDIAN_HOST } endian = ENDIAN_BIG;
+
+	assert(fmt[0] == 'i' || fmt[0] == 'I');
+	assert(fmt[1] == '4');
+
+	if (isalnum(fmt[2])) {
+		switch (fmt[2]) {
+		case 'h':
+			endian = ENDIAN_HOST;
+			break;
+		case 'l':
+			endian = ENDIAN_LITTLE;
+			break;
+		case 'n':
+		case 'b':
+			endian = ENDIAN_BIG;
+			break;
+		default:
+			sm_warning("'%%p%c4' can only be followed by one of [hnbl], not '%c'", fmt[0], fmt[2]);
+		}
+		if (isalnum(fmt[3]))
+			sm_warning("'%%p%c4' can only be followed by precisely one of [hnbl]", fmt[0]);
+	}
+
+
+	if (type->ctype.modifiers & MOD_NODEREF)
+		sm_error("passing __user pointer to '%%p%c4'", fmt[0]);
+
+	/*
+	 * If we have a pointer to char/u8/s8, we expect the caller to
+	 * handle endianness; I don't think there's anything we can
+	 * do. I'd like to check that if we're passed a pointer to a
+	 * __bitwise u32 (most likely a __be32), we should have endian
+	 * == ENDIAN_BIG. But I can't figure out how to get that
+	 * information (it also seems to require ensuring certain
+	 * macros are defined). But struct in_addr certainly consists
+	 * of only a single __be32, so in that case we can do a check.
+	 */
+	if (is_char_type(basetype))
+		return;
+
+	if (is_struct_tag(basetype, "in_addr") && endian != ENDIAN_BIG)
+		sm_warning("passing struct in_addr* to '%%p%c4%c', is the endianness ok?", fmt[0], fmt[2]);
+
+	/* ... */
+}
+
+static void ip6(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	assert(fmt[0] == 'i' || fmt[0] == 'I');
+	assert(fmt[1] == '6');
+
+	if (isalnum(fmt[2])) {
+		if (fmt[2] != 'c')
+			sm_warning("'%%p%c6' can only be followed by c", fmt[0]);
+		else if (fmt[0] == 'i')
+			sm_warning("'%%pi6' does not allow flag c");
+		if (isalnum(fmt[3]))
+			sm_warning("'%%p%c6%c' cannot be followed by other alphanumerics", fmt[0], fmt[2]);
+	}
+
+	if (type->ctype.modifiers & MOD_NODEREF)
+		sm_error("passing __user pointer to '%%p%c6'", fmt[0]);
+}
+
+static void ipS(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	const char *f;
+
+	assert(tolower(fmt[0]) == 'i');
+	assert(fmt[1] == 'S');
+
+	for (f = fmt+2; isalnum(*f); ++f) {
+		/* It's probably too anal checking for duplicate flags. */
+		if (!strchr("pfschnbl", *f))
+			sm_warning("'%%p%cS' cannot be followed by '%c'", fmt[0], *f);
+	}
+
+	/*
+	 * XXX: Should we also allow passing a pointer to a union, one
+	 * member of which is a struct sockaddr? It may be slightly
+	 * cleaner actually passing &u.raw instead of just &u, though
+	 * the generated code is of course exactly the same. For now,
+	 * we do accept struct sockaddr_in and struct sockaddr_in6,
+	 * since those are easy to handle and rather harmless.
+	 */
+	if (!has_struct_tag(basetype, "sockaddr") &&
+	    !has_struct_tag(basetype, "sockaddr_in") &&
+	    !has_struct_tag(basetype, "sockaddr_in6") &&
+	    !has_struct_tag(basetype, "__kernel_sockaddr_storage"))
+		sm_error("'%%p%cS' expects argument of type struct sockaddr *, "
+			"argument %d has type '%s'", fmt[0], vaidx, type_to_str(type));
+}
+
+static void hex_string(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	assert(fmt[0] == 'h');
+	if (isalnum(fmt[1])) {
+		if (!strchr("CDN", fmt[1]))
+			sm_warning("'%%ph' cannot be followed by '%c'", fmt[1]);
+		if (isalnum(fmt[2]))
+			sm_warning("'%%ph' can be followed by at most one of [CDN], and no other alphanumerics");
+	}
+	if (type->ctype.modifiers & MOD_NODEREF)
+		sm_error("passing __user pointer to %%ph");
+}
+
+static void escaped_string(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	assert(fmt[0] == 'E');
+	while (isalnum(*++fmt)) {
+		if (!strchr("achnops", *fmt))
+			sm_warning("%%pE can only be followed by a combination of [achnops]");
+	}
+	if (type->ctype.modifiers & MOD_NODEREF)
+		sm_error("passing __user pointer to %%pE");
+}
+
+static void resource_string(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	assert(tolower(fmt[0]) == 'r');
+	if (!is_struct_tag(basetype, "resource")) {
+		sm_error("'%%p%c' expects argument of type struct resource *, "
+			"but argument %d has type '%s'", fmt[0], vaidx, type_to_str(type));
+	}
+	if (isalnum(fmt[1]))
+		sm_warning("'%%p%c' cannot be followed by '%c'", fmt[0], fmt[1]);
+}
+
+static void mac_address_string(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	assert(tolower(fmt[0]) == 'm');
+	if (isalnum(fmt[1])) {
+		if (!(fmt[1] == 'F' || fmt[1] == 'R'))
+			sm_warning("'%%p%c' cannot be followed by '%c'", fmt[0], fmt[1]);
+		if (fmt[0] == 'm' && fmt[1] == 'F')
+			sm_warning("it is pointless to pass flag F to %%pm");
+		if (isalnum(fmt[2]))
+			sm_warning("'%%p%c%c' cannot be followed by other alphanumeric", fmt[0], fmt[1]);
+	}
+	/* Technically, bdaddr_t is a typedef for an anonymous struct, but this still seems to work. */
+	if (!is_char_type(basetype) && !is_struct_tag(basetype, "bdaddr_t") && basetype != &void_ctype) {
+		sm_warning("'%%p%c' expects argument of type u8 * or bdaddr_t *, argument %d has type '%s'",
+			fmt[0], vaidx, type_to_str(type));
+	}
+	if (type->ctype.modifiers & MOD_NODEREF)
+		sm_error("passing __user pointer to '%%p%c'", fmt[0]);
+}
+
+static void dentry_file(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	const char *tag;
+
+	assert(tolower(fmt[0]) == 'd');
+	tag = fmt[0] == 'd' ? "dentry" : "file";
+
+	if (isalnum(fmt[1])) {
+		if (!strchr("234", fmt[1]))
+			sm_warning("'%%p%c' can only be followed by one of [234]", fmt[0]);
+		if (isalnum(fmt[2]))
+			sm_warning("'%%p%c%c' cannot be followed by '%c'", fmt[0], fmt[1], fmt[2]);
+	}
+
+	if (!is_struct_tag(basetype, tag))
+		sm_error("'%%p%c' expects argument of type struct '%s*', argument %d has type '%s'",
+			fmt[0], tag, vaidx, type_to_str(type));
+}
+
+static void check_clock(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	assert(fmt[0] == 'C');
+	if (isalnum(fmt[1])) {
+		if (!strchr("nr", fmt[1]))
+			sm_warning("'%%pC' can only be followed by one of [nr]");
+		if (isalnum(fmt[2]))
+			sm_warning("'%%pC%c' cannot be followed by '%c'", fmt[1], fmt[2]);
+	}
+	if (!is_struct_tag(basetype, "clk"))
+		sm_error("'%%pC' expects argument of type 'struct clk*', argument %d has type '%s'",
+		       vaidx, type_to_str(type));
+}
+
+static void va_format(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	assert(fmt[0] == 'V');
+	if (isalnum(fmt[1]))
+		sm_warning("%%pV cannot be followed by any alphanumerics");
+	if (!is_struct_tag(basetype, "va_format"))
+		sm_error("%%pV expects argument of type struct va_format*, argument %d has type '%s'", vaidx, type_to_str(type));
+}
+
+static void netdev_feature(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	static struct typedef_lookup netdev = { .name = "netdev_features_t" };
+
+	assert(fmt[0] == 'N');
+	if (fmt[1] != 'F') {
+		sm_error("%%pN must be followed by 'F'");
+		return;
+	}
+	if (isalnum(fmt[2]))
+		sm_warning("%%pNF cannot be followed by '%c'", fmt[2]);
+
+	typedef_lookup(&netdev);
+	if (!netdev.sym)
+		return;
+	if (basetype != netdev.sym)
+		sm_error("%%pNF expects argument of type netdev_features_t*, argument %d has type '%s'",
+			vaidx, type_to_str(type));
+
+}
+static void address_val(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	static struct typedef_lookup dma = { .name = "dma_addr_t" };
+	static struct typedef_lookup phys = { .name = "phys_addr_t" };
+	struct typedef_lookup *which = &phys;
+	const char *suf = "";
+	assert(fmt[0] == 'a');
+
+	if (isalnum(fmt[1])) {
+		switch (fmt[1]) {
+		case 'd':
+			which = &dma;
+			suf = "d";
+			break;
+		case 'p':
+			suf = "p";
+			break;
+		default:
+			sm_error("'%%pa' can only be followed by one of [dp]");
+		}
+		if (isalnum(fmt[2]))
+			sm_error("'%%pa%c' cannot be followed by '%c'", fmt[1], fmt[2]);
+	}
+
+	typedef_lookup(which);
+	if (!which->sym)
+		return;
+	if (basetype != which->sym) {
+		sm_error("'%%pa%s' expects argument of type '%s*', argument %d has type '%s'",
+			suf, which->name, vaidx, type_to_str(type));
+	}
+}
+
+static void block_device(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	const char *tag = "block_device";
+
+	assert(fmt[0] == 'g');
+	if (isalnum(fmt[1])) {
+		sm_warning("%%pg cannot be followed by '%c'", fmt[1]);
+	}
+	if (!is_struct_tag(basetype, tag))
+		sm_error("'%%p%c' expects argument of type struct '%s*', argument %d has type '%s'",
+			fmt[0], tag, vaidx, type_to_str(type));
+}
+
+static void flag_string(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	static struct typedef_lookup gfp = { .name = "gfp_t" };
+
+	assert(fmt[0] == 'G');
+	if (!isalnum(fmt[1])) {
+		sm_error("%%pG must be followed by one of [gpv]");
+		return;
+	}
+	switch (fmt[1]) {
+	case 'p':
+	case 'v':
+		if (basetype != &ulong_ctype)
+			sm_error("'%%pG%c' expects argument of type 'unsigned long *', argument %d has type '%s'",
+				fmt[1], vaidx, type_to_str(type));
+		break;
+	case 'g':
+		typedef_lookup(&gfp);
+		if (basetype != gfp.sym)
+			sm_error("'%%pGg' expects argument of type 'gfp_t *', argument %d has type '%s'",
+				vaidx, type_to_str(type));
+		break;
+	default:
+		sm_error("'%%pG' must be followed by one of [gpv]");
+	}
+}
+
+static void device_node_string(const char *fmt, struct symbol *type, struct symbol *basetype, int vaidx)
+{
+	if (fmt[1] != 'F') {
+		sm_error("%%pO can only be followed by 'F'");
+		return;
+	}
+	if (!is_struct_tag(basetype, "device_node"))
+		sm_error("'%%pOF' expects argument of type 'struct device_node*', argument %d has type '%s'",
+		       vaidx, type_to_str(type));
+}
+
+static void
+pointer(const char *fmt, struct expression *arg, int vaidx)
+{
+	struct symbol *type, *basetype;
+
+	type = get_type(arg);
+	if (!type) {
+		sm_warning("could not determine type of argument %d", vaidx);
+		return;
+	}
+	if (!is_ptr_type(type)) {
+		sm_error("%%p expects pointer argument, but argument %d has type '%s'",
+			vaidx, type_to_str(type));
+		return;
+	}
+	/* Just plain %p, nothing to check. */
+	if (!isalnum(*fmt))
+		return;
+
+	basetype = get_real_base_type(type);
+	if (is_void_type(basetype))
+		return;
+	/*
+	 * Passing a pointer-to-array is harmless, but most likely one
+	 * meant to pass pointer-to-first-element. If basetype is
+	 * array type, we issue a notice and "dereference" the types
+	 * once more.
+	 */
+	if (basetype->type == SYM_ARRAY) {
+		spam("note: passing pointer-to-array; is the address-of redundant?");
+		type = basetype;
+		basetype = get_real_base_type(type);
+	}
+
+	/*
+	 * We pass both the type and the basetype to the helpers. If,
+	 * for example, the pointer is really a decayed array which is
+	 * passed to %pI4, we might want to check that it is in fact
+	 * an array of four bytes. But most are probably only
+	 * interested in whether the basetype makes sense. Also, the
+	 * pointer may carry some annotation such as __user which
+	 * might be worth checking in the handlers which actually
+	 * dereference the pointer.
+	 */
+
+	switch (*fmt) {
+	case 'b':
+	case 'F':
+	case 'f':
+	case 'S':
+	case 's':
+	case 'B':
+		/* Can we do anything sensible? Check that the arg is a function pointer, for example? */
+		break;
+
+	case 'R':
+	case 'r':
+		resource_string(fmt, type, basetype, vaidx);
+		break;
+	case 'M':
+	case 'm':
+		mac_address_string(fmt, type, basetype, vaidx);
+		break;
+	case 'I':
+	case 'i':
+		switch (fmt[1]) {
+		case '4':
+			ip4(fmt, type, basetype, vaidx);
+			break;
+		case '6':
+			ip6(fmt, type, basetype, vaidx);
+			break;
+		case 'S':
+			ipS(fmt, type, basetype, vaidx);
+			break;
+		default:
+			sm_warning("'%%p%c' must be followed by one of [46S]", fmt[0]);
+			break;
+		}
+		break;
+       /*
+	* %pE and %ph can handle any valid pointer. We still check
+	* whether all the subsequent alphanumerics are valid for the
+	* particular %pX conversion.
+	*/
+	case 'E':
+		escaped_string(fmt, type, basetype, vaidx);
+		break;
+	case 'h':
+		hex_string(fmt, type, basetype, vaidx);
+		break;
+	case 'U': /* TODO */
+		break;
+	case 'V':
+		va_format(fmt, type, basetype, vaidx);
+		break;
+	case 'K': /* TODO */
+		break;
+	case 'N':
+		netdev_feature(fmt, type, basetype, vaidx);
+		break;
+	case 'a':
+		address_val(fmt, type, basetype, vaidx);
+		break;
+	case 'D':
+	case 'd':
+		dentry_file(fmt, type, basetype, vaidx);
+		break;
+	case 'C':
+		check_clock(fmt, type, basetype, vaidx);
+		break;
+	case 'g':
+		block_device(fmt, type, basetype, vaidx);
+		break;
+	case 'G':
+		flag_string(fmt, type, basetype, vaidx);
+		break;
+	case 'O':
+		device_node_string(fmt, type, basetype, vaidx);
+		break;
+	case 'x':
+		/* 'x' is for an unhashed pointer */
+		break;
+	default:
+		sm_error("unrecognized %%p extension '%c', treated as normal %%p", *fmt);
+	}
+}
+
+/*
+ * A common error is to pass a "char" or "signed char" to %02x (or
+ * %.2X or some other variant). This can actually be a security
+ * problem, because a lot of code expects this to produce exactly two
+ * characters of output. Unfortunately this also produces false
+ * positives, since we're sometimes in arch-specific code on an arch
+ * where char is always unsigned.
+ */
+static void
+hexbyte(const char *fmt, int fmt_len, struct expression *arg, int vaidx, struct printf_spec spec)
+{
+	struct symbol *type;
+
+	/*
+	 * For now, just check the most common and obvious, which is
+	 * roughly %[.0]2[xX].
+	 */
+	if (spec.field_width != 2 && spec.precision != 2)
+		return;
+	if (spec.base != 16)
+		return;
+
+	type = get_type(arg);
+	if (!type) {
+		sm_warning("could not determine type of argument %d", vaidx);
+		return;
+	}
+	if (type == &char_ctype || type == &schar_ctype)
+		sm_warning("argument %d to %.*s specifier has type '%s'",
+		       vaidx, fmt_len, fmt, type_to_str(type));
+}
+
+static int
+check_format_string(const char *fmt, const char *caller)
+{
+	const char *f;
+
+	for (f = fmt; *f; ++f) {
+		unsigned char c = *f;
+		switch (c) {
+		case KERN_SOH_ASCII:
+			/*
+			 * This typically arises from bad conversion
+			 * to pr_*, e.g. pr_warn(KERN_WARNING "something").
+			 */
+			if (f != fmt)
+				sm_warning("KERN_* level not at start of string");
+			/*
+			 * In a very few cases, the level is actually
+			 * computed and passed via %c, as in KERN_SOH
+			 * "%c...". printk explicitly supports
+			 * this.
+			 */
+			if (!(('0' <= f[1] && f[1] <= '7') ||
+			      f[1] == 'd' || /* KERN_DEFAULT */
+			      f[1] == 'c' || /* KERN_CONT */
+			      (f[1] == '%' && f[2] == 'c')))
+				sm_warning("invalid KERN_* level: KERN_SOH_ASCII followed by '\\x%02x'", (unsigned char)f[1]);
+			break;
+		case '\t':
+		case '\n':
+		case '\r':
+		case 0x20 ... 0x7e:
+			break;
+		case 0x80 ... 0xff:
+			sm_warning("format string contains non-ascii character '\\x%02x'", c);
+			break;
+		case 0x08:
+			if (f == fmt)
+				break;
+			/* fall through */
+		default:
+			sm_warning("format string contains unusual character '\\x%02x'", c);
+			break;
+		}
+	}
+
+	f = strstr(fmt, caller);
+	if (f && strstr(f+1, caller))
+		sm_warning("format string contains name of enclosing function '%s' twice", caller);
+
+	return f != NULL;
+}
+
+static int arg_is___func__(struct expression *arg)
+{
+	if (arg->type != EXPR_SYMBOL)
+		return 0;
+	return !strcmp(arg->symbol_name->name, "__func__") ||
+	       !strcmp(arg->symbol_name->name, "__FUNCTION__") ||
+	       !strcmp(arg->symbol_name->name, "__PRETTY_FUNCTION__");
+}
+static int arg_contains_caller(struct expression *arg, const char *caller)
+{
+	if (arg->type != EXPR_STRING)
+		return 0;
+	return strstr(arg->string->data, caller) != NULL;
+}
+
+static int is_array_of_const_char(struct symbol *sym)
+{
+	struct symbol *base = sym->ctype.base_type;
+	if (base->type != SYM_ARRAY)
+		return 0;
+	if (!(base->ctype.modifiers & MOD_CONST))
+		return 0;
+	if (!is_char_type(base->ctype.base_type)) {
+		spam("weird: format argument is array of const '%s'", type_to_str(base->ctype.base_type));
+		return 0;
+	}
+	return 1;
+}
+
+static int is_const_pointer_to_const_char(struct symbol *sym)
+{
+	struct symbol *base = sym->ctype.base_type;
+	if (!(sym->ctype.modifiers & MOD_CONST))
+		return 0;
+	if (base->type != SYM_PTR)
+		return 0;
+	if (!(base->ctype.modifiers & MOD_CONST))
+		return 0;
+	if (!is_char_type(base->ctype.base_type)) {
+		spam("weird: format argument is pointer to const '%s'", type_to_str(base->ctype.base_type));
+		return 0;
+	}
+	return 1;
+}
+
+static int unknown_format(struct expression *expr)
+{
+	struct state_list *slist;
+
+	slist = get_strings(expr);
+	if (!slist)
+		return 1;
+	if (slist_has_state(slist, &undefined))
+		return 1;
+	free_slist(&slist);
+	return 0;
+}
+
+static bool has_hex_prefix(const char *orig_fmt, const char *old_fmt)
+{
+	return old_fmt >= orig_fmt + 2 &&
+		old_fmt[-2] == '0' && _tolower(old_fmt[-1]) == 'x';
+}
+
+static bool is_integer_specifier(int type)
+{
+	switch (type) {
+	case FORMAT_TYPE_LONG_LONG:
+	case FORMAT_TYPE_ULONG:
+	case FORMAT_TYPE_LONG:
+	case FORMAT_TYPE_UBYTE:
+	case FORMAT_TYPE_BYTE:
+	case FORMAT_TYPE_USHORT:
+	case FORMAT_TYPE_SHORT:
+	case FORMAT_TYPE_UINT:
+	case FORMAT_TYPE_INT:
+	case FORMAT_TYPE_SIZE_T:
+	case FORMAT_TYPE_PTRDIFF:
+		return true;
+	default:
+		return false;
+	}
+}
+
+static int
+is_cast_expr(struct expression *expr)
+{
+	if (!expr)
+		return 0;
+
+	switch (expr->type) {
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+		/* not EXPR_IMPLIED_CAST for our purposes */
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+static void
+check_cast_from_pointer(const char *fmt, int len, struct expression *arg, int va_idx)
+{
+	/*
+	 * This can easily be fooled by passing 0+(long)ptr or doing
+	 * "long local_var = (long)ptr" and passing local_var to
+	 * %lx. Tough.
+	 */
+	if (!is_cast_expr(arg))
+		return;
+	while (is_cast_expr(arg))
+		arg = arg->cast_expression;
+	if (is_ptr_type(get_final_type(arg)))
+		sm_warning("argument %d to %.*s specifier is cast from pointer",
+			va_idx, len, fmt);
+}
+
+static void
+do_check_printf_call(const char *caller, const char *name, struct expression *callexpr, struct expression *fmtexpr, int vaidx)
+{
+	struct printf_spec spec = {0};
+	const char *fmt, *orig_fmt;
+	int caller_in_fmt;
+
+	fmtexpr = strip_parens(fmtexpr);
+	if (fmtexpr->type == EXPR_CONDITIONAL) {
+		do_check_printf_call(caller, name, callexpr, fmtexpr->cond_true ? : fmtexpr->conditional, vaidx);
+		do_check_printf_call(caller, name, callexpr, fmtexpr->cond_false, vaidx);
+		return;
+	}
+	if (fmtexpr->type == EXPR_SYMBOL) {
+		/*
+		 * If the symbol has an initializer, we can handle
+		 *
+		 *   const char foo[] = "abc";         and
+		 *   const char * const foo = "abc";
+		 *
+		 * We simply replace fmtexpr with the initializer
+		 * expression. If foo is not one of the above, or if
+		 * the initializer expression is somehow not a string
+		 * literal, fmtexpr->type != EXPR_STRING will trigger
+		 * below and we'll spam+return.
+		 */
+		struct symbol *sym = fmtexpr->symbol;
+		if (sym && sym->initializer &&
+		    (is_array_of_const_char(sym) ||
+		     is_const_pointer_to_const_char(sym))) {
+			fmtexpr = strip_parens(sym->initializer);
+		}
+	}
+
+	if (fmtexpr->type != EXPR_STRING) {
+		if (!unknown_format(fmtexpr))
+			return;
+		/*
+		 * Since we're now handling both ?: and static const
+		 * char[] arguments, we don't get as much noise. It's
+		 * still spammy, though.
+		 */
+		spam("warn: call of '%s' with non-constant format argument", name);
+		return;
+	}
+
+	orig_fmt = fmt = fmtexpr->string->data;
+	caller_in_fmt = check_format_string(fmt, caller);
+
+	while (*fmt) {
+		const char *old_fmt = fmt;
+		int read = format_decode(fmt, &spec);
+		struct expression *arg;
+
+		fmt += read;
+		if (spec.type == FORMAT_TYPE_NONE ||
+		    spec.type == FORMAT_TYPE_PERCENT_CHAR)
+			continue;
+
+		/*
+		 * vaidx is currently the correct 0-based index for
+		 * get_argument_from_call_expr. We post-increment it
+		 * here so that it is the correct 1-based index for
+		 * all the handlers below. This of course requires
+		 * that we handle all FORMAT_TYPE_* things not taking
+		 * an argument above.
+		 */
+		arg = get_argument_from_call_expr(callexpr->args, vaidx++);
+
+		if (spec.flags & SPECIAL && has_hex_prefix(orig_fmt, old_fmt))
+			sm_warning("'%.2s' prefix is redundant when # flag is used", old_fmt-2);
+		if (is_integer_specifier(spec.type)) {
+			if (spec.base != 16 && has_hex_prefix(orig_fmt, old_fmt))
+				sm_warning("'%.2s' prefix is confusing together with '%.*s' specifier",
+				       old_fmt-2, (int)(fmt-old_fmt), old_fmt);
+
+			check_cast_from_pointer(old_fmt, read, arg, vaidx);
+		}
+
+		switch (spec.type) {
+		/* case FORMAT_TYPE_NONE: */
+		/* case FORMAT_TYPE_PERCENT_CHAR: */
+		/* 	break; */
+
+		case FORMAT_TYPE_INVALID:
+			sm_error("format specifier '%.*s' invalid", read, old_fmt);
+			return;
+
+		case FORMAT_TYPE_FLOAT:
+			sm_error("no floats in the kernel; invalid format specifier '%.*s'", read, old_fmt);
+			return;
+
+		case FORMAT_TYPE_NRCHARS:
+			sm_error("%%n not supported in kernel");
+			return;
+
+		case FORMAT_TYPE_WIDTH:
+		case FORMAT_TYPE_PRECISION:
+			/* check int argument */
+			break;
+
+		case FORMAT_TYPE_STR:
+			/*
+			 * If the format string already contains the
+			 * function name, it probably doesn't make
+			 * sense to pass __func__ as well (or rather
+			 * vice versa: If pr_fmt(fmt) has been defined
+			 * to '"%s: " fmt, __func__', it doesn't make
+			 * sense to use a format string containing the
+			 * function name).
+			 *
+			 * This produces a lot of hits. They are not
+			 * false positives, but it is easier to handle
+			 * the things which don't occur that often
+			 * first, so we use spam().
+			 */
+			if (caller_in_fmt) {
+				if (arg_is___func__(arg))
+					spam("warn: passing __func__ while the format string already contains the name of the function '%s'",
+					     caller);
+				else if (arg_contains_caller(arg, caller))
+					sm_warning("passing string constant '%s' containing '%s' which is already part of the format string",
+					       arg->string->data, caller);
+			}
+			break;
+
+		case FORMAT_TYPE_PTR:
+			/* This is the most important part: Checking %p extensions. */
+			pointer(fmt, arg, vaidx);
+			while (isalnum(*fmt))
+				fmt++;
+			break;
+
+		case FORMAT_TYPE_CHAR:
+
+		case FORMAT_TYPE_UBYTE:
+		case FORMAT_TYPE_BYTE:
+		case FORMAT_TYPE_USHORT:
+		case FORMAT_TYPE_SHORT:
+		case FORMAT_TYPE_INT:
+			/* argument should have integer type of width <= sizeof(int) */
+			break;
+
+		case FORMAT_TYPE_UINT:
+			hexbyte(old_fmt, fmt-old_fmt, arg, vaidx, spec);
+		case FORMAT_TYPE_LONG:
+		case FORMAT_TYPE_ULONG:
+		case FORMAT_TYPE_LONG_LONG:
+		case FORMAT_TYPE_PTRDIFF:
+		case FORMAT_TYPE_SIZE_T:
+			break;
+		}
+
+
+	}
+
+	if (get_argument_from_call_expr(callexpr->args, vaidx))
+		sm_warning("excess argument passed to '%s'", name);
+
+
+}
+
+static void
+check_printf_call(const char *name, struct expression *callexpr, void *_info)
+{
+	/*
+	 * Note: attribute(printf) uses 1-based indexing, but
+	 * get_argument_from_call_expr() uses 0-based indexing.
+	 */
+	int info = PTR_INT(_info);
+	int fmtidx = (info & 0xff) - 1;
+	int vaidx = ((info >> 8) & 0xff) - 1;
+	struct expression *fmtexpr;
+	const char *caller = get_function();
+
+	if (!caller)
+		return;
+
+	/*
+	 * Calling a v*printf function with a literal format arg is
+	 * extremely rare, so we don't bother doing the only checking
+	 * we could do, namely checking that the format string is
+	 * valid.
+	 */
+	if (vaidx < 0)
+		return;
+
+	/*
+	 * For the things we use the name of the calling function for,
+	 * it is more appropriate to skip a potential SyS_ prefix; the
+	 * same goes for leading underscores.
+	 */
+	if (!strncmp(caller, "SyS_", 4))
+		caller += 4;
+	while (*caller == '_')
+		++caller;
+
+	/* Lack of format argument is a bug. */
+	fmtexpr = get_argument_from_call_expr(callexpr->args, fmtidx);
+	if (!fmtexpr) {
+		sm_error("call of '%s' with no format argument", name);
+		return;
+	}
+
+	do_check_printf_call(caller, name, callexpr, fmtexpr, vaidx);
+}
+
+
+void check_kernel_printf(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+
+#define printf_hook(func, fmt, first_to_check)	\
+	add_function_hook(#func, check_printf_call, INT_PTR(fmt + (first_to_check << 8)))
+
+	/* Extracted using stupid perl script. */
+
+#if 0
+	printf_hook(srm_printk, 1, 2);                    /* arch/alpha/include/asm/console.h */
+	printf_hook(die_if_kernel, 1, 2);                 /* arch/frv/include/asm/bug.h */
+	printf_hook(ia64_mca_printk, 1, 2);               /* arch/ia64/include/asm/mca.h */
+	printf_hook(nfprint, 1, 2);                       /* arch/m68k/include/asm/natfeat.h */
+	printf_hook(gdbstub_printk, 1, 2);                /* arch/mn10300/include/asm/gdb-stub.h */
+	printf_hook(DBG, 1, 2);                           /* arch/powerpc/boot/ps3.c */
+	printf_hook(printf, 1, 2);                        /* arch/powerpc/boot/stdio.h */
+	printf_hook(udbg_printf, 1, 2);                   /* arch/powerpc/include/asm/udbg.h */
+	printf_hook(__debug_sprintf_event, 3, 4);         /* arch/s390/include/asm/debug.h */
+	printf_hook(__debug_sprintf_exception, 3, 4);     /* arch/s390/include/asm/debug.h */
+	printf_hook(prom_printf, 1, 2);                   /* arch/sparc/include/asm/oplib_32.h */
+
+	printf_hook(fail, 1, 2);                          /* arch/x86/vdso/vdso2c.c */
+#endif
+
+	printf_hook(_ldm_printk, 3, 4);                   /* block/partitions/ldm.c */
+	printf_hook(rbd_warn, 2, 3);                      /* drivers/block/rbd.c */
+	printf_hook(fw_err, 2, 3);                        /* drivers/firewire/core.h */
+	printf_hook(fw_notice, 2, 3);                     /* drivers/firewire/core.h */
+	printf_hook(i915_error_printf, 2, 3);             /* drivers/gpu/drm/i915/i915_drv.h */
+	printf_hook(i915_handle_error, 3, 4);             /* drivers/gpu/drm/i915/i915_drv.h */
+	printf_hook(nv_printk_, 3, 4);                    /* drivers/gpu/drm/nouveau/core/include/core/printk.h */
+	printf_hook(host1x_debug_output, 2, 3);           /* drivers/gpu/host1x/debug.h */
+	printf_hook(callc_debug, 2, 3);                   /* drivers/isdn/hisax/callc.c */
+	printf_hook(link_debug, 3, 4);                    /* drivers/isdn/hisax/callc.c */
+	printf_hook(HiSax_putstatus, 3, 4);               /* drivers/isdn/hisax/hisax.h */
+	printf_hook(VHiSax_putstatus, 3, 0);              /* drivers/isdn/hisax/hisax.h */
+	printf_hook(debugl1, 2, 3);                       /* drivers/isdn/hisax/isdnl1.h */
+	printf_hook(l3m_debug, 2, 3);                     /* drivers/isdn/hisax/isdnl3.c */
+	printf_hook(dout_debug, 2, 3);                    /* drivers/isdn/hisax/st5481_d.c */
+	printf_hook(l1m_debug, 2, 3);                     /* drivers/isdn/hisax/st5481_d.c */
+	printf_hook(bch_cache_set_error, 2, 3);           /* drivers/md/bcache/bcache.h */
+	printf_hook(_tda_printk, 4, 5);                   /* drivers/media/tuners/tda18271-priv.h */
+	printf_hook(i40evf_debug_d, 3, 4);                /* drivers/net/ethernet/intel/i40evf/i40e_osdep.h */
+	printf_hook(en_print, 3, 4);                      /* drivers/net/ethernet/mellanox/mlx4/mlx4_en.h */
+	printf_hook(_ath_dbg, 3, 4);                      /* drivers/net/wireless/ath/ath.h */
+	printf_hook(ath_printk, 3, 4);                    /* drivers/net/wireless/ath/ath.h */
+	printf_hook(ath10k_dbg, 3, 4);                    /* drivers/net/wireless/ath/ath10k/debug.h */
+	printf_hook(ath10k_err, 2, 3);                    /* drivers/net/wireless/ath/ath10k/debug.h */
+	printf_hook(ath10k_info, 2, 3);                   /* drivers/net/wireless/ath/ath10k/debug.h */
+	printf_hook(ath10k_warn, 2, 3);                   /* drivers/net/wireless/ath/ath10k/debug.h */
+	printf_hook(_ath5k_printk, 3, 4);                 /* drivers/net/wireless/ath/ath5k/ath5k.h */
+	printf_hook(ATH5K_DBG, 3, 4);                     /* drivers/net/wireless/ath/ath5k/debug.h */
+	printf_hook(ATH5K_DBG_UNLIMIT, 3, 4);             /* drivers/net/wireless/ath/ath5k/debug.h */
+	printf_hook(ath6kl_printk, 2, 3);                 /* drivers/net/wireless/ath/ath6kl/common.h */
+	printf_hook(ath6kl_err, 1, 2);                    /* drivers/net/wireless/ath/ath6kl/debug.h */
+	printf_hook(ath6kl_info, 1, 2);                   /* drivers/net/wireless/ath/ath6kl/debug.h */
+	printf_hook(ath6kl_warn, 1, 2);                   /* drivers/net/wireless/ath/ath6kl/debug.h */
+	printf_hook(wil_dbg_trace, 2, 3);                 /* drivers/net/wireless/ath/wil6210/wil6210.h */
+	printf_hook(wil_err, 2, 3);                       /* drivers/net/wireless/ath/wil6210/wil6210.h */
+	printf_hook(wil_err_ratelimited, 2, 3);           /* drivers/net/wireless/ath/wil6210/wil6210.h */
+	printf_hook(wil_info, 2, 3);                      /* drivers/net/wireless/ath/wil6210/wil6210.h */
+	printf_hook(b43dbg, 2, 3);                        /* drivers/net/wireless/b43/b43.h */
+	printf_hook(b43err, 2, 3);                        /* drivers/net/wireless/b43/b43.h */
+	printf_hook(b43info, 2, 3);                       /* drivers/net/wireless/b43/b43.h */
+	printf_hook(b43warn, 2, 3);                       /* drivers/net/wireless/b43/b43.h */
+	printf_hook(b43legacydbg, 2, 3);                  /* drivers/net/wireless/b43legacy/b43legacy.h */
+	printf_hook(b43legacyerr, 2, 3);                  /* drivers/net/wireless/b43legacy/b43legacy.h */
+	printf_hook(b43legacyinfo, 2, 3);                 /* drivers/net/wireless/b43legacy/b43legacy.h */
+	printf_hook(b43legacywarn, 2, 3);                 /* drivers/net/wireless/b43legacy/b43legacy.h */
+	printf_hook(__brcmf_dbg, 3, 4);                   /* drivers/net/wireless/brcm80211/brcmfmac/debug.h */
+	printf_hook(__brcmf_err, 2, 3);                   /* drivers/net/wireless/brcm80211/brcmfmac/debug.h */
+	printf_hook(__brcms_crit, 2, 3);                  /* drivers/net/wireless/brcm80211/brcmsmac/debug.h */
+	printf_hook(__brcms_dbg, 4, 5);                   /* drivers/net/wireless/brcm80211/brcmsmac/debug.h */
+	printf_hook(__brcms_err, 2, 3);                   /* drivers/net/wireless/brcm80211/brcmsmac/debug.h */
+	printf_hook(__brcms_info, 2, 3);                  /* drivers/net/wireless/brcm80211/brcmsmac/debug.h */
+	printf_hook(__brcms_warn, 2, 3);                  /* drivers/net/wireless/brcm80211/brcmsmac/debug.h */
+	printf_hook(brcmu_dbg_hex_dump, 3, 4);            /* drivers/net/wireless/brcm80211/include/brcmu_utils.h */
+	printf_hook(__iwl_crit, 2, 3);                    /* drivers/net/wireless/iwlwifi/iwl-debug.h */
+	printf_hook(__iwl_dbg, 5, 6);                     /* drivers/net/wireless/iwlwifi/iwl-debug.h */
+	printf_hook(__iwl_err, 4, 5);                     /* drivers/net/wireless/iwlwifi/iwl-debug.h */
+	printf_hook(__iwl_info, 2, 3);                    /* drivers/net/wireless/iwlwifi/iwl-debug.h */
+	printf_hook(__iwl_warn, 2, 3);                    /* drivers/net/wireless/iwlwifi/iwl-debug.h */
+	printf_hook(rsi_dbg, 2, 3);                       /* drivers/net/wireless/rsi/rsi_main.h */
+	printf_hook(RTPRINT, 4, 5);                       /* drivers/net/wireless/rtlwifi/debug.h */
+	printf_hook(RT_ASSERT, 2, 3);                     /* drivers/net/wireless/rtlwifi/debug.h */
+	printf_hook(RT_TRACE, 4, 5);                      /* drivers/net/wireless/rtlwifi/debug.h */
+	printf_hook(__of_node_dup, 2, 3);                 /* drivers/of/of_private.h */
+	printf_hook(BNX2FC_HBA_DBG, 2, 3);                /* drivers/scsi/bnx2fc/bnx2fc_debug.h */
+	printf_hook(BNX2FC_IO_DBG, 2, 3);                 /* drivers/scsi/bnx2fc/bnx2fc_debug.h */
+	printf_hook(BNX2FC_TGT_DBG, 2, 3);                /* drivers/scsi/bnx2fc/bnx2fc_debug.h */
+	printf_hook(ql_dbg, 4, 5);                        /* drivers/scsi/qla2xxx/qla_dbg.h */
+	printf_hook(ql_dbg_pci, 4, 5);                    /* drivers/scsi/qla2xxx/qla_dbg.h */
+	printf_hook(ql_log, 4, 5);                        /* drivers/scsi/qla2xxx/qla_dbg.h */
+	printf_hook(ql_log_pci, 4, 5);                    /* drivers/scsi/qla2xxx/qla_dbg.h */
+	printf_hook(libcfs_debug_msg, 2, 3);              /* drivers/staging/lustre/include/linux/libcfs/libcfs_debug.h */
+	printf_hook(libcfs_debug_vmsg2, 4, 5);            /* drivers/staging/lustre/include/linux/libcfs/libcfs_debug.h */
+	printf_hook(_ldlm_lock_debug, 3, 4);              /* drivers/staging/lustre/lustre/include/lustre_dlm.h */
+	printf_hook(_debug_req, 3, 4);                    /* drivers/staging/lustre/lustre/include/lustre_net.h */
+	printf_hook(iscsi_change_param_sprintf, 2, 3);    /* drivers/target/iscsi/iscsi_target_login.c */
+	printf_hook(dbg, 1, 2);                           /* drivers/tty/serial/samsung.c */
+	printf_hook(_usb_stor_dbg, 2, 3);                 /* drivers/usb/storage/debug.h */
+	printf_hook(usb_stor_dbg, 2, 3);                  /* drivers/usb/storage/debug.h */
+	printf_hook(vringh_bad, 1, 2);                    /* drivers/vhost/vringh.c */
+	printf_hook(__adfs_error, 3, 4);                  /* fs/adfs/adfs.h */
+	printf_hook(affs_error, 3, 4);                    /* fs/affs/affs.h */
+	printf_hook(affs_warning, 3, 4);                  /* fs/affs/affs.h */
+	printf_hook(befs_debug, 2, 3);                    /* fs/befs/befs.h */
+	printf_hook(befs_error, 2, 3);                    /* fs/befs/befs.h */
+	printf_hook(befs_warning, 2, 3);                  /* fs/befs/befs.h */
+	printf_hook(__btrfs_panic, 5, 6);                 /* fs/btrfs/ctree.h */
+	printf_hook(__btrfs_std_error, 5, 6);             /* fs/btrfs/ctree.h */
+	printf_hook(btrfs_printk, 2, 3);                  /* fs/btrfs/ctree.h */
+	printf_hook(cifs_vfs_err, 1, 2);                  /* fs/cifs/cifs_debug.h */
+	printf_hook(__ecryptfs_printk, 1, 2);             /* fs/ecryptfs/ecryptfs_kernel.h */
+	printf_hook(ext2_error, 3, 4);                    /* fs/ext2/ext2.h */
+	printf_hook(ext2_msg, 3, 4);                      /* fs/ext2/ext2.h */
+	printf_hook(ext3_abort, 3, 4);                    /* fs/ext3/ext3.h */
+	printf_hook(ext3_error, 3, 4);                    /* fs/ext3/ext3.h */
+	printf_hook(ext3_msg, 3, 4);                      /* fs/ext3/ext3.h */
+	printf_hook(ext3_warning, 3, 4);                  /* fs/ext3/ext3.h */
+	printf_hook(__ext4_abort, 4, 5);                  /* fs/ext4/ext4.h */
+	printf_hook(__ext4_error, 4, 5);                  /* fs/ext4/ext4.h */
+	printf_hook(__ext4_error_file, 5, 6);             /* fs/ext4/ext4.h */
+	printf_hook(__ext4_error_inode, 5, 6);            /* fs/ext4/ext4.h */
+	printf_hook(__ext4_grp_locked_error, 7, 8);       /* fs/ext4/ext4.h */
+	printf_hook(__ext4_msg, 3, 4);                    /* fs/ext4/ext4.h */
+	printf_hook(__ext4_warning, 4, 5);                /* fs/ext4/ext4.h */
+	printf_hook(f2fs_msg, 3, 4);                      /* fs/f2fs/f2fs.h */
+	printf_hook(__fat_fs_error, 3, 4);                /* fs/fat/fat.h */
+	printf_hook(fat_msg, 3, 4);                       /* fs/fat/fat.h */
+	printf_hook(gfs2_print_dbg, 2, 3);                /* fs/gfs2/glock.h */
+	printf_hook(gfs2_lm_withdraw, 2, 3);              /* fs/gfs2/util.h */
+	printf_hook(hpfs_error, 2, 3);                    /* fs/hpfs/hpfs_fn.h */
+	printf_hook(jfs_error, 2, 3);                     /* fs/jfs/jfs_superblock.h */
+	printf_hook(nilfs_error, 3, 4);                   /* fs/nilfs2/nilfs.h */
+	printf_hook(nilfs_warning, 3, 4);                 /* fs/nilfs2/nilfs.h */
+	printf_hook(__ntfs_debug, 4, 5);                  /* fs/ntfs/debug.h */
+	printf_hook(__ntfs_error, 3, 4);                  /* fs/ntfs/debug.h */
+	printf_hook(__ntfs_warning, 3, 4);                /* fs/ntfs/debug.h */
+	printf_hook(__ocfs2_abort, 3, 4);                 /* fs/ocfs2/super.h */
+	printf_hook(__ocfs2_error, 3, 4);                 /* fs/ocfs2/super.h */
+	printf_hook(_udf_err, 3, 4);                      /* fs/udf/udfdecl.h */
+	printf_hook(_udf_warn, 3, 4);                     /* fs/udf/udfdecl.h */
+	printf_hook(ufs_error, 3, 4);                     /* fs/ufs/ufs.h */
+	printf_hook(ufs_panic, 3, 4);                     /* fs/ufs/ufs.h */
+	printf_hook(ufs_warning, 3, 4);                   /* fs/ufs/ufs.h */
+	printf_hook(xfs_alert, 2, 3);                     /* fs/xfs/xfs_message.h */
+	printf_hook(xfs_alert_tag, 3, 4);                 /* fs/xfs/xfs_message.h */
+	printf_hook(xfs_crit, 2, 3);                      /* fs/xfs/xfs_message.h */
+	printf_hook(xfs_debug, 2, 3);                     /* fs/xfs/xfs_message.h */
+	printf_hook(xfs_emerg, 2, 3);                     /* fs/xfs/xfs_message.h */
+	printf_hook(xfs_err, 2, 3);                       /* fs/xfs/xfs_message.h */
+	printf_hook(xfs_info, 2, 3);                      /* fs/xfs/xfs_message.h */
+	printf_hook(xfs_notice, 2, 3);                    /* fs/xfs/xfs_message.h */
+	printf_hook(xfs_warn, 2, 3);                      /* fs/xfs/xfs_message.h */
+	printf_hook(warn_slowpath_fmt, 3, 4);             /* include/asm-generic/bug.h */
+	printf_hook(warn_slowpath_fmt_taint, 4, 5);       /* include/asm-generic/bug.h */
+	printf_hook(drm_err, 1, 2);                       /* include/drm/drmP.h */
+	printf_hook(drm_ut_debug_printk, 2, 3);           /* include/drm/drmP.h */
+	printf_hook(__acpi_handle_debug, 3, 4);           /* include/linux/acpi.h */
+	printf_hook(acpi_handle_printk, 3, 4);            /* include/linux/acpi.h */
+	printf_hook(audit_log, 4, 5);                     /* include/linux/audit.h */
+	printf_hook(audit_log_format, 2, 3);              /* include/linux/audit.h */
+	printf_hook(bdi_register, 3, 4);                  /* include/linux/backing-dev.h */
+	printf_hook(__trace_note_message, 2, 3);          /* include/linux/blktrace_api.h */
+	printf_hook(_dev_info, 2, 3);                     /* include/linux/device.h */
+	printf_hook(dev_alert, 2, 3);                     /* include/linux/device.h */
+	printf_hook(dev_crit, 2, 3);                      /* include/linux/device.h */
+	printf_hook(dev_emerg, 2, 3);                     /* include/linux/device.h */
+	printf_hook(dev_err, 2, 3);                       /* include/linux/device.h */
+	printf_hook(dev_notice, 2, 3);                    /* include/linux/device.h */
+	printf_hook(dev_printk, 3, 4);                    /* include/linux/device.h */
+	printf_hook(dev_printk_emit, 3, 4);               /* include/linux/device.h */
+	printf_hook(dev_set_name, 2, 3);                  /* include/linux/device.h */
+	printf_hook(dev_vprintk_emit, 3, 0);              /* include/linux/device.h */
+	printf_hook(dev_warn, 2, 3);                      /* include/linux/device.h */
+	printf_hook(device_create, 5, 6);                 /* include/linux/device.h */
+	printf_hook(device_create_with_groups, 6, 7);     /* include/linux/device.h */
+	printf_hook(devm_kasprintf, 3, 4);                /* include/linux/device.h */
+	printf_hook(__dynamic_dev_dbg, 3, 4);             /* include/linux/dynamic_debug.h */
+	printf_hook(__dynamic_netdev_dbg, 3, 4);          /* include/linux/dynamic_debug.h */
+	printf_hook(__dynamic_pr_debug, 2, 3);            /* include/linux/dynamic_debug.h */
+	printf_hook(__simple_attr_check_format, 1, 2);    /* include/linux/fs.h */
+	printf_hook(fscache_init_cache, 3, 4);            /* include/linux/fscache-cache.h */
+	printf_hook(gameport_set_phys, 2, 3);             /* include/linux/gameport.h */
+	printf_hook(iio_trigger_alloc, 1, 2);             /* include/linux/iio/trigger.h */
+	printf_hook(__check_printsym_format, 1, 2);       /* include/linux/kallsyms.h */
+	printf_hook(kdb_printf, 1, 2);                    /* include/linux/kdb.h */
+	printf_hook(vkdb_printf, 1, 0);                   /* include/linux/kdb.h */
+	printf_hook(____trace_printk_check_format, 1, 2);  /* include/linux/kernel.h */
+	printf_hook(__trace_bprintk, 2, 3);               /* include/linux/kernel.h */
+	printf_hook(__trace_printk, 2, 3);                /* include/linux/kernel.h */
+	printf_hook(kasprintf, 2, 3);                     /* include/linux/kernel.h */
+	printf_hook(panic, 1, 2);                         /* include/linux/kernel.h */
+	printf_hook(scnprintf, 3, 4);                     /* include/linux/kernel.h */
+	printf_hook(snprintf, 3, 4);                      /* include/linux/kernel.h */
+	printf_hook(sprintf, 2, 3);                       /* include/linux/kernel.h */
+	printf_hook(trace_printk, 1, 2);                  /* include/linux/kernel.h */
+	printf_hook(vscnprintf, 3, 0);                    /* include/linux/kernel.h */
+	printf_hook(vsnprintf, 3, 0);                     /* include/linux/kernel.h */
+	printf_hook(vsprintf, 2, 0);                      /* include/linux/kernel.h */
+	printf_hook(vmcoreinfo_append_str, 1, 2);         /* include/linux/kexec.h */
+	printf_hook(__request_module, 2, 3);              /* include/linux/kmod.h */
+	printf_hook(add_uevent_var, 2, 3);                /* include/linux/kobject.h */
+	printf_hook(kobject_add, 3, 4);                   /* include/linux/kobject.h */
+	printf_hook(kobject_init_and_add, 4, 5);          /* include/linux/kobject.h */
+	printf_hook(kobject_set_name, 2, 3);              /* include/linux/kobject.h */
+	printf_hook(kthread_create_on_node, 4, 5);        /* include/linux/kthread.h */
+	printf_hook(__ata_ehi_push_desc, 2, 3);           /* include/linux/libata.h */
+	printf_hook(ata_dev_printk, 3, 4);                /* include/linux/libata.h */
+	printf_hook(ata_ehi_push_desc, 2, 3);             /* include/linux/libata.h */
+	printf_hook(ata_link_printk, 3, 4);               /* include/linux/libata.h */
+	printf_hook(ata_port_desc, 2, 3);                 /* include/linux/libata.h */
+	printf_hook(ata_port_printk, 3, 4);               /* include/linux/libata.h */
+	printf_hook(warn_alloc_failed, 3, 4);             /* include/linux/mm.h */
+	printf_hook(mmiotrace_printk, 1, 2);              /* include/linux/mmiotrace.h */
+	printf_hook(netdev_alert, 2, 3);                  /* include/linux/netdevice.h */
+	printf_hook(netdev_crit, 2, 3);                   /* include/linux/netdevice.h */
+	printf_hook(netdev_emerg, 2, 3);                  /* include/linux/netdevice.h */
+	printf_hook(netdev_err, 2, 3);                    /* include/linux/netdevice.h */
+	printf_hook(netdev_info, 2, 3);                   /* include/linux/netdevice.h */
+	printf_hook(netdev_notice, 2, 3);                 /* include/linux/netdevice.h */
+	printf_hook(netdev_printk, 3, 4);                 /* include/linux/netdevice.h */
+	printf_hook(netdev_warn, 2, 3);                   /* include/linux/netdevice.h */
+	printf_hook(early_printk, 1, 2);                  /* include/linux/printk.h */
+	printf_hook(no_printk, 1, 2);                     /* include/linux/printk.h */
+	printf_hook(printk, 1, 2);                        /* include/linux/printk.h */
+	printf_hook(printk_deferred, 1, 2);               /* include/linux/printk.h */
+	printf_hook(printk_emit, 5, 6);                   /* include/linux/printk.h */
+	printf_hook(vprintk, 1, 0);                       /* include/linux/printk.h */
+	printf_hook(vprintk_emit, 5, 0);                  /* include/linux/printk.h */
+	printf_hook(__quota_error, 3, 4);                 /* include/linux/quotaops.h */
+	printf_hook(seq_buf_printf, 2, 3);                /* include/linux/seq_buf.h */
+	printf_hook(seq_buf_vprintf, 2, 0);               /* include/linux/seq_buf.h */
+	printf_hook(seq_printf, 2, 3);                    /* include/linux/seq_file.h */
+	printf_hook(seq_vprintf, 2, 0);                   /* include/linux/seq_file.h */
+	printf_hook(bprintf, 3, 4);                       /* include/linux/string.h */
+	printf_hook(trace_seq_printf, 2, 3);              /* include/linux/trace_seq.h */
+	printf_hook(trace_seq_vprintf, 2, 0);             /* include/linux/trace_seq.h */
+	printf_hook(__alloc_workqueue_key, 1, 6);         /* include/linux/workqueue.h */
+	printf_hook(set_worker_desc, 1, 2);               /* include/linux/workqueue.h */
+	printf_hook(_p9_debug, 3, 4);                     /* include/net/9p/9p.h */
+	printf_hook(bt_err, 1, 2);                        /* include/net/bluetooth/bluetooth.h */
+	printf_hook(bt_info, 1, 2);                       /* include/net/bluetooth/bluetooth.h */
+	printf_hook(nf_ct_helper_log, 3, 4);              /* include/net/netfilter/nf_conntrack_helper.h */
+	printf_hook(nf_log_buf_add, 2, 3);                /* include/net/netfilter/nf_log.h */
+	printf_hook(nf_log_packet, 8, 9);                 /* include/net/netfilter/nf_log.h */
+	printf_hook(SOCK_DEBUG, 2, 3);                    /* include/net/sock.h */
+	printf_hook(__snd_printk, 4, 5);                  /* include/sound/core.h */
+	printf_hook(_snd_printd, 2, 3);                   /* include/sound/core.h */
+	printf_hook(snd_printd, 1, 2);                    /* include/sound/core.h */
+	printf_hook(snd_printdd, 1, 2);                   /* include/sound/core.h */
+	printf_hook(snd_iprintf, 2, 3);                   /* include/sound/info.h */
+	printf_hook(snd_seq_create_kernel_client, 3, 4);  /* include/sound/seq_kernel.h */
+	printf_hook(xen_raw_printk, 1, 2);                /* include/xen/hvc-console.h */
+	printf_hook(xenbus_dev_error, 3, 4);              /* include/xen/xenbus.h */
+	printf_hook(xenbus_dev_fatal, 3, 4);              /* include/xen/xenbus.h */
+	printf_hook(xenbus_printf, 4, 5);                 /* include/xen/xenbus.h */
+	printf_hook(xenbus_watch_pathfmt, 4, 5);          /* include/xen/xenbus.h */
+	printf_hook(batadv_fdebug_log, 2, 3);             /* net/batman-adv/debugfs.c */
+	printf_hook(_batadv_dbg, 4, 5);                   /* net/batman-adv/main.h */
+	printf_hook(batadv_debug_log, 2, 3);              /* net/batman-adv/main.h */
+	printf_hook(__sdata_dbg, 2, 3);                   /* net/mac80211/debug.h */
+	printf_hook(__sdata_err, 1, 2);                   /* net/mac80211/debug.h */
+	printf_hook(__sdata_info, 1, 2);                  /* net/mac80211/debug.h */
+	printf_hook(__wiphy_dbg, 3, 4);                   /* net/mac80211/debug.h */
+	printf_hook(mac80211_format_buffer, 4, 5);        /* net/mac80211/debugfs.h */
+	printf_hook(__rds_conn_error, 2, 3);              /* net/rds/rds.h */
+	printf_hook(rdsdebug, 1, 2);                      /* net/rds/rds.h */
+	printf_hook(printl, 1, 2);                        /* net/sctp/probe.c */
+	printf_hook(svc_printk, 2, 3);                    /* net/sunrpc/svc.c */
+	printf_hook(tomoyo_io_printf, 2, 3);              /* security/tomoyo/common.c */
+	printf_hook(tomoyo_supervisor, 2, 3);             /* security/tomoyo/common.h */
+	printf_hook(tomoyo_write_log, 2, 3);              /* security/tomoyo/common.h */
+	printf_hook(cmp_error, 2, 3);                     /* sound/firewire/cmp.c */
+}
diff --git a/usr/src/tools/smatch/src/check_kmalloc_to_bugon.c b/usr/src/tools/smatch/src/check_kmalloc_to_bugon.c
new file mode 100644
index 0000000000..514a4ad5bc
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_kmalloc_to_bugon.c
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+extern int check_assigned_expr_id;
+
+static int is_kmalloc_call(struct expression *expr)
+{
+	if (expr->type != EXPR_CALL)
+		return 0;
+	if (expr->fn->type != EXPR_SYMBOL)
+		return 0;
+	if (!strcmp(expr->fn->symbol_name->name, "kmalloc"))
+		return 1;
+	if (!strcmp(expr->fn->symbol_name->name, "kzalloc"))
+		return 1;
+	return 0;
+}
+
+static void match_condition(struct expression *expr)
+{
+	char *macro;
+	struct smatch_state *state;
+	struct expression *right;
+	char *name;
+
+	macro = get_macro_name(expr->pos);
+	if (!macro || strcmp(macro, "BUG_ON") != 0)
+		return;
+	state = get_state_expr(check_assigned_expr_id, expr);
+	if (!state || !state->data)
+		return;
+	right = (struct expression *)state->data;
+	if (!is_kmalloc_call(right))
+		return;
+
+	name = expr_to_var(expr);
+	sm_warning("bug on allocation failure '%s'", name);
+	free_string(name);
+}
+
+void check_kmalloc_to_bugon(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	if (!option_spammy)
+		return;
+	my_id = id;
+	add_hook(&match_condition, CONDITION_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_kmalloc_wrong_size.c b/usr/src/tools/smatch/src/check_kmalloc_wrong_size.c
new file mode 100644
index 0000000000..41e1e0e64c
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_kmalloc_wrong_size.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2011 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static int get_data_size(struct expression *ptr)
+{
+	struct symbol *type;
+
+	type = get_type(ptr);
+	if (!type || type->type != SYM_PTR)
+		return 0;
+	type = get_base_type(type);
+	if (!type)
+		return 0;
+	return type_bytes(type);
+}
+
+static void check_size_matches(int data_size, struct expression *size_expr)
+{
+	sval_t sval;
+
+	if (data_size == 1)  /* this is generic a buffer */
+		return;
+
+	if (!get_implied_value(size_expr, &sval))
+		return;
+	if (sval_cmp_val(sval, data_size) != 0)
+		sm_warning("double check that we're allocating correct size: %d vs %s", data_size, sval_to_str(sval));
+}
+
+static void match_alloc(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *call = strip_expr(expr->right);
+	struct expression *arg;
+	int ptr_size;
+
+	ptr_size = get_data_size(expr->left);
+	if (!ptr_size)
+		return;
+
+	arg = get_argument_from_call_expr(call->args, 0);
+	arg = strip_expr(arg);
+	if (!arg || arg->type != EXPR_BINOP || arg->op != '*')
+		return;
+	if (expr->left->type == EXPR_SIZEOF)
+		check_size_matches(ptr_size, arg->left);
+	if (expr->right->type == EXPR_SIZEOF)
+		check_size_matches(ptr_size, arg->right);
+}
+
+static void match_calloc(const char *fn, struct expression *expr, void *_arg_nr)
+{
+	int arg_nr = PTR_INT(_arg_nr);
+	struct expression *call = strip_expr(expr->right);
+	struct expression *arg;
+	int ptr_size;
+
+	ptr_size = get_data_size(expr->left);
+	if (!ptr_size)
+		return;
+
+	arg = get_argument_from_call_expr(call->args, arg_nr);
+	check_size_matches(ptr_size, arg);
+}
+
+void check_kmalloc_wrong_size(int id)
+{
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL) {
+		add_function_assign_hook("malloc", &match_alloc, NULL);
+		add_function_assign_hook("calloc", &match_calloc, INT_PTR(1));
+		return;
+	}
+
+	add_function_assign_hook("kmalloc", &match_alloc, NULL);
+	add_function_assign_hook("kcalloc", &match_calloc, INT_PTR(1));
+}
diff --git a/usr/src/tools/smatch/src/check_kunmap.c b/usr/src/tools/smatch/src/check_kunmap.c
new file mode 100644
index 0000000000..c8ce6324e0
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_kunmap.c
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+STATE(no_unmap);
+
+extern int check_assigned_expr_id;
+static int my_id;
+
+static void check_assignment(void *data)
+{
+	struct expression *expr = (struct expression *)data;
+	char *fn;
+
+	if (!expr)
+		return;
+	if (expr->type != EXPR_CALL)
+		return;
+	fn = expr_to_var(expr->fn);
+	if (!fn)
+		return;
+	if (!strcmp(fn, "kmap"))
+		sm_warning("passing the wrong variable to kunmap()");
+	free_string(fn);
+}
+
+static void match_kmap_atomic(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	set_state_expr(my_id, arg, &no_unmap);
+}
+
+static void match_kunmap_atomic(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg;
+	struct sm_state *sm;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	sm = get_sm_state_expr(my_id, arg);
+	if (!sm)
+		return;
+	if (slist_has_state(sm->possible, &no_unmap))
+		sm_warning("passing the wrong variable to kmap_atomic()");
+}
+
+static void match_kunmap(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg;
+	struct sm_state *sm;
+	struct sm_state *tmp;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	sm = get_sm_state_expr(check_assigned_expr_id, arg);
+	if (!sm)
+		return;
+	FOR_EACH_PTR(sm->possible, tmp) {
+		check_assignment(tmp->state->data);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+void check_kunmap(int id)
+{
+	my_id = id;
+	if (option_project != PROJ_KERNEL)
+		return;
+	add_function_hook("kunmap", &match_kunmap, NULL);
+	add_function_hook("kmap_atomic", &match_kmap_atomic, NULL);
+	add_function_hook("kunmap_atomic", &match_kunmap_atomic, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_leaks.c b/usr/src/tools/smatch/src/check_leaks.c
new file mode 100644
index 0000000000..1c627a35a5
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_leaks.c
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The point of this check is to look for leaks.
+ * foo = malloc();  // <- mark it as allocated.
+ * A variable becomes &ok if we:
+ * 1) assign it to another variable.
+ * 2) pass it to a function.
+ *
+ * One complication is dealing with stuff like:
+ * foo->bar = malloc();
+ * foo->baz = malloc();
+ * foo = something();
+ *
+ * The work around is that for now what this check only
+ * checks simple expressions and doesn't check whether
+ * foo->bar is leaked.
+ * 
+ */
+
+#include <fcntl.h>
+#include <unistd.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(allocated);
+STATE(ok);
+
+static void set_parent(struct expression *expr, struct smatch_state *state);
+
+static const char *allocation_funcs[] = {
+	"malloc",
+	"kmalloc",
+	"kzalloc",
+	"kmemdup",
+};
+
+static char *alloc_parent_str(struct symbol *sym)
+{
+	static char buf[256];
+
+	if (!sym || !sym->ident)
+		return NULL;
+
+	snprintf(buf, 255, "%s", sym->ident->name);
+	buf[255] = '\0';
+	return alloc_string(buf);
+}
+
+static char *get_parent_from_expr(struct expression *expr, struct symbol **sym)
+{
+	char *name;
+
+	expr = strip_expr(expr);
+
+	name = expr_to_str_sym(expr, sym);
+	free_string(name);
+	if (!name || !*sym || !(*sym)->ident) {
+		*sym = NULL;
+		return NULL;
+	}
+	return alloc_parent_str(*sym);
+}
+
+static int is_local(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	int ret = 0;
+
+	name = expr_to_str_sym(expr, &sym);
+	if (!name || !sym)
+		goto out;
+	if (sym->ctype.modifiers & (MOD_NONLOCAL | MOD_STATIC | MOD_ADDRESSABLE))
+		goto out;
+	ret = 1;
+out:
+	free_string(name);
+	return ret;
+}
+
+static int is_param(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	struct symbol *tmp;
+	int ret = 0;
+
+	name = expr_to_str_sym(expr, &sym);
+	if (!name || !sym)
+		goto out;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, tmp) {
+		if (tmp == sym) {
+			ret = 1;
+			goto out;
+		}
+	} END_FOR_EACH_PTR(tmp);
+out:
+	free_string(name);
+	return ret;
+	
+}
+
+static void match_alloc(const char *fn, struct expression *expr, void *unused)
+{
+	if (!is_local(expr->left))
+		return;
+	if (is_param(expr->left))
+		return;
+	if (expr->left->type != EXPR_SYMBOL)
+		return;
+	set_state_expr(my_id, expr->left, &allocated);
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	expr = strip_expr(expr);
+
+	switch (expr->type) {
+	case EXPR_PREOP:
+	case EXPR_SYMBOL:
+	case EXPR_DEREF:
+		sm = get_sm_state_expr(my_id, expr);
+		if (sm && slist_has_state(sm->possible, &allocated))
+			set_true_false_states_expr(my_id, expr, NULL, &ok);
+		return;
+	case EXPR_ASSIGNMENT:
+		 /* You have to deal with stuff like if (a = b = c) */
+		match_condition(expr->left);
+		return;
+	default:
+		return;
+	}
+}
+
+static void set_parent(struct expression *expr, struct smatch_state *state)
+{
+	char *name;
+	struct symbol *sym;
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return;
+	if (expr->type == EXPR_CONDITIONAL ||
+	    expr->type == EXPR_SELECT) {
+		set_parent(expr->cond_true, state);
+		set_parent(expr->cond_false, state);
+		return;
+	}
+
+	name = get_parent_from_expr(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	if (state == &ok && !get_state(my_id, name, sym))
+		goto free;
+	set_state(my_id, name, sym, state);
+free:
+	free_string(name);
+}
+
+static void match_function_call(struct expression *expr)
+{
+	struct expression *tmp;
+
+	FOR_EACH_PTR(expr->args, tmp) {
+		set_parent(tmp, &ok);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void warn_if_allocated(struct expression *expr)
+{
+	struct sm_state *sm;
+	char *name;
+	sval_t sval;
+
+	if (get_implied_value(expr, &sval) && sval.value == 0)
+		return;
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return;
+	if (!slist_has_state(sm->possible, &allocated))
+		return;
+
+	name = expr_to_var(expr);
+	sm_warning("overwrite may leak '%s'", name);
+	free_string(name);
+
+	/* silence further warnings */
+	set_state_expr(my_id, expr, &ok);
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *right;
+
+	right = expr->right;
+
+	while (right->type == EXPR_ASSIGNMENT)
+		right = right->left;
+
+	warn_if_allocated(expr->left);
+	set_parent(right, &ok);
+}
+
+static void check_for_allocated(void)
+{
+	struct stree *stree;
+	struct sm_state *tmp;
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(my_id, stree, tmp) {
+		if (!slist_has_state(tmp->possible, &allocated))
+			continue;
+		sm_warning("possible memory leak of '%s'", tmp->name);
+	} END_FOR_EACH_SM(tmp);
+}
+
+static void match_return(struct expression *ret_value)
+{
+	if (__inline_fn)
+		return;
+	set_parent(ret_value, &ok);
+	check_for_allocated();
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	check_for_allocated();
+}
+
+void check_leaks(int id)
+{
+	int i;
+
+	my_id = id;
+
+	for (i = 0; i < ARRAY_SIZE(allocation_funcs); i++)
+		add_function_assign_hook(allocation_funcs[i], &match_alloc, NULL);
+
+	add_hook(&match_condition, CONDITION_HOOK);
+
+	add_hook(&match_function_call, FUNCTION_CALL_HOOK);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+
+	add_hook(&match_return, RETURN_HOOK);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_list.h b/usr/src/tools/smatch/src/check_list.h
new file mode 100644
index 0000000000..0c6ab0cd5f
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_list.h
@@ -0,0 +1,219 @@
+#ifndef CK
+#define CK(_x) void _x(int id);
+#define __undo_CK_def
+#endif
+
+CK(register_db_call_marker) /* always has to be first  */
+CK(register_param_used)     /* get_state_hooks have to be registered before smatch_extra */
+CK(register_container_of)
+CK(register_container_of2)
+CK(register_smatch_extra)   /* smatch_extra always has to be SMATCH_EXTRA */
+CK(register_smatch_extra_links)
+CK(register_modification_hooks)
+/*
+ * Implications should probably be after all the modification and smatch_extra
+ * hooks have run.
+ *
+ */
+CK(register_implications)
+CK(register_definition_db_callbacks)
+CK(register_project)
+CK(register_untracked_param)
+CK(register_buf_comparison)
+CK(register_buf_comparison_links)
+CK(register_param_compare_limit)
+CK(register_param_compare_limit_links)
+CK(register_returns_early)
+
+CK(register_smatch_ignore)
+CK(register_buf_size)
+CK(register_strlen)
+CK(register_strlen_equiv)
+CK(register_capped)
+CK(register_parse_call_math)
+CK(register_param_limit)
+CK(register_param_filter)
+CK(register_param_set)
+CK(register_param_cleared)
+CK(register_struct_assignment)
+CK(register_comparison)
+CK(register_comparison_links)
+CK(register_comparison_inc_dec)
+CK(register_comparison_inc_dec_links)
+CK(register_local_values)
+CK(register_function_ptrs)
+CK(register_annotate)
+CK(register_start_states)
+CK(register_type_val)
+CK(register_data_source)
+CK(register_common_functions)
+CK(register_function_info)
+CK(register_auto_copy)
+CK(register_type_links)
+CK(register_impossible)
+CK(register_impossible_return)
+CK(register_strings)
+CK(register_real_absolute)
+CK(register_imaginary_absolute)
+CK(register_fn_arg_link)
+CK(register_parameter_names)
+CK(register_return_to_param)
+CK(register_return_to_param_links)
+CK(register_constraints)
+CK(register_constraints_required)
+CK(register_about_fn_ptr_arg)
+CK(register_mtag)
+CK(register_mtag_map)
+CK(register_mtag_data)
+CK(register_param_to_mtag_data)
+CK(register_array_values)
+CK(register_nul_terminator)
+CK(register_nul_terminator_param_set)
+CK(register_statement_count)
+
+CK(register_kernel_user_data2)
+CK(register_kernel_user_data3)
+
+CK(check_debug)
+
+CK(check_bogus_loop)
+
+CK(check_deref)
+CK(check_check_deref)
+CK(check_dereferences_param)
+CK(check_index_overflow)
+CK(check_index_overflow_loop_marker)
+CK(check_testing_index_after_use)
+CK(check_memcpy_overflow)
+CK(check_strcpy_overflow)
+CK(check_sprintf_overflow)
+CK(check_snprintf_overflow)
+CK(check_allocating_enough_data)
+CK(check_leaks)
+CK(check_type)
+CK(check_allocation_funcs)
+CK(check_frees_argument)
+CK(check_deref_check)
+CK(check_signed)
+CK(check_precedence)
+CK(check_unused_ret)
+CK(check_dma_on_stack)
+CK(check_param_mapper)
+CK(check_call_tree)
+CK(check_dev_queue_xmit)
+CK(check_stack)
+CK(check_no_return)
+CK(check_mod_timer)
+CK(check_return)
+CK(check_resource_size)
+CK(check_release_resource)
+CK(check_proc_create)
+CK(check_freeing_null)
+CK(check_frees_param)
+CK(check_free)
+CK(check_frees_param_strict)
+CK(check_free_strict)
+CK(check_no_effect)
+CK(check_kunmap)
+CK(check_snprintf)
+CK(check_macros)
+CK(check_return_efault)
+CK(check_gfp_dma)
+CK(check_unwind)
+CK(check_kmalloc_to_bugon)
+CK(check_platform_device_put)
+CK(check_info_leak)
+CK(check_return_enomem)
+CK(check_get_user_overflow)
+CK(check_get_user_overflow2)
+CK(check_access_ok_math)
+CK(check_container_of)
+CK(check_input_free_device)
+CK(check_select)
+CK(check_memset)
+CK(check_logical_instead_of_bitwise)
+CK(check_kmalloc_wrong_size)
+CK(check_pointer_math)
+CK(check_bit_shift)
+CK(check_macro_side_effects)
+CK(check_sizeof)
+CK(check_return_cast)
+CK(check_or_vs_and)
+CK(check_passes_sizeof)
+CK(check_assign_vs_compare)
+CK(check_missing_break)
+CK(check_array_condition)
+CK(check_struct_type)
+CK(check_64bit_shift)
+CK(check_wrong_size_arg)
+CK(check_cast_assign)
+CK(check_readl_infinite_loops)
+CK(check_double_checking)
+CK(check_shift_to_zero)
+CK(check_indenting)
+CK(check_unreachable)
+CK(check_no_if_block)
+CK(check_buffer_too_small_for_struct)
+CK(check_uninitialized)
+CK(check_signed_integer_overflow_check)
+CK(check_continue_vs_break)
+CK(check_impossible_mask)
+CK(check_syscall_arg_type)
+CK(check_trinity_generator)
+
+/* <- your test goes here */
+/* CK(register_template) */
+
+/* kernel specific */
+CK(check_kernel_printf)
+CK(check_locking)
+CK(check_puts_argument)
+CK(check_err_ptr)
+CK(check_err_ptr_deref)
+CK(check_expects_err_ptr)
+CK(check_held_dev)
+CK(check_return_negative_var)
+CK(check_rosenberg)
+CK(check_rosenberg2)
+CK(check_wait_for_common)
+CK(check_bogus_irqrestore)
+CK(check_zero_to_err_ptr)
+CK(check_freeing_devm)
+CK(check_off_by_one_relative)
+CK(check_capable)
+CK(check_ns_capable)
+CK(check_test_bit)
+CK(check_dma_mapping_error)
+CK(check_nospec)
+CK(check_nospec_barrier)
+CK(check_spectre)
+CK(check_implicit_dependencies)
+
+/* wine specific stuff */
+CK(check_wine_filehandles)
+CK(check_wine_WtoA)
+
+/* illumos specific */
+CK(check_all_func_returns)
+
+#include "check_list_local.h"
+
+CK(register_scope)
+CK(register_stored_conditions)
+CK(register_stored_conditions_links)
+CK(register_sval)
+CK(register_buf_size_late)
+CK(register_smatch_extra_late)
+CK(register_assigned_expr) /* This is used by smatch_extra.c so it has to come really late */
+CK(register_assigned_expr_links)
+CK(register_modification_hooks_late)  /* has to come after smatch_extra */
+CK(register_comparison_late) /* has to come after modification_hooks_late */
+CK(register_function_hooks)
+CK(check_kernel)  /* this is overwriting stuff from smatch_extra_late */
+CK(check_wine)
+CK(register_returns)
+
+#ifdef __undo_CK_def
+#undef CK
+#undef __undo_CK_def
+#endif
diff --git a/usr/src/tools/smatch/src/check_locking.c b/usr/src/tools/smatch/src/check_locking.c
new file mode 100644
index 0000000000..06cc7a597a
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_locking.c
@@ -0,0 +1,969 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This test checks that locks are held the same across all returns.
+ *
+ * Of course, some functions are designed to only hold the locks on success.
+ * Oh well... We can rewrite it later if we want.
+ *
+ * The list of wine locking functions came from an earlier script written
+ * by Michael Stefaniuc.
+ *
+ */
+
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static int func_has_transition;
+
+STATE(locked);
+STATE(start_state);
+STATE(unlocked);
+STATE(impossible);
+
+enum action {
+	LOCK,
+	UNLOCK,
+};
+
+enum return_type {
+	ret_any,
+	ret_non_zero,
+	ret_zero,
+	ret_negative,
+	ret_positive,
+};
+
+#define RETURN_VAL -1
+#define NO_ARG -2
+
+struct lock_info {
+	const char *function;
+	enum action action;
+	const char *name;
+	int arg;
+	enum return_type return_type;
+};
+
+static struct lock_info wine_lock_table[] = {
+	{"create_window_handle", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
+	{"WIN_GetPtr", LOCK, "create_window_handle", RETURN_VAL, ret_non_zero},
+	{"WIN_ReleasePtr", UNLOCK, "create_window_handle", 0, ret_any},
+	{"EnterCriticalSection", LOCK, "CriticalSection", 0, ret_any},
+	{"LeaveCriticalSection", UNLOCK, "CriticalSection", 0, ret_any},
+	{"RtlEnterCriticalSection", LOCK, "RtlCriticalSection", 0, ret_any},
+	{"RtlLeaveCriticalSection", UNLOCK, "RtlCriticalSection", 0, ret_any},
+	{"GDI_GetObjPtr", LOCK, "GDI_Get", 0, ret_non_zero},
+	{"GDI_ReleaseObj", UNLOCK, "GDI_Get", 0, ret_any},
+	{"LdrLockLoaderLock", LOCK, "LdrLockLoaderLock", 2, ret_any},
+	{"LdrUnlockLoaderLock", UNLOCK, "LdrLockLoaderLock", 1, ret_any},
+	{"_lock", LOCK, "_lock", 0, ret_any},
+	{"_unlock", UNLOCK, "_lock", 0, ret_any},
+	{"msiobj_lock", LOCK, "msiobj_lock", 0, ret_any},
+	{"msiobj_unlock", UNLOCK, "msiobj_lock", 0, ret_any},
+	{"RtlAcquirePebLock", LOCK, "PebLock", NO_ARG, ret_any},
+	{"RtlReleasePebLock", UNLOCK, "PebLock", NO_ARG, ret_any},
+	{"server_enter_uninterrupted_section", LOCK, "server_uninterrupted_section", 0, ret_any},
+	{"server_leave_uninterrupted_section", UNLOCK, "server_uninterrupted_section", 0, ret_any},
+	{"RtlLockHeap", LOCK, "RtlLockHeap", 0, ret_any},
+	{"RtlUnlockHeap", UNLOCK, "RtlLockHeap", 0, ret_any},
+	{"_EnterSysLevel", LOCK, "SysLevel", 0, ret_any},
+	{"_LeaveSysLevel", UNLOCK, "SysLevel", 0, ret_any},
+	{"USER_Lock", LOCK, "USER_Lock", NO_ARG, ret_any},
+	{"USER_Unlock", UNLOCK, "USER_Lock", NO_ARG, ret_any},
+	{"wine_tsx11_lock", LOCK, "wine_tsx11_lock", NO_ARG, ret_any},
+	{"wine_tsx11_unlock", UNLOCK, "wine_tsx11_lock", NO_ARG, ret_any},
+	{"wine_tsx11_lock_ptr", LOCK, "wine_tsx11_lock_ptr", NO_ARG, ret_any},
+	{"wine_tsx11_unlock_ptr", UNLOCK, "wine_tsx11_lock_ptr", NO_ARG, ret_any},
+	{"wined3d_mutex_lock", LOCK, "wined3d_mutex_lock", NO_ARG, ret_any},
+	{"wined3d_mutex_unlock", UNLOCK, "wined3d_mutex_lock", NO_ARG, ret_any},
+	{"X11DRV_DIB_Lock", LOCK, "X11DRV_DIB_Lock", 0, ret_any},
+	{"X11DRV_DIB_Unlock", UNLOCK, "X11DRV_DIB_Lock", 0, ret_any},
+};
+
+static struct lock_info kernel_lock_table[] = {
+	{"lock_kernel",   LOCK,   "BKL", NO_ARG, ret_any},
+	{"unlock_kernel", UNLOCK, "BKL", NO_ARG, ret_any},
+
+	{"spin_lock",                  LOCK,   "spin_lock", 0, ret_any},
+	{"spin_unlock",                UNLOCK, "spin_lock", 0, ret_any},
+	{"spin_lock_nested",           LOCK,   "spin_lock", 0, ret_any},
+	{"_spin_lock",                 LOCK,   "spin_lock", 0, ret_any},
+	{"_spin_unlock",               UNLOCK, "spin_lock", 0, ret_any},
+	{"_spin_lock_nested",          LOCK,   "spin_lock", 0, ret_any},
+	{"__spin_lock",                LOCK,   "spin_lock", 0, ret_any},
+	{"__spin_unlock",              UNLOCK, "spin_lock", 0, ret_any},
+	{"__spin_lock_nested",         LOCK,   "spin_lock", 0, ret_any},
+	{"raw_spin_lock",              LOCK,   "spin_lock", 0, ret_any},
+	{"raw_spin_unlock",            UNLOCK, "spin_lock", 0, ret_any},
+	{"_raw_spin_lock",             LOCK,   "spin_lock", 0, ret_any},
+	{"_raw_spin_lock_nested",      LOCK,   "spin_lock", 0, ret_any},
+	{"_raw_spin_unlock",           UNLOCK, "spin_lock", 0, ret_any},
+	{"__raw_spin_lock",            LOCK,   "spin_lock", 0, ret_any},
+	{"__raw_spin_unlock",          UNLOCK, "spin_lock", 0, ret_any},
+
+	{"spin_lock_irq",              LOCK,   "spin_lock", 0, ret_any},
+	{"spin_unlock_irq",            UNLOCK, "spin_lock", 0, ret_any},
+	{"_spin_lock_irq",             LOCK,   "spin_lock", 0, ret_any},
+	{"_spin_unlock_irq",           UNLOCK, "spin_lock", 0, ret_any},
+	{"__spin_lock_irq",            LOCK,   "spin_lock", 0, ret_any},
+	{"__spin_unlock_irq",          UNLOCK, "spin_lock", 0, ret_any},
+	{"_raw_spin_lock_irq",         LOCK,   "spin_lock", 0, ret_any},
+	{"_raw_spin_unlock_irq",       UNLOCK, "spin_lock", 0, ret_any},
+	{"__raw_spin_unlock_irq",      UNLOCK, "spin_lock", 0, ret_any},
+	{"spin_lock_irqsave",          LOCK,   "spin_lock", 0, ret_any},
+	{"spin_unlock_irqrestore",     UNLOCK, "spin_lock", 0, ret_any},
+	{"_spin_lock_irqsave",         LOCK,   "spin_lock", 0, ret_any},
+	{"_spin_unlock_irqrestore",    UNLOCK, "spin_lock", 0, ret_any},
+	{"__spin_lock_irqsave",        LOCK,   "spin_lock", 0, ret_any},
+	{"__spin_unlock_irqrestore",   UNLOCK, "spin_lock", 0, ret_any},
+	{"_raw_spin_lock_irqsave",     LOCK,   "spin_lock", 0, ret_any},
+	{"_raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
+	{"__raw_spin_lock_irqsave",    LOCK,   "spin_lock", 0, ret_any},
+	{"__raw_spin_unlock_irqrestore", UNLOCK, "spin_lock", 0, ret_any},
+	{"spin_lock_irqsave_nested",   LOCK,   "spin_lock", 0, ret_any},
+	{"_spin_lock_irqsave_nested",  LOCK,   "spin_lock", 0, ret_any},
+	{"__spin_lock_irqsave_nested", LOCK,   "spin_lock", 0, ret_any},
+	{"_raw_spin_lock_irqsave_nested", LOCK, "spin_lock", 0, ret_any},
+	{"spin_lock_bh",               LOCK,   "spin_lock", 0, ret_any},
+	{"spin_unlock_bh",             UNLOCK, "spin_lock", 0, ret_any},
+	{"_spin_lock_bh",              LOCK,   "spin_lock", 0, ret_any},
+	{"_spin_unlock_bh",            UNLOCK, "spin_lock", 0, ret_any},
+	{"__spin_lock_bh",             LOCK,   "spin_lock", 0, ret_any},
+	{"__spin_unlock_bh",           UNLOCK, "spin_lock", 0, ret_any},
+
+	{"spin_trylock",               LOCK,   "spin_lock", 0, ret_non_zero},
+	{"_spin_trylock",              LOCK,   "spin_lock", 0, ret_non_zero},
+	{"__spin_trylock",             LOCK,   "spin_lock", 0, ret_non_zero},
+	{"raw_spin_trylock",           LOCK,   "spin_lock", 0, ret_non_zero},
+	{"_raw_spin_trylock",          LOCK,   "spin_lock", 0, ret_non_zero},
+	{"spin_trylock_irq",           LOCK,   "spin_lock", 0, ret_non_zero},
+	{"spin_trylock_irqsave",       LOCK,   "spin_lock", 0, ret_non_zero},
+	{"spin_trylock_bh",            LOCK,   "spin_lock", 0, ret_non_zero},
+	{"_spin_trylock_bh",           LOCK,   "spin_lock", 0, ret_non_zero},
+	{"__spin_trylock_bh",          LOCK,   "spin_lock", 0, ret_non_zero},
+	{"__raw_spin_trylock",         LOCK,   "spin_lock", 0, ret_non_zero},
+	{"_atomic_dec_and_lock",       LOCK,   "spin_lock", 1, ret_non_zero},
+
+	{"read_lock",                 LOCK,   "read_lock", 0, ret_any},
+	{"read_unlock",               UNLOCK, "read_lock", 0, ret_any},
+	{"_read_lock",                LOCK,   "read_lock", 0, ret_any},
+	{"_read_unlock",              UNLOCK, "read_lock", 0, ret_any},
+	{"__read_lock",               LOCK,   "read_lock", 0, ret_any},
+	{"__read_unlock",             UNLOCK, "read_lock", 0, ret_any},
+	{"_raw_read_lock",            LOCK,   "read_lock", 0, ret_any},
+	{"_raw_read_unlock",          UNLOCK, "read_lock", 0, ret_any},
+	{"__raw_read_lock",           LOCK,   "read_lock", 0, ret_any},
+	{"__raw_read_unlock",         UNLOCK, "read_lock", 0, ret_any},
+	{"read_lock_irq",             LOCK,   "read_lock", 0, ret_any},
+	{"read_unlock_irq" ,          UNLOCK, "read_lock", 0, ret_any},
+	{"_read_lock_irq",            LOCK,   "read_lock", 0, ret_any},
+	{"_read_unlock_irq",          UNLOCK, "read_lock", 0, ret_any},
+	{"__read_lock_irq",           LOCK,   "read_lock", 0, ret_any},
+	{"__read_unlock_irq",         UNLOCK, "read_lock", 0, ret_any},
+	{"read_lock_irqsave",         LOCK,   "read_lock", 0, ret_any},
+	{"read_unlock_irqrestore",    UNLOCK, "read_lock", 0, ret_any},
+	{"_read_lock_irqsave",        LOCK,   "read_lock", 0, ret_any},
+	{"_read_unlock_irqrestore",   UNLOCK, "read_lock", 0, ret_any},
+	{"__read_lock_irqsave",       LOCK,   "read_lock", 0, ret_any},
+	{"__read_unlock_irqrestore",  UNLOCK, "read_lock", 0, ret_any},
+	{"read_lock_bh",              LOCK,   "read_lock", 0, ret_any},
+	{"read_unlock_bh",            UNLOCK, "read_lock", 0, ret_any},
+	{"_read_lock_bh",             LOCK,   "read_lock", 0, ret_any},
+	{"_read_unlock_bh",           UNLOCK, "read_lock", 0, ret_any},
+	{"__read_lock_bh",            LOCK,   "read_lock", 0, ret_any},
+	{"__read_unlock_bh",          UNLOCK, "read_lock", 0, ret_any},
+	{"_raw_read_lock_bh",         LOCK,   "read_lock", 0, ret_any},
+	{"_raw_read_unlock_bh",       UNLOCK, "read_lock", 0, ret_any},
+	{"__raw_read_lock_bh",        LOCK,   "read_lock", 0, ret_any},
+	{"__raw_read_unlock_bh",      UNLOCK, "read_lock", 0, ret_any},
+
+	{"generic__raw_read_trylock", LOCK,   "read_lock", 0, ret_non_zero},
+	{"read_trylock",              LOCK,   "read_lock", 0, ret_non_zero},
+	{"_read_trylock",             LOCK,   "read_lock", 0, ret_non_zero},
+	{"raw_read_trylock",          LOCK,   "read_lock", 0, ret_non_zero},
+	{"_raw_read_trylock",         LOCK,   "read_lock", 0, ret_non_zero},
+	{"__raw_read_trylock",        LOCK,   "read_lock", 0, ret_non_zero},
+	{"__read_trylock",            LOCK,   "read_lock", 0, ret_non_zero},
+
+	{"write_lock",                LOCK,   "write_lock", 0, ret_any},
+	{"write_unlock",              UNLOCK, "write_lock", 0, ret_any},
+	{"_write_lock",               LOCK,   "write_lock", 0, ret_any},
+	{"_write_unlock",             UNLOCK, "write_lock", 0, ret_any},
+	{"__write_lock",              LOCK,   "write_lock", 0, ret_any},
+	{"__write_unlock",            UNLOCK, "write_lock", 0, ret_any},
+	{"write_lock_irq",            LOCK,   "write_lock", 0, ret_any},
+	{"write_unlock_irq",          UNLOCK, "write_lock", 0, ret_any},
+	{"_write_lock_irq",           LOCK,   "write_lock", 0, ret_any},
+	{"_write_unlock_irq",         UNLOCK, "write_lock", 0, ret_any},
+	{"__write_lock_irq",          LOCK,   "write_lock", 0, ret_any},
+	{"__write_unlock_irq",        UNLOCK, "write_lock", 0, ret_any},
+	{"write_lock_irqsave",        LOCK,   "write_lock", 0, ret_any},
+	{"write_unlock_irqrestore",   UNLOCK, "write_lock", 0, ret_any},
+	{"_write_lock_irqsave",       LOCK,   "write_lock", 0, ret_any},
+	{"_write_unlock_irqrestore",  UNLOCK, "write_lock", 0, ret_any},
+	{"__write_lock_irqsave",      LOCK,   "write_lock", 0, ret_any},
+	{"__write_unlock_irqrestore", UNLOCK, "write_lock", 0, ret_any},
+	{"write_lock_bh",             LOCK,   "write_lock", 0, ret_any},
+	{"write_unlock_bh",           UNLOCK, "write_lock", 0, ret_any},
+	{"_write_lock_bh",            LOCK,   "write_lock", 0, ret_any},
+	{"_write_unlock_bh",          UNLOCK, "write_lock", 0, ret_any},
+	{"__write_lock_bh",           LOCK,   "write_lock", 0, ret_any},
+	{"__write_unlock_bh",         UNLOCK, "write_lock", 0, ret_any},
+	{"_raw_write_lock",           LOCK,   "write_lock", 0, ret_any},
+	{"__raw_write_lock",          LOCK,   "write_lock", 0, ret_any},
+	{"_raw_write_unlock",         UNLOCK, "write_lock", 0, ret_any},
+	{"__raw_write_unlock",        UNLOCK, "write_lock", 0, ret_any},
+
+	{"write_trylock",             LOCK,   "write_lock", 0, ret_non_zero},
+	{"_write_trylock",            LOCK,   "write_lock", 0, ret_non_zero},
+	{"raw_write_trylock",         LOCK,   "write_lock", 0, ret_non_zero},
+	{"_raw_write_trylock",        LOCK,   "write_lock", 0, ret_non_zero},
+	{"__write_trylock",           LOCK,   "write_lock", 0, ret_non_zero},
+	{"__raw_write_trylock",       LOCK,   "write_lock", 0, ret_non_zero},
+
+	{"down",               LOCK,   "sem", 0, ret_any},
+	{"up",                 UNLOCK, "sem", 0, ret_any},
+	{"down_trylock",       LOCK,   "sem", 0, ret_zero},
+	{"down_timeout",       LOCK,   "sem", 0, ret_zero},
+	{"down_interruptible", LOCK,   "sem", 0, ret_zero},
+
+	{"mutex_lock",                      LOCK,   "mutex", 0, ret_any},
+	{"mutex_unlock",                    UNLOCK, "mutex", 0, ret_any},
+	{"mutex_lock_nested",               LOCK,   "mutex", 0, ret_any},
+
+	{"mutex_lock_interruptible",        LOCK,   "mutex", 0, ret_zero},
+	{"mutex_lock_interruptible_nested", LOCK,   "mutex", 0, ret_zero},
+	{"mutex_lock_killable",             LOCK,   "mutex", 0, ret_zero},
+	{"mutex_lock_killable_nested",      LOCK,   "mutex", 0, ret_zero},
+
+	{"mutex_trylock",                   LOCK,   "mutex", 0, ret_non_zero},
+
+	{"raw_local_irq_disable", LOCK,   "irq", NO_ARG, ret_any},
+	{"raw_local_irq_enable",  UNLOCK, "irq", NO_ARG, ret_any},
+	{"spin_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
+	{"spin_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
+	{"_spin_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
+	{"_spin_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
+	{"__spin_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
+	{"__spin_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
+	{"_raw_spin_lock_irq",    LOCK,   "irq", NO_ARG, ret_any},
+	{"_raw_spin_unlock_irq",  UNLOCK, "irq", NO_ARG, ret_any},
+	{"__raw_spin_unlock_irq", UNLOCK, "irq", NO_ARG, ret_any},
+	{"spin_trylock_irq",      LOCK,   "irq", NO_ARG, ret_non_zero},
+	{"read_lock_irq",         LOCK,   "irq", NO_ARG, ret_any},
+	{"read_unlock_irq",       UNLOCK, "irq", NO_ARG, ret_any},
+	{"_read_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
+	{"_read_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
+	{"__read_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
+	{"__read_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
+	{"write_lock_irq",        LOCK,   "irq", NO_ARG, ret_any},
+	{"write_unlock_irq",      UNLOCK, "irq", NO_ARG, ret_any},
+	{"_write_lock_irq",       LOCK,   "irq", NO_ARG, ret_any},
+	{"_write_unlock_irq",     UNLOCK, "irq", NO_ARG, ret_any},
+	{"__write_lock_irq",      LOCK,   "irq", NO_ARG, ret_any},
+	{"__write_unlock_irq",    UNLOCK, "irq", NO_ARG, ret_any},
+
+	{"arch_local_irq_save",        LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"arch_local_irq_restore",     UNLOCK, "irqsave", 0, ret_any},
+	{"__raw_local_irq_save",       LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"raw_local_irq_restore",      UNLOCK, "irqsave", 0, ret_any},
+	{"spin_lock_irqsave_nested",   LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"spin_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"spin_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
+	{"spin_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
+	{"_spin_lock_irqsave_nested",  LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"_spin_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"_spin_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
+	{"_spin_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
+	{"__spin_lock_irqsave_nested", LOCK,   "irqsave", 1, ret_any},
+	{"__spin_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
+	{"__spin_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
+	{"_raw_spin_lock_irqsave",     LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"_raw_spin_lock_irqsave",     LOCK,   "irqsave", 1, ret_any},
+	{"_raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
+	{"__raw_spin_lock_irqsave",    LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"__raw_spin_unlock_irqrestore",UNLOCK, "irqsave", 1, ret_any},
+	{"_raw_spin_lock_irqsave_nested", LOCK, "irqsave", RETURN_VAL, ret_any},
+	{"spin_trylock_irqsave",       LOCK,   "irqsave", 1, ret_non_zero},
+	{"read_lock_irqsave",          LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"read_lock_irqsave",          LOCK,   "irqsave", 1, ret_any},
+	{"read_unlock_irqrestore",     UNLOCK, "irqsave", 1, ret_any},
+	{"_read_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"_read_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
+	{"_read_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
+	{"__read_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"__read_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
+	{"write_lock_irqsave",         LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"write_lock_irqsave",         LOCK,   "irqsave", 1, ret_any},
+	{"write_unlock_irqrestore",    UNLOCK, "irqsave", 1, ret_any},
+	{"_write_lock_irqsave",        LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"_write_lock_irqsave",        LOCK,   "irqsave", 1, ret_any},
+	{"_write_unlock_irqrestore",   UNLOCK, "irqsave", 1, ret_any},
+	{"__write_lock_irqsave",       LOCK,   "irqsave", RETURN_VAL, ret_any},
+	{"__write_unlock_irqrestore",  UNLOCK, "irqsave", 1, ret_any},
+
+	{"local_bh_disable",	LOCK,	"bottom_half", NO_ARG, ret_any},
+	{"_local_bh_disable",	LOCK,	"bottom_half", NO_ARG, ret_any},
+	{"__local_bh_disable",	LOCK,	"bottom_half", NO_ARG, ret_any},
+	{"local_bh_enable",	UNLOCK,	"bottom_half", NO_ARG, ret_any},
+	{"_local_bh_enable",	UNLOCK,	"bottom_half", NO_ARG, ret_any},
+	{"__local_bh_enable",	UNLOCK,	"bottom_half", NO_ARG, ret_any},
+	{"spin_lock_bh",        LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"spin_unlock_bh",      UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"_spin_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"_spin_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"__spin_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"__spin_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"read_lock_bh",        LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"read_unlock_bh",      UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"_read_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"_read_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"__read_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"__read_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"_raw_read_lock_bh",   LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"_raw_read_unlock_bh", UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"write_lock_bh",       LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"write_unlock_bh",     UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"_write_lock_bh",      LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"_write_unlock_bh",    UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"__write_lock_bh",     LOCK,   "bottom_half", NO_ARG, ret_any},
+	{"__write_unlock_bh",   UNLOCK, "bottom_half", NO_ARG, ret_any},
+	{"spin_trylock_bh",     LOCK,   "bottom_half", NO_ARG, ret_non_zero},
+	{"_spin_trylock_bh",    LOCK,   "bottom_half", NO_ARG, ret_non_zero},
+	{"__spin_trylock_bh",   LOCK,   "bottom_half", NO_ARG, ret_non_zero},
+
+	{"ffs_mutex_lock",        LOCK,   "mutex", 0, ret_zero},
+};
+
+static struct lock_info *lock_table;
+
+static struct tracker_list *starts_locked;
+static struct tracker_list *starts_unlocked;
+
+struct locks_on_return {
+	int line;
+	struct tracker_list *locked;
+	struct tracker_list *unlocked;
+	struct tracker_list *impossible;
+	struct range_list *return_values;
+};
+DECLARE_PTR_LIST(return_list, struct locks_on_return);
+static struct return_list *all_returns;
+
+static char *make_full_name(const char *lock, const char *var)
+{
+	static char tmp_buf[512];
+
+	snprintf(tmp_buf, sizeof(tmp_buf), "%s:%s", lock, var);
+	remove_parens(tmp_buf);
+	return alloc_string(tmp_buf);
+}
+
+static struct expression *remove_spinlock_check(struct expression *expr)
+{
+	if (expr->type != EXPR_CALL)
+		return expr;
+	if (expr->fn->type != EXPR_SYMBOL)
+		return expr;
+	if (strcmp(expr->fn->symbol_name->name, "spinlock_check"))
+		return expr;
+	expr = get_argument_from_call_expr(expr->args, 0);
+	return expr;
+}
+
+static char *get_full_name(struct expression *expr, int index)
+{
+	struct expression *arg;
+	char *name = NULL;
+	char *full_name = NULL;
+	struct lock_info *lock = &lock_table[index];
+
+	if (lock->arg == RETURN_VAL) {
+		name = expr_to_var(expr->left);
+		full_name = make_full_name(lock->name, name);
+	} else if (lock->arg == NO_ARG) {
+		full_name = make_full_name(lock->name, "");
+	} else {
+		arg = get_argument_from_call_expr(expr->args, lock->arg);
+		if (!arg)
+			goto free;
+		arg = remove_spinlock_check(arg);
+		name = expr_to_str(arg);
+		if (!name)
+			goto free;
+		full_name = make_full_name(lock->name, name);
+	}
+free:
+	free_string(name);
+	return full_name;
+}
+
+static struct smatch_state *get_start_state(struct sm_state *sm)
+{
+	int is_locked = 0;
+	int is_unlocked = 0;
+
+	if (in_tracker_list(starts_locked, my_id, sm->name, sm->sym))
+		is_locked = 1;
+	if (in_tracker_list(starts_unlocked, my_id, sm->name, sm->sym))
+		is_unlocked = 1;
+	if (is_locked && is_unlocked)
+		return &undefined;
+	if (is_locked)
+		return &locked;
+	if (is_unlocked)
+		return &unlocked;
+	return &undefined;
+}
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	return &start_state;
+}
+
+static void pre_merge_hook(struct sm_state *sm)
+{
+	if (is_impossible_path())
+		set_state(my_id, sm->name, sm->sym, &impossible);
+}
+
+static void do_lock(const char *name)
+{
+	struct sm_state *sm;
+
+	if (__inline_fn)
+		return;
+
+	sm = get_sm_state(my_id, name, NULL);
+	if (!sm)
+		add_tracker(&starts_unlocked, my_id, name, NULL);
+	if (sm && slist_has_state(sm->possible, &locked) &&
+			strcmp(name, "bottom_half:") != 0)
+		sm_error("double lock '%s'", name);
+	if (sm)
+		func_has_transition = TRUE;
+	set_state(my_id, name, NULL, &locked);
+}
+
+static void do_lock_failed(const char *name)
+{
+	struct sm_state *sm;
+
+	if (__inline_fn)
+		return;
+
+	sm = get_sm_state(my_id, name, NULL);
+	if (!sm)
+		add_tracker(&starts_unlocked, my_id, name, NULL);
+	set_state(my_id, name, NULL, &unlocked);
+}
+
+static void do_unlock(const char *name)
+{
+	struct sm_state *sm;
+
+	if (__inline_fn)
+		return;
+	if (__path_is_null())
+		return;
+	sm = get_sm_state(my_id, name, NULL);
+	if (!sm)
+		add_tracker(&starts_locked, my_id, name, NULL);
+	if (sm && slist_has_state(sm->possible, &unlocked) &&
+			strcmp(name, "bottom_half:") != 0)
+		sm_error("double unlock '%s'", name);
+	if (sm)
+		func_has_transition = TRUE;
+	set_state(my_id, name, NULL, &unlocked);
+}
+
+static void match_lock_held(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *_index)
+{
+	int index = PTR_INT(_index);
+	char *lock_name;
+	struct lock_info *lock = &lock_table[index];
+
+	if (lock->arg == NO_ARG) {
+		lock_name = get_full_name(NULL, index);
+	} else if (lock->arg == RETURN_VAL) {
+		if (!assign_expr)
+			return;
+		lock_name = get_full_name(assign_expr, index);
+	} else {
+		lock_name = get_full_name(call_expr, index);
+	}
+	if (!lock_name)
+		return;
+	do_lock(lock_name);
+	free_string(lock_name);
+}
+
+static void match_lock_failed(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *_index)
+{
+	int index = PTR_INT(_index);
+	char *lock_name;
+	struct lock_info *lock = &lock_table[index];
+
+	if (lock->arg == NO_ARG) {
+		lock_name = get_full_name(NULL, index);
+	} else if (lock->arg == RETURN_VAL) {
+		if (!assign_expr)
+			return;
+		lock_name = get_full_name(assign_expr, index);
+	} else {
+		lock_name = get_full_name(call_expr, index);
+	}
+	if (!lock_name)
+		return;
+	do_lock_failed(lock_name);
+	free_string(lock_name);
+}
+
+static void match_returns_locked(const char *fn, struct expression *expr,
+				      void *_index)
+{
+	char *full_name = NULL;
+	int index = PTR_INT(_index);
+	struct lock_info *lock = &lock_table[index];
+
+	if (lock->arg != RETURN_VAL)
+		return;
+	full_name = get_full_name(expr, index);
+	do_lock(full_name);
+}
+
+static void match_lock_unlock(const char *fn, struct expression *expr, void *_index)
+{
+	char *full_name = NULL;
+	int index = PTR_INT(_index);
+	struct lock_info *lock = &lock_table[index];
+
+	if (__inline_fn)
+		return;
+
+	full_name = get_full_name(expr, index);
+	if (!full_name)
+		return;
+	if (lock->action == LOCK)
+		do_lock(full_name);
+	else
+		do_unlock(full_name);
+	free_string(full_name);
+}
+
+static struct locks_on_return *alloc_return(struct expression *expr)
+{
+	struct locks_on_return *ret;
+
+	ret = malloc(sizeof(*ret));
+	if (!get_implied_rl(expr, &ret->return_values))
+		ret->return_values = NULL;
+	ret->line = get_lineno();
+	ret->locked = NULL;
+	ret->unlocked = NULL;
+	ret->impossible = NULL;
+	return ret;
+}
+
+static int check_possible(struct sm_state *sm)
+{
+	struct sm_state *tmp;
+	int islocked = 0;
+	int isunlocked = 0;
+	int undef = 0;
+
+	if (!option_spammy)
+		return 0;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->state == &locked)
+			islocked = 1;
+		if (tmp->state == &unlocked)
+			isunlocked = 1;
+		if (tmp->state == &start_state) {
+			struct smatch_state *s;
+
+			s = get_start_state(tmp);
+			if (s == &locked)
+				islocked = 1;
+			else if (s == &unlocked)
+				isunlocked = 1;
+			else
+				undef = 1;
+		}
+		if (tmp->state == &undefined)
+			undef = 1;  // i don't think this is possible any more.
+	} END_FOR_EACH_PTR(tmp);
+	if ((islocked && isunlocked) || undef) {
+		sm_warning("'%s' is sometimes locked here and sometimes unlocked.", sm->name);
+		return 1;
+	}
+	return 0;
+}
+
+static struct position warned_pos;
+
+static void match_return(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct locks_on_return *ret;
+	struct stree *stree;
+	struct sm_state *tmp;
+
+	if (!final_pass)
+		return;
+	if (__inline_fn)
+		return;
+
+	if (expr && cmp_pos(expr->pos, warned_pos) == 0)
+		return;
+
+	ret = alloc_return(expr);
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(my_id, stree, tmp) {
+		if (tmp->state == &locked) {
+			add_tracker(&ret->locked, tmp->owner, tmp->name,
+				tmp->sym);
+		} else if (tmp->state == &unlocked) {
+			add_tracker(&ret->unlocked, tmp->owner, tmp->name,
+				tmp->sym);
+		} else if (tmp->state == &start_state) {
+			struct smatch_state *s;
+
+			s = get_start_state(tmp);
+			if (s == &locked)
+				add_tracker(&ret->locked, tmp->owner, tmp->name, 
+					    tmp->sym);
+			if (s == &unlocked)
+				add_tracker(&ret->unlocked, tmp->owner,tmp->name,
+					     tmp->sym);
+		} else if (tmp->state == &impossible) {
+			add_tracker(&ret->impossible, tmp->owner, tmp->name,
+				    tmp->sym);
+		} else {
+			if (check_possible(tmp)) {
+				if (expr)
+					warned_pos = expr->pos;
+			}
+		}
+	} END_FOR_EACH_SM(tmp);
+	add_ptr_list(&all_returns, ret);
+}
+
+static void add_line(struct range_list **rl, int line)
+{
+	sval_t sval = sval_type_val(&int_ctype, line);
+
+	add_range(rl, sval, sval);
+}
+
+static int line_printed(struct range_list *rl, int line)
+{
+	sval_t sval = sval_type_val(&int_ctype, line);
+
+	return rl_has_sval(rl, sval);
+}
+
+static void print_inconsistent_returns(struct tracker *lock,
+				struct smatch_state *start)
+{
+	struct locks_on_return *tmp;
+	struct range_list *printed = NULL;
+	int i;
+
+	sm_warning("inconsistent returns '%s'.", lock->name);
+	sm_printf("  Locked on:   ");
+
+	i = 0;
+	FOR_EACH_PTR(all_returns, tmp) {
+		if (line_printed(printed, tmp->line))
+			continue;
+		if (in_tracker_list(tmp->unlocked, lock->owner, lock->name, lock->sym))
+			continue;
+		if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym)) {
+			if (i++)
+				sm_printf("               ");
+			sm_printf("line %d\n", tmp->line);
+			add_line(&printed, tmp->line);
+			continue;
+		}
+		if (start == &locked) {
+			if (i++)
+				sm_printf("               ");
+			sm_printf("line %d\n", tmp->line);
+			add_line(&printed, tmp->line);
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+	sm_printf("  Unlocked on: ");
+	printed = NULL;
+	i = 0;
+	FOR_EACH_PTR(all_returns, tmp) {
+		if (line_printed(printed, tmp->line))
+			continue;
+		if (in_tracker_list(tmp->unlocked, lock->owner, lock->name, lock->sym)) {
+			if (i++)
+				sm_printf("               ");
+			sm_printf("line %d\n", tmp->line);
+			add_line(&printed, tmp->line);
+			continue;
+		}
+		if (in_tracker_list(tmp->locked, lock->owner, lock->name, lock->sym))
+			continue;
+		if (start == &unlocked) {
+			if (i++)
+				sm_printf("               ");
+			sm_printf("line %d\n", tmp->line);
+			add_line(&printed, tmp->line);
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static int matches_return_type(struct range_list *rl, enum return_type type)
+{
+	sval_t zero_sval = ll_to_sval(0);
+
+	/* All these double negatives are super ugly!  */
+
+	switch (type) {
+	case ret_zero:
+		return !possibly_true_rl(rl, SPECIAL_NOTEQUAL, alloc_rl(zero_sval, zero_sval));
+	case ret_non_zero:
+		return !possibly_true_rl(rl, SPECIAL_EQUAL, alloc_rl(zero_sval, zero_sval));
+	case ret_negative:
+		return !possibly_true_rl(rl, SPECIAL_GTE, alloc_rl(zero_sval, zero_sval));
+	case ret_positive:
+		return !possibly_true_rl(rl, '<', alloc_rl(zero_sval, zero_sval));
+	case ret_any:
+	default:
+		return 1;
+	}
+}
+
+static int match_held(struct tracker *lock, struct locks_on_return *this_return, struct smatch_state *start)
+{
+	if (in_tracker_list(this_return->impossible, lock->owner, lock->name, lock->sym))
+		return 0;
+	if (in_tracker_list(this_return->unlocked, lock->owner, lock->name, lock->sym))
+		return 0;
+	if (in_tracker_list(this_return->locked, lock->owner, lock->name, lock->sym))
+		return 1;
+	if (start == &unlocked)
+		return 0;
+	return 1;
+}
+
+static int match_released(struct tracker *lock, struct locks_on_return *this_return, struct smatch_state *start)
+{
+	if (in_tracker_list(this_return->impossible, lock->owner, lock->name, lock->sym))
+		return 0;
+	if (in_tracker_list(this_return->unlocked, lock->owner, lock->name, lock->sym))
+		return 1;
+	if (in_tracker_list(this_return->locked, lock->owner, lock->name, lock->sym))
+		return 0;
+	if (start == &unlocked)
+		return 1;
+	return 0;
+}
+
+static int held_on_return(struct tracker *lock, struct smatch_state *start, enum return_type type)
+{
+	struct locks_on_return *tmp;
+
+	FOR_EACH_PTR(all_returns, tmp) {
+		if (!matches_return_type(tmp->return_values, type))
+			continue;
+		if (match_held(lock, tmp, start))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static int released_on_return(struct tracker *lock, struct smatch_state *start, enum return_type type)
+{
+	struct locks_on_return *tmp;
+
+	FOR_EACH_PTR(all_returns, tmp) {
+		if (!matches_return_type(tmp->return_values, type))
+			continue;
+		if (match_released(lock, tmp, start))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static void check_returns_consistently(struct tracker *lock,
+				struct smatch_state *start)
+{
+	struct symbol *type;
+
+	if (!held_on_return(lock, start, ret_any) ||
+	    !released_on_return(lock, start, ret_any))
+		return;
+
+	if (held_on_return(lock, start, ret_zero) &&
+	    !held_on_return(lock, start, ret_non_zero))
+		return;
+
+	if (held_on_return(lock, start, ret_positive) &&
+	    !held_on_return(lock, start, ret_zero))
+		return;
+
+	if (held_on_return(lock, start, ret_positive) &&
+	    !held_on_return(lock, start, ret_negative))
+		return;
+
+	type = cur_func_return_type();
+	if (type && type->type == SYM_PTR) {
+		if (held_on_return(lock, start, ret_non_zero) &&
+		    !held_on_return(lock, start, ret_zero))
+			return;
+	}
+
+	print_inconsistent_returns(lock, start);
+}
+
+static void check_consistency(struct symbol *sym)
+{
+	struct tracker *tmp;
+
+	FOR_EACH_PTR(starts_locked, tmp) {
+		if (in_tracker_list(starts_unlocked, tmp->owner, tmp->name,
+					tmp->sym))
+			sm_error("locking inconsistency.  We assume "
+				   "'%s' is both locked and unlocked at the "
+				   "start.",
+				tmp->name);
+	} END_FOR_EACH_PTR(tmp);
+
+	FOR_EACH_PTR(starts_locked, tmp) {
+		check_returns_consistently(tmp, &locked);
+	} END_FOR_EACH_PTR(tmp);
+
+	FOR_EACH_PTR(starts_unlocked, tmp) {
+		check_returns_consistently(tmp, &unlocked);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void clear_lists(void)
+{
+	struct locks_on_return *tmp;
+
+	func_has_transition = FALSE;
+
+	free_trackers_and_list(&starts_locked);
+	free_trackers_and_list(&starts_unlocked);
+
+	FOR_EACH_PTR(all_returns, tmp) {
+		free_trackers_and_list(&tmp->locked);
+		free_trackers_and_list(&tmp->unlocked);
+		free(tmp);
+	} END_FOR_EACH_PTR(tmp);
+	__free_ptr_list((struct ptr_list **)&all_returns);
+}
+
+static void match_func_end(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+
+	if (func_has_transition)
+		check_consistency(sym);
+}
+
+static void match_after_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	clear_lists();
+}
+
+static void register_lock(int index)
+{
+	struct lock_info *lock = &lock_table[index];
+	void *idx = INT_PTR(index);
+
+	if (lock->return_type == ret_non_zero) {
+		return_implies_state(lock->function, valid_ptr_min, valid_ptr_max, &match_lock_held, idx);
+		return_implies_state(lock->function, 0, 0, &match_lock_failed, idx);
+	} else if (lock->return_type == ret_any && lock->arg == RETURN_VAL) {
+		add_function_assign_hook(lock->function, &match_returns_locked, idx);
+	} else if (lock->return_type == ret_any) {
+		add_function_hook(lock->function, &match_lock_unlock, idx);
+	} else if (lock->return_type == ret_zero) {
+		return_implies_state(lock->function, 0, 0, &match_lock_held, idx);
+		return_implies_state(lock->function, -4095, -1, &match_lock_failed, idx);
+	}
+}
+
+static void load_table(struct lock_info *_lock_table, int size)
+{
+	int i;
+
+	lock_table = _lock_table;
+
+	for (i = 0; i < size; i++) {
+		if (lock_table[i].action == LOCK)
+			register_lock(i);
+		else
+			add_function_hook(lock_table[i].function, &match_lock_unlock, INT_PTR(i));
+	}
+}
+
+/* print_held_locks() is used in check_call_tree.c */
+void print_held_locks(void)
+{
+	struct stree *stree;
+	struct sm_state *sm;
+	int i = 0;
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(my_id, stree, sm) {
+		if (sm->state != &locked)
+			continue;
+		if (i++)
+			sm_printf(" ");
+		sm_printf("'%s'", sm->name);
+	} END_FOR_EACH_SM(sm);
+}
+
+void check_locking(int id)
+{
+	my_id = id;
+
+	if (option_project == PROJ_WINE)
+		load_table(wine_lock_table, ARRAY_SIZE(wine_lock_table));
+	else if (option_project == PROJ_KERNEL)
+		load_table(kernel_lock_table, ARRAY_SIZE(kernel_lock_table));
+	else
+		return;
+
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	add_pre_merge_hook(my_id, &pre_merge_hook);
+	add_split_return_callback(match_return);
+	add_hook(&match_func_end, END_FUNC_HOOK);
+	add_hook(&match_after_func, AFTER_FUNC_HOOK);
+
+}
diff --git a/usr/src/tools/smatch/src/check_logical_instead_of_bitwise.c b/usr/src/tools/smatch/src/check_logical_instead_of_bitwise.c
new file mode 100644
index 0000000000..39522084b7
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_logical_instead_of_bitwise.c
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static int is_bitshift(struct expression *expr)
+{
+	expr = strip_expr(expr);
+
+	if (expr->type != EXPR_BINOP)
+		return 0;
+	if (expr->op == SPECIAL_LEFTSHIFT)
+		return 1;
+	return 0;
+}
+
+static void match_logic(struct expression *expr)
+{
+	sval_t sval;
+
+	if (expr->type != EXPR_LOGICAL)
+		return;
+
+	if (get_macro_name(expr->pos))
+		return;
+
+	if (!get_value(expr->right, &sval)) {
+		if (!get_value(expr->left, &sval))
+			return;
+	}
+
+	if (sval.value == 0 || sval.value == 1)
+		return;
+
+	sm_warning("should this be a bitwise op?");
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *right;
+
+	right = strip_expr(expr->right);
+	if (right->type != EXPR_LOGICAL)
+		return;
+	if (is_bitshift(right->left) || is_bitshift(right->right))
+		sm_warning("should this be a bitwise op?");
+}
+
+void check_logical_instead_of_bitwise(int id)
+{
+	my_id = id;
+
+	add_hook(&match_logic, LOGIC_HOOK);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_macro_side_effects.c b/usr/src/tools/smatch/src/check_macro_side_effects.c
new file mode 100644
index 0000000000..29c92b0e4b
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_macro_side_effects.c
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_expression_stacks.h"
+
+static int my_id;
+
+static struct string_list *ignored_macros;
+static struct position old_pos;
+
+static struct smatch_state *alloc_my_state(struct expression *expr)
+{
+	struct smatch_state *state;
+	char *name;
+
+	state = __alloc_smatch_state(0);
+	expr = strip_expr(expr);
+	name = expr_to_str(expr);
+	state->name = alloc_sname(name);
+	free_string(name);
+	state->data = expr;
+	return state;
+}
+
+static int defined_inside_macro(struct position macro_pos, struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	int ret = 0;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	if (!sym->scope || !sym->scope->token)
+		goto free;
+	if (positions_eq(macro_pos, sym->scope->token->pos))
+		ret = 1;
+free:
+	free_string(name);
+	return ret;
+}
+
+static int affected_inside_macro_before(struct expression *expr)
+{
+	struct sm_state *sm;
+	struct sm_state *tmp;
+	struct expression *old_mod;
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return 0;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		old_mod = tmp->state->data;
+		if (!old_mod)
+			continue;
+		if (positions_eq(old_mod->pos, expr->pos))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static int is_ignored_macro(const char *macro)
+{
+	char *tmp;
+
+	FOR_EACH_PTR(ignored_macros, tmp) {
+		if (!strcmp(tmp, macro))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static void match_unop(struct expression *raw_expr)
+{
+	struct expression *expr;
+	char *macro, *name;
+
+	if (raw_expr->op != SPECIAL_INCREMENT && raw_expr->op != SPECIAL_DECREMENT)
+		return;
+
+	macro = get_macro_name(raw_expr->pos);
+	if (!macro)
+		return;
+
+	expr = strip_expr(raw_expr->unop);
+
+	if (defined_inside_macro(expr->pos, expr))
+		return;
+
+	if (is_ignored_macro(macro))
+		return;
+
+	if (!affected_inside_macro_before(expr)) {
+		set_state_expr(my_id, expr, alloc_my_state(expr));
+		old_pos = expr->pos;
+		return;
+	}
+
+	if (!positions_eq(old_pos, expr->pos))
+		return;
+
+	name = expr_to_str(raw_expr);
+	sm_warning("side effect in macro '%s' doing '%s'",
+		macro, name);
+	free_string(name);
+}
+
+static void match_stmt(struct statement *stmt)
+{
+	if (!positions_eq(old_pos, stmt->pos))
+		old_pos.line = 0;
+}
+
+static void register_ignored_macros(void)
+{
+	struct token *token;
+	char *macro;
+	char name[256];
+
+	snprintf(name, 256, "%s.ignore_side_effects", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		macro = alloc_string(show_ident(token->ident));
+		add_ptr_list(&ignored_macros, macro);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_macro_side_effects(int id)
+{
+	my_id = id;
+
+	if (!option_spammy)
+		return;
+
+	add_hook(&match_unop, OP_HOOK);
+	add_hook(&match_stmt, STMT_HOOK);
+	register_ignored_macros();
+}
diff --git a/usr/src/tools/smatch/src/check_macros.c b/usr/src/tools/smatch/src/check_macros.c
new file mode 100644
index 0000000000..8b7198e2ad
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_macros.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_inside(struct expression *expr, struct position pos)
+{
+	char *name;
+	int matched = 0;
+
+	if (positions_eq(expr->pos, pos))
+		matched++;
+	if (positions_eq(expr->unop->pos, pos))
+		matched++;
+	if (matched != 1)
+		return;
+	name = get_macro_name(pos);
+	if (!name)
+		return;
+	sm_warning("the '%s' macro might need parens", name);
+}
+
+static void match_one_side(struct expression *expr, struct position pos, int op)
+{
+	char *name;
+	int matched = 0;
+
+	if ((op == '+' || op == '*' || op == '|' || op == '&') && expr->op == op)
+		return;
+	if (positions_eq(expr->right->pos, pos))
+		matched++;
+	if (positions_eq(expr->left->pos, pos))
+		matched++;
+	if (matched != 1)
+		return;
+	name = get_macro_name(pos);
+	if (!name)
+		return;
+	if (option_project == PROJ_WINE && !strcmp("BEGIN", name))
+		return;
+	sm_warning("the '%s' macro might need parens", name);
+}
+
+static void match_join(struct expression *expr)
+{
+	if (expr->left->type == EXPR_PREOP)
+		match_inside(expr->left, expr->pos);
+	if (expr->right->type == EXPR_POSTOP)
+		match_inside(expr->right, expr->pos);
+
+	if (expr->left->type == EXPR_BINOP)
+		match_one_side(expr->left, expr->pos, expr->op);
+	if (expr->right->type == EXPR_BINOP)
+		match_one_side(expr->right, expr->pos, expr->op);
+}
+
+void check_macros(int id)
+{
+	my_id = id;
+	add_hook(&match_join, BINOP_HOOK);
+	add_hook(&match_join, LOGIC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_memcpy_overflow.c b/usr/src/tools/smatch/src/check_memcpy_overflow.c
new file mode 100644
index 0000000000..dddc555a24
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_memcpy_overflow.c
@@ -0,0 +1,372 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdlib.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+struct limiter {
+	int buf_arg;
+	int limit_arg;
+};
+static struct limiter b0_l2 = {0, 2};
+static struct limiter b1_l2 = {1, 2};
+
+struct string_list *ignored_structs;
+
+static int get_the_max(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+
+	if (get_hard_max(expr, sval))
+		return 1;
+	if (!option_spammy)
+		return 0;
+	if (get_fuzzy_max(expr, sval))
+		return 1;
+	if (!get_user_rl(expr, &rl))
+		return 0;
+	*sval = rl_max(rl);
+	return 1;
+}
+
+static int bytes_to_end_of_struct(struct expression *expr)
+{
+	struct expression *deref;
+	struct symbol *type;
+	int struct_bytes;
+	int offset;
+
+	if (expr->type == EXPR_PREOP && expr->op == '&')
+		expr = strip_parens(expr->unop);
+	else {
+		type = get_type(expr);
+		if (!type || type->type != SYM_ARRAY)
+			return 0;
+	}
+	if (expr->type != EXPR_DEREF || !expr->member)
+		return 0;
+	deref = expr->deref;
+	if (deref->type == EXPR_PREOP && deref->op == '*')
+		deref = deref->unop;
+	struct_bytes = get_array_size_bytes_max(deref);
+	if (struct_bytes <= 0) {
+		type = get_type(expr->deref);
+		struct_bytes = type_bytes(type);
+	}
+	offset = get_member_offset_from_deref(expr);
+	if (offset <= 0)
+		return 0;
+	return struct_bytes - expr->member_offset;
+}
+
+static int size_of_union(struct expression *expr)
+{
+	struct symbol *type;
+
+	if (expr->type != EXPR_PREOP || expr->op != '&')
+		return 0;
+	expr = strip_parens(expr->unop);
+	if (expr->type != EXPR_DEREF || !expr->member)
+		return 0;
+	expr = expr->unop;
+	type = get_type(expr);
+	if (!type || type->type != SYM_UNION)
+		return 0;
+	return type_bytes(type);
+}
+
+static int is_likely_multiple(int has, int needed, struct expression *limit)
+{
+	sval_t mult;
+
+	limit = strip_parens(limit);
+	if (limit->type != EXPR_BINOP || limit->op != '*')
+		return 0;
+	if (!get_value(limit->left, &mult))
+		return 0;
+	if (has * mult.value == needed)
+		return 1;
+	if (!get_value(limit->right, &mult))
+		return 0;
+	if (has * mult.value == needed)
+		return 1;
+
+	return 0;
+}
+
+static int name_in_union(struct symbol *type, const char *name)
+{
+	struct symbol *tmp;
+
+	if (type->type == SYM_NODE)
+		type = get_real_base_type(type);
+	if (!type || type->type != SYM_UNION)
+		return 0;
+
+	FOR_EACH_PTR(type->symbol_list, tmp) {
+		if (tmp->ident &&
+		    strcmp(name, tmp->ident->name) == 0)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static int ends_on_struct_member_boundary(struct expression *expr, int needed)
+{
+	struct symbol *type, *tmp;
+	int offset;
+	int size;
+	int found = 0;
+
+	expr = strip_expr(expr);
+	if (expr->type == EXPR_PREOP && expr->op == '&') {
+		expr = strip_parens(expr->unop);
+	} else {
+		type = get_type(expr);
+		if (!type || type->type != SYM_ARRAY)
+			return 0;
+	}
+	if (expr->type != EXPR_DEREF || !expr->member)
+		return 0;
+
+	type = get_type(expr->unop);
+	if (!type)
+		return 0;
+	if (type->type == SYM_UNION) {
+		struct expression *unop = strip_expr(expr->unop);
+
+		if (unop->type != EXPR_DEREF)
+			return 0;
+		type = get_type(unop->unop);
+		if (!type)
+			return 0;
+	}
+	if (type->type != SYM_STRUCT)
+		return 0;
+
+	offset = 0;
+	FOR_EACH_PTR(type->symbol_list, tmp) {
+		if (!found) {
+			if ((tmp->ident &&
+			     strcmp(expr->member->name, tmp->ident->name) == 0) ||
+			    name_in_union(tmp, expr->member->name))
+				found = 1;
+
+			offset = ALIGN(offset, tmp->ctype.alignment);
+
+			offset += type_bytes(tmp);
+			size = type_bytes(tmp);
+			continue;
+		}
+
+		/* if there is a hole then fail. */
+		if (offset != ALIGN(offset, tmp->ctype.alignment))
+			return 0;
+		offset += type_bytes(tmp);
+		size += type_bytes(tmp);
+
+		if (size == needed)
+			return 1;
+		if (size > needed)
+			return 0;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static int is_one_element_array(struct expression *expr)
+{
+	struct symbol *type;
+	sval_t sval;
+
+	if (expr->type == EXPR_PREOP && expr->op == '&')
+		expr = expr->unop;
+	if (expr->type == EXPR_BINOP) /* array elements foo[5] */
+		return 0;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+	if (!type || type->type != SYM_ARRAY)
+		return 0;
+
+	if (!get_implied_value(type->array_size, &sval))
+		return 0;
+
+	if (sval.value == 1)
+		return 1;
+	return 0;
+}
+
+static int is_ignored_struct(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+	if (type->type == SYM_PTR)
+		type = get_real_base_type(type);
+	if (type->type != SYM_STRUCT)
+		return 0;
+	if (!type->ident)
+		return 0;
+	if (list_has_string(ignored_structs, type->ident->name))
+		return 1;
+	return 0;
+}
+
+static void match_limited(const char *fn, struct expression *expr, void *_limiter)
+{
+	struct limiter *limiter = (struct limiter *)_limiter;
+	struct expression *dest;
+	struct expression *limit;
+	char *dest_name = NULL;
+	sval_t needed;
+	int has;
+
+	dest = get_argument_from_call_expr(expr->args, limiter->buf_arg);
+	limit = get_argument_from_call_expr(expr->args, limiter->limit_arg);
+	if (!get_the_max(limit, &needed))
+		return;
+	has = get_array_size_bytes_max(dest);
+	if (!has)
+		return;
+	if (has >= needed.value)
+		return;
+
+	if (needed.value == bytes_to_end_of_struct(dest))
+		return;
+
+	if (needed.value <= size_of_union(dest))
+		return;
+
+	if (is_likely_multiple(has, needed.value, limit))
+		return;
+
+	if (ends_on_struct_member_boundary(dest, needed.value))
+		return;
+
+	if (is_one_element_array(dest))
+		return;
+
+	if (is_ignored_struct(dest))
+		return;
+
+	dest_name = expr_to_str(dest);
+	sm_error("%s() '%s' too small (%d vs %s)", fn, dest_name, has, sval_to_str(needed));
+	free_string(dest_name);
+}
+
+static void register_funcs_from_file(void)
+{
+	char name[256];
+	struct token *token;
+	const char *func;
+	int size, buf;
+	struct limiter *limiter;
+
+	snprintf(name, 256, "%s.sizeof_param", option_project_str);
+	name[255] = '\0';
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			break;
+		func = show_ident(token->ident);
+
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			break;
+		size = atoi(token->number);
+
+		token = token->next;
+		if (token_type(token) == TOKEN_SPECIAL) {
+			if (token->special != '-')
+				break;
+			token = token->next;
+			if (token_type(token) != TOKEN_NUMBER)
+				break;
+			token = token->next;
+			continue;
+
+		}
+		if (token_type(token) != TOKEN_NUMBER)
+			break;
+		buf = atoi(token->number);
+
+		limiter = malloc(sizeof(*limiter));
+		limiter->limit_arg = size;
+		limiter->buf_arg = buf;
+
+		add_function_hook(func, &match_limited, limiter);
+
+		token = token->next;
+	}
+	if (token_type(token) != TOKEN_STREAMEND)
+		sm_perror("parsing '%s'", name);
+	clear_token_alloc();
+}
+
+static void register_ignored_structs_from_file(void)
+{
+	char name[256];
+	struct token *token;
+	const char *struct_type;
+
+	snprintf(name, 256, "%s.ignore_memcpy_struct_overflows", option_project_str);
+	name[255] = '\0';
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+
+		struct_type = show_ident(token->ident);
+		insert_string(&ignored_structs, alloc_string(struct_type));
+
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_memcpy_overflow(int id)
+{
+	register_funcs_from_file();
+	register_ignored_structs_from_file();
+	add_function_hook("memcmp", &match_limited, &b0_l2);
+	add_function_hook("memcmp", &match_limited, &b1_l2);
+	if (option_project == PROJ_KERNEL) {
+		add_function_hook("copy_to_user", &match_limited, &b1_l2);
+		add_function_hook("_copy_to_user", &match_limited, &b1_l2);
+		add_function_hook("__copy_to_user", &match_limited, &b1_l2);
+		add_function_hook("copy_from_user", &match_limited, &b0_l2);
+		add_function_hook("_copy_from_user", &match_limited, &b0_l2);
+		add_function_hook("__copy_from_user", &match_limited, &b0_l2);
+	}
+}
diff --git a/usr/src/tools/smatch/src/check_memory.c b/usr/src/tools/smatch/src/check_memory.c
new file mode 100644
index 0000000000..4e27497581
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_memory.c
@@ -0,0 +1,466 @@
+/*
+ * Copyright (C) 2008 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <fcntl.h>
+#include <unistd.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static void check_sm_is_leaked(struct sm_state *sm);
+
+static int my_id;
+
+STATE(allocated);
+STATE(assigned);
+STATE(isfree);
+STATE(malloced);
+STATE(isnull);
+STATE(unfree);
+
+/*
+  malloced --> allocated --> assigned --> isfree +
+            \-> isnull.    \-> isfree +
+
+  isfree --> unfree.
+          \-> isnull.
+*/
+
+static struct tracker_list *arguments;
+
+static const char *allocation_funcs[] = {
+	"malloc",
+	"kmalloc",
+	"kzalloc",
+	NULL,
+};
+
+static char *get_parent_name(struct symbol *sym)
+{
+	static char buf[256];
+
+	if (!sym || !sym->ident)
+		return NULL;
+
+	snprintf(buf, 255, "-%s", sym->ident->name);
+	buf[255] = '\0';
+	return alloc_string(buf);
+}
+
+static int is_parent_sym(const char *name)
+{
+	if (!strncmp(name, "-", 1))
+		return 1;
+	return 0;
+}
+
+static int is_complex(struct expression *expr)
+{
+	char *name;
+	int ret = 1;
+
+	name = expr_to_var(expr);
+	if (name)
+		ret = 0;
+	free_string(name);
+	return ret;
+}
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	if (is_parent_sym(sm->name))
+		return &assigned;
+	return &undefined;
+}
+
+static void assign_parent(struct symbol *sym)
+{
+	char *name;
+
+	name = get_parent_name(sym);
+	if (!name)
+		return;
+	set_state(my_id, name, sym, &assigned);
+	free_string(name);
+}
+
+static int parent_is_assigned(struct symbol *sym)
+{
+	struct smatch_state *state;
+	char *name;
+
+	name = get_parent_name(sym);
+	if (!name)
+		return 0;
+	state = get_state(my_id, name, sym);
+	free_string(name);
+	if (state == &assigned)
+		return 1;
+	return 0;
+}
+
+static int is_allocation(struct expression *expr)
+{
+	char *fn_name;
+	int i;
+
+	if (expr->type != EXPR_CALL)
+		return 0;
+
+	if (!(fn_name = expr_to_var_sym(expr->fn, NULL)))
+		return 0;
+
+	for (i = 0; allocation_funcs[i]; i++) {
+		if (!strcmp(fn_name, allocation_funcs[i])) {
+			free_string(fn_name);
+			return 1;
+		}
+	}
+	free_string(fn_name);
+	return 0;
+}
+
+static int is_freed(const char *name, struct symbol *sym)
+{
+	struct state_list *slist;
+
+	slist = get_possible_states(my_id, name, sym);
+	if (slist_has_state(slist, &isfree)) {
+		return 1;
+	}
+	return 0;
+}
+
+static int is_argument(struct symbol *sym)
+{
+	struct tracker *arg;
+
+	FOR_EACH_PTR(arguments, arg) {
+		if (arg->sym == sym)
+			return 1;
+	} END_FOR_EACH_PTR(arg);
+	return 0;
+}
+
+static void match_function_def(struct symbol *sym)
+{
+	struct symbol *arg;
+
+	FOR_EACH_PTR(sym->ctype.base_type->arguments, arg) {
+		add_tracker(&arguments, my_id, (arg->ident?arg->ident->name:"NULL"), arg);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static int is_parent(struct expression *expr)
+{
+	if (expr->type == EXPR_DEREF)
+		return 0;
+	return 1;
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *left, *right;
+	char *left_name = NULL;
+	char *right_name = NULL;
+	struct symbol *left_sym, *right_sym;
+	struct smatch_state *state;
+	struct state_list *slist;
+	struct sm_state *tmp;
+
+	left = strip_expr(expr->left);
+	left_name = expr_to_str_sym(left, &left_sym);
+
+	right = strip_expr(expr->right);
+	while (right->type == EXPR_ASSIGNMENT)
+		right = right->left;
+
+	if (left_name && left_sym && is_allocation(right) && 
+	    !(left_sym->ctype.modifiers & 
+	      (MOD_NONLOCAL | MOD_STATIC | MOD_ADDRESSABLE)) &&
+	    !parent_is_assigned(left_sym)) {
+		set_state(my_id, left_name, left_sym, &malloced);
+		goto exit;
+	}
+
+	right_name = expr_to_str_sym(right, &right_sym);
+
+	if (right_name && (state = get_state(my_id, right_name, right_sym))) {
+		if (state == &isfree && !is_complex(right))
+			sm_error("assigning freed pointer '%s'", right_name);
+		set_state(my_id, right_name, right_sym, &assigned);
+	}
+
+	if (is_zero(expr->right)) {
+		slist = get_possible_states(my_id, left_name, left_sym);
+
+		FOR_EACH_PTR(slist, tmp) {
+			check_sm_is_leaked(tmp);
+		} END_FOR_EACH_PTR(tmp);
+	}
+
+	if (is_freed(left_name, left_sym)) {
+		set_state(my_id, left_name, left_sym, &unfree);
+	}
+	if (left_name && is_parent(left))
+		assign_parent(left_sym);
+	if (right_name && is_parent(right))
+		assign_parent(right_sym);
+exit:
+	free_string(left_name);
+	free_string(right_name);
+}
+
+static int is_null(const char *name, struct symbol *sym)
+{
+	struct smatch_state *state;
+
+	state = get_state(my_id, name, sym);
+	if (state && !strcmp(state->name, "isnull"))
+		return 1;
+	return 0;
+}
+
+static void set_unfree(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (slist_has_state(sm->possible, &isfree))
+		set_state(my_id, sm->name, sm->sym, &unfree);
+}
+
+static void match_free_func(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *ptr_expr;
+	char *ptr_name;
+	struct symbol *ptr_sym;
+	int arg_num = PTR_INT(data);
+
+	ptr_expr = get_argument_from_call_expr(expr->args, arg_num);
+	ptr_name = expr_to_var_sym(ptr_expr, &ptr_sym);
+	if (!ptr_name)
+		return;
+	set_state(my_id, ptr_name, ptr_sym, &isfree);
+	free_string(ptr_name);
+}
+
+static int possibly_allocated(struct state_list *slist)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(slist, tmp) {
+		if (tmp->state == &allocated)
+			return 1;
+		if (tmp->state == &malloced)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static void check_sm_is_leaked(struct sm_state *sm)
+{
+	if (possibly_allocated(sm->possible) && 
+		!is_null(sm->name, sm->sym) &&
+		!is_argument(sm->sym) && 
+		!parent_is_assigned(sm->sym))
+		sm_error("memory leak of '%s'", sm->name);
+}
+
+static void check_tracker_is_leaked(struct tracker *t)
+{
+	struct sm_state *sm;
+
+	sm = get_sm_state(t->owner, t->name, t->sym);
+	if (sm)
+		check_sm_is_leaked(sm);
+	__free_tracker(t);
+}
+
+static void match_declarations(struct symbol *sym)
+{
+	const char *name;
+
+	if ((get_base_type(sym))->type == SYM_ARRAY) {
+		return;
+	}
+
+	name = sym->ident->name;
+
+	if (sym->initializer) {
+		if (is_allocation(sym->initializer)) {
+			set_state(my_id, name, sym, &malloced);
+			add_scope_hook((scope_hook *)&check_tracker_is_leaked,
+				alloc_tracker(my_id, name, sym));
+			scoped_state(my_id, name, sym);
+		} else {
+			assign_parent(sym);
+		}
+	}
+}
+
+static void check_for_allocated(void)
+{
+	struct stree *stree;
+	struct sm_state *tmp;
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(my_id, stree, tmp) {
+		check_sm_is_leaked(tmp);
+	} END_FOR_EACH_SM(tmp);
+}
+
+static void match_return(struct expression *ret_value)
+{
+	char *name;
+	struct symbol *sym;
+
+	if (__inline_fn)
+		return;
+	name = expr_to_str_sym(ret_value, &sym);
+	if (sym)
+		assign_parent(sym);
+	free_string(name);
+	check_for_allocated();
+}
+
+static void set_new_true_false_paths(const char *name, struct symbol *sym)
+{
+	struct smatch_state *tmp;
+
+	tmp = get_state(my_id, name, sym);
+
+	if (!tmp) {
+		return;
+	}
+
+	if (tmp == &isfree) {
+		sm_warning("why do you care about freed memory? '%s'", name);
+	}
+
+	if (tmp == &assigned) {
+		/* we don't care about assigned pointers any more */
+		return;
+	}
+	set_true_false_states(my_id, name, sym, &allocated, &isnull);
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct symbol *sym;
+	char *name;
+
+	expr = strip_expr(expr);
+	switch (expr->type) {
+	case EXPR_PREOP:
+	case EXPR_SYMBOL:
+	case EXPR_DEREF:
+		name = expr_to_var_sym(expr, &sym);
+		if (!name)
+			return;
+		set_new_true_false_paths(name, sym);
+		free_string(name);
+		return;
+	case EXPR_ASSIGNMENT:
+		 /* You have to deal with stuff like if (a = b = c) */
+		match_condition(expr->right);
+		match_condition(expr->left);
+		return;
+	default:
+		return;
+	}
+}
+
+static void match_function_call(struct expression *expr)
+{
+	struct expression *tmp;
+	struct symbol *sym;
+	char *name;
+	struct sm_state *state;
+
+	FOR_EACH_PTR(expr->args, tmp) {
+		tmp = strip_expr(tmp);
+		name = expr_to_str_sym(tmp, &sym);
+		if (!name)
+			continue;
+		if ((state = get_sm_state(my_id, name, sym))) {
+			if (possibly_allocated(state->possible)) {
+				set_state(my_id, name, sym, &assigned);
+			}
+		}
+		assign_parent(sym);
+		free_string(name);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	check_for_allocated();
+}
+
+static void match_after_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	free_trackers_and_list(&arguments);
+}
+
+static void register_funcs_from_file(void)
+{
+	struct token *token;
+	const char *func;
+	int arg;
+
+	token = get_tokens_file("kernel.frees_argument");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		arg = atoi(token->number);
+		add_function_hook(func, &match_free_func, INT_PTR(arg));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_memory(int id)
+{
+	my_id = id;
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+	add_hook(&match_declarations, DECLARATION_HOOK);
+	add_hook(&match_function_call, FUNCTION_CALL_HOOK);
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_return, RETURN_HOOK);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+	add_hook(&match_after_func, AFTER_FUNC_HOOK);
+	add_modification_hook(my_id, &set_unfree);
+	if (option_project == PROJ_KERNEL) {
+		add_function_hook("kfree", &match_free_func, (void *)0);
+		register_funcs_from_file();
+	} else {
+		add_function_hook("free", &match_free_func, (void *)0);
+	}
+}
diff --git a/usr/src/tools/smatch/src/check_memset.c b/usr/src/tools/smatch/src/check_memset.c
new file mode 100644
index 0000000000..0213693afa
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_memset.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2011 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_memset(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg_expr;
+	sval_t sval;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 2);
+
+	if (arg_expr->type != EXPR_VALUE)
+		return;
+	if (!get_value(arg_expr, &sval))
+		return;
+	if (sval.value != 0)
+		return;
+	sm_error("calling memset(x, y, 0);");
+}
+
+void check_memset(int id)
+{
+	my_id = id;
+	add_function_hook("memset", &match_memset, NULL);
+	add_function_hook("__builtin_memset", &match_memset, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_min_t.c b/usr/src/tools/smatch/src/check_min_t.c
new file mode 100644
index 0000000000..9ec37f9e47
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_min_t.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2011 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_assign(struct expression *expr)
+{
+	const char *macro;
+	sval_t max_left, max_right;
+	char *name;
+
+	if (expr->op != '=')
+		return;
+
+	macro = get_macro_name(expr->pos);
+	if (!macro)
+		return;
+	if (strcmp(macro, "min_t"))
+		return;
+
+	if (!get_absolute_max(expr->left, &max_left))
+		return;
+	if (!get_absolute_max(expr->right, &max_right))
+		return;
+
+	if (sval_cmp(max_left, max_right) >= 0)
+		return;
+
+	name = expr_to_str(expr->right);
+	sm_warning("min_t truncates here '%s' (%s vs %s)", name, sval_to_str(max_left), sval_to_str(max_right));
+	free_string(name);
+}
+
+void check_min_t(int id)
+{
+	my_id = id;
+	if (option_project != PROJ_KERNEL)
+		return;
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_missing_break.c b/usr/src/tools/smatch/src/check_missing_break.c
new file mode 100644
index 0000000000..fb30518131
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_missing_break.c
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The way I'm detecting missing breaks is if there is an assignment inside a
+ * switch statement which is over written.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+static struct expression *skip_this;
+
+/*
+ * It goes like this:
+ * - Allocate a state which stores the switch expression.  I wanted to
+ *   just have a state &assigned but we need to know the switch statement where
+ *   it was assigned.
+ * - If it gets used then we change it to &used.
+ * - For unmatched states we use &used (because of cleanness, not because we need
+ *   to).
+ * - If we merge inside a case statement and one of the states is &assigned (or
+ *   if it is &nobreak) then &nobreak is used.
+ *
+ * We print an error when we assign something to a &no_break symbol.
+ *
+ */
+
+STATE(used);
+STATE(no_break);
+
+static int in_switch_stmt;
+
+static struct smatch_state *alloc_my_state(struct expression *expr)
+{
+	struct smatch_state *state;
+	char *name;
+
+	state = __alloc_smatch_state(0);
+	expr = strip_expr(expr);
+	name = expr_to_str(expr);
+	if (!name)
+		name = alloc_string("");
+	state->name = alloc_sname(name);
+	free_string(name);
+	state->data = expr;
+	return state;
+}
+
+struct expression *last_print_expr;
+static void print_missing_break(struct expression *expr)
+{
+	char *name;
+
+	if (get_switch_expr() == last_print_expr)
+		return;
+	last_print_expr = get_switch_expr();
+
+	name = expr_to_var(expr);
+	sm_warning("missing break? reassigning '%s'", name);
+	free_string(name);
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *left;
+
+	if (expr->op != '=')
+		return;
+	if (!get_switch_expr())
+		return;
+	left = strip_expr(expr->left);
+	if (get_state_expr(my_id, left) == &no_break)
+		print_missing_break(left);
+
+	set_state_expr(my_id, left, alloc_my_state(get_switch_expr()));
+	skip_this = left;
+}
+
+static void match_symbol(struct expression *expr)
+{
+	if (outside_of_function())
+		return;
+	if (!get_switch_expr())
+		return;
+
+	expr = strip_expr(expr);
+	if (expr == skip_this)
+		return;
+	set_state_expr(my_id, expr, &used);
+}
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	return &used;
+}
+
+static int in_case;
+static struct smatch_state *merge_hook(struct smatch_state *s1, struct smatch_state *s2)
+{
+	struct expression *switch_expr;
+
+	if (s1 == &no_break || s2 == &no_break)
+		return &no_break;
+	if (!in_case)
+		return &used;
+	switch_expr = get_switch_expr();
+	if (s1->data == switch_expr || s2->data == switch_expr)
+		return &no_break;
+	return &used;
+}
+
+static void match_stmt(struct statement *stmt)
+{
+	if (stmt->type == STMT_CASE)
+		in_case = 1;
+	else
+		in_case = 0;
+}
+
+static void match_switch(struct statement *stmt)
+{
+	if (stmt->type != STMT_SWITCH)
+		return;
+
+	in_switch_stmt++;
+}
+
+static void delete_my_states(int owner)
+{
+	struct state_list *slist = NULL;
+	struct sm_state *sm;
+
+	FOR_EACH_MY_SM(owner, __get_cur_stree(), sm) {
+		add_ptr_list(&slist, sm);
+	} END_FOR_EACH_SM(sm);
+
+	FOR_EACH_PTR(slist, sm) {
+		delete_state(sm->owner, sm->name, sm->sym);
+	} END_FOR_EACH_PTR(sm);
+
+	free_slist(&slist);
+}
+
+static void match_switch_end(struct statement *stmt)
+{
+
+	if (stmt->type != STMT_SWITCH)
+		return;
+
+	in_switch_stmt--;
+
+	if (!in_switch_stmt)
+		delete_my_states(my_id);
+}
+
+void check_missing_break(int id)
+{
+	my_id = id;
+
+	if (!option_spammy)
+		return;
+
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	add_merge_hook(my_id, &merge_hook);
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_symbol, SYM_HOOK);
+	add_hook(&match_stmt, STMT_HOOK);
+	add_hook(&match_switch, STMT_HOOK);
+	add_hook(&match_switch_end, STMT_HOOK_AFTER);
+}
diff --git a/usr/src/tools/smatch/src/check_mod_timer.c b/usr/src/tools/smatch/src/check_mod_timer.c
new file mode 100644
index 0000000000..614852090f
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_mod_timer.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static void match_mod_timer(const char *fn, struct expression *expr, void *param)
+{
+	struct expression *arg;
+	sval_t sval;
+
+	arg = get_argument_from_call_expr(expr->args, 1);
+	if (!get_value(arg, &sval) || sval.value == 0)
+		return;
+	sm_warning("mod_timer() takes an absolute time not an offset.");
+}
+
+void check_mod_timer(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_function_hook("mod_timer", &match_mod_timer, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_no_effect.c b/usr/src/tools/smatch/src/check_no_effect.c
new file mode 100644
index 0000000000..f7a7ddd5ca
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_no_effect.c
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_stmt(struct statement *stmt)
+{
+	struct expression *expr;
+
+	if (stmt->type != STMT_EXPRESSION)
+		return;
+	expr = stmt->expression;
+	if (!expr)
+		return;
+	switch(expr->type) {
+	case EXPR_PREOP:
+		if (expr->op == '!')
+			break;
+		if (expr->op == '~')
+			break;
+	case EXPR_POSTOP:
+	case EXPR_STATEMENT:
+	case EXPR_ASSIGNMENT:
+	case EXPR_CALL:
+	case EXPR_CONDITIONAL:
+	case EXPR_SELECT:
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+	case EXPR_COMMA:
+		return;
+	}
+	if (in_expression_statement())
+		return;
+	sm_warning("statement has no effect %d", expr->type);
+}
+
+void check_no_effect(int id)
+{
+	my_id = id;
+	add_hook(&match_stmt, STMT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_no_if_block.c b/usr/src/tools/smatch/src/check_no_if_block.c
new file mode 100644
index 0000000000..d3095e94e0
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_no_if_block.c
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_if_stmt(struct statement *stmt)
+{
+	if (__inline_fn)
+		return;
+	if (stmt->type != STMT_IF)
+		return;
+	if (stmt->if_true->type == STMT_COMPOUND)
+		return;
+	if (get_macro_name(stmt->pos))
+		return;
+	if (stmt->pos.pos != stmt->if_true->pos.pos)
+		return;
+	sm_warning("if statement not indented");
+}
+
+static void match_for_stmt(struct statement *stmt)
+{
+	if (__inline_fn)
+		return;
+	if (stmt->type != STMT_ITERATOR)
+		return;
+	if (stmt->iterator_statement->type == STMT_COMPOUND)
+		return;
+	if (get_macro_name(stmt->pos))
+		return;
+	if (stmt->pos.pos != stmt->iterator_statement->pos.pos)
+		return;
+	sm_warning("for statement not indented");
+}
+
+void check_no_if_block(int id)
+{
+	my_id = id;
+
+	add_hook(&match_if_stmt, STMT_HOOK);
+	add_hook(&match_for_stmt, STMT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_no_return.c b/usr/src/tools/smatch/src/check_no_return.c
new file mode 100644
index 0000000000..57c6afdf38
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_no_return.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+static int returned;
+
+static void match_return(struct expression *ret_value)
+{
+	if (__inline_fn)
+		return;
+	if (is_reachable())
+		returned = 1;
+}
+
+static void match_func_end(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	if (!is_reachable() && !returned)
+		sm_info("info: add to no_return_funcs");
+	returned = 0;
+}
+
+void check_no_return(int id)
+{
+	if (!option_info)
+		return;
+	my_id = id;
+	add_hook(&match_return, RETURN_HOOK);
+	add_hook(&match_func_end, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_nospec.c b/usr/src/tools/smatch/src/check_nospec.c
new file mode 100644
index 0000000000..a4d5baef89
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_nospec.c
@@ -0,0 +1,261 @@
+/*
+ * Copyright (C) 2018 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdlib.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+static int barrier_id;
+
+STATE(nospec);
+
+static bool in_nospec_stmt;
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	struct range_list *rl;
+
+	if (__in_function_def && !get_user_rl_var_sym(sm->name, sm->sym, &rl))
+		return &nospec;
+	return &undefined;
+}
+
+bool is_nospec(struct expression *expr)
+{
+	char *macro;
+
+	if (in_nospec_stmt)
+		return true;
+	if (!expr)
+		return false;
+	if (get_state_expr(my_id, expr) == &nospec)
+		return true;
+	macro = get_macro_name(expr->pos);
+	if (macro && strcmp(macro, "array_index_nospec") == 0)
+		return true;
+	return false;
+}
+
+static void nospec_assign(struct expression *expr)
+{
+	if (is_nospec(expr->right))
+		set_state_expr(my_id, expr->left, &nospec);
+}
+
+static void set_param_nospec(const char *name, struct symbol *sym, char *key, char *value)
+{
+	char fullname[256];
+
+	if (strcmp(key, "*$") == 0)
+		snprintf(fullname, sizeof(fullname), "*%s", name);
+	else if (strncmp(key, "$", 1) == 0)
+		snprintf(fullname, 256, "%s%s", name, key + 1);
+	else
+		return;
+
+	set_state(my_id, fullname, sym, &nospec);
+}
+
+static void match_call_info(struct expression *expr)
+{
+	struct expression *arg;
+	int i = 0;
+
+	FOR_EACH_PTR(expr->args, arg) {
+		if (get_state_expr(my_id, arg) == &nospec)
+			sql_insert_caller_info(expr, NOSPEC, i, "$", "");
+		i++;
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
+{
+	struct range_list *rl;
+
+	if (!get_user_rl_var_sym(sm->name, sm->sym, &rl))
+		return;
+	sql_insert_caller_info(call, NOSPEC, param, printed_name, "");
+}
+
+static void returned_struct_members(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct symbol *returned_sym;
+	struct sm_state *sm;
+	const char *param_name;
+	struct range_list *rl;
+	int param;
+
+	returned_sym = expr_to_sym(expr);
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0) {
+			if (!returned_sym || returned_sym != sm->sym)
+				continue;
+			param = -1;
+		}
+
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+		if (param != -1 && strcmp(param_name, "$") == 0)
+			continue;
+
+		if (!get_user_rl_var_sym(sm->name, sm->sym, &rl))
+			continue;
+
+		sql_insert_return_states(return_id, return_ranges, NOSPEC, param, param_name, "");
+	} END_FOR_EACH_SM(sm);
+
+	if (is_nospec(expr) && get_user_rl(expr, &rl))
+		sql_insert_return_states(return_id, return_ranges, NOSPEC, -1, "$", "");
+
+	if (get_state(barrier_id, "barrier", NULL) == &nospec)
+		sql_insert_return_states(return_id, return_ranges, NOSPEC_WB, -1, "", "");
+}
+
+static int is_return_statement(void)
+{
+	if (__cur_stmt && __cur_stmt->type == STMT_RETURN)
+		return 1;
+	return 0;
+}
+
+static void db_returns_nospec(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *call;
+	struct expression *arg;
+	char *name;
+	struct symbol *sym;
+
+	call = expr;
+	while (call->type == EXPR_ASSIGNMENT)
+		call = strip_expr(call->right);
+	if (call->type != EXPR_CALL)
+		return;
+
+	if (param == -1 && expr->type == EXPR_ASSIGNMENT) {
+		name = get_variable_from_key(expr->left, key, &sym);
+	} else if (param == -1 && is_return_statement()) {
+		in_nospec_stmt = true;
+		return;
+	} else {
+		arg = get_argument_from_call_expr(call->args, param);
+		if (!arg)
+			return;
+		name = get_variable_from_key(arg, key, &sym);
+	}
+	if (!name || !sym)
+		goto free;
+
+	set_state(my_id, name, sym, &nospec);
+free:
+	free_string(name);
+}
+
+static int is_nospec_asm(struct statement *stmt)
+{
+	char *macro;
+
+	if (!stmt || stmt->type != STMT_ASM)
+		return 0;
+	macro = get_macro_name(stmt->asm_string->pos);
+	if (!macro || strcmp(macro, "CALL_NOSPEC") != 0)
+		return 0;
+	return 1;
+}
+
+static void match_asm(struct statement *stmt)
+{
+	if (is_nospec_asm(stmt))
+		in_nospec_stmt = true;
+}
+
+static void match_after_nospec_asm(struct statement *stmt)
+{
+	in_nospec_stmt = false;
+}
+
+static void mark_user_data_as_nospec(void)
+{
+	struct stree *stree;
+	struct symbol *type;
+	struct sm_state *sm;
+
+	stree = get_user_stree();
+	FOR_EACH_SM(stree, sm) {
+		if (is_whole_rl(estate_rl(sm->state)))
+			continue;
+		type = estate_type(sm->state);
+		if (!type || type->type != SYM_BASETYPE)
+			continue;
+		if (!is_capped_var_sym(sm->name, sm->sym))
+			continue;
+		set_state(my_id, sm->name, sm->sym, &nospec);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&stree);
+}
+
+static void match_barrier(struct statement *stmt)
+{
+	char *macro;
+
+	macro = get_macro_name(stmt->pos);
+	if (!macro)
+		return;
+	if (strcmp(macro, "rmb") != 0 &&
+	    strcmp(macro, "smp_rmb") != 0 &&
+	    strcmp(macro, "barrier_nospec") != 0)
+		return;
+
+	set_state(barrier_id, "barrier", NULL, &nospec);
+	mark_user_data_as_nospec();
+}
+
+static void db_returns_barrier(struct expression *expr, int param, char *key, char *value)
+{
+	mark_user_data_as_nospec();
+}
+
+void check_nospec(int id)
+{
+	my_id = id;
+
+	add_hook(&nospec_assign, ASSIGNMENT_HOOK);
+
+	select_caller_info_hook(set_param_nospec, NOSPEC);
+	add_unmatched_state_hook(my_id, &unmatched_state);
+
+	add_hook(&match_call_info, FUNCTION_CALL_HOOK);
+	add_member_info_callback(my_id, struct_member_callback);
+	add_split_return_callback(&returned_struct_members);
+	select_return_states_hook(NOSPEC, &db_returns_nospec);
+	select_return_states_hook(NOSPEC_WB, &db_returns_barrier);
+
+	add_hook(&match_asm, ASM_HOOK);
+	add_hook(&match_after_nospec_asm, STMT_HOOK_AFTER);
+}
+
+void check_nospec_barrier(int id)
+{
+	barrier_id = id;
+
+	add_hook(&match_barrier, ASM_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_off_by_one_relative.c b/usr/src/tools/smatch/src/check_off_by_one_relative.c
new file mode 100644
index 0000000000..f6f6e6fac7
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_off_by_one_relative.c
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2015 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The point here is to store that a buffer has x bytes even if we don't know
+ * the value of x.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static void array_check(struct expression *expr)
+{
+	struct expression *array;
+	struct expression *size;
+	struct expression *offset;
+	char *array_str, *offset_str;
+
+	expr = strip_expr(expr);
+	if (!is_array(expr))
+		return;
+
+	array = get_array_base(expr);
+	size = get_size_variable(array);
+	if (!size)
+		return;
+	offset = get_array_offset(expr);
+	if (!possible_comparison(size, SPECIAL_EQUAL, offset))
+		return;
+
+	array_str = expr_to_str(array);
+	offset_str = expr_to_str(offset);
+	sm_warning("potentially one past the end of array '%s[%s]'", array_str, offset_str);
+	free_string(array_str);
+	free_string(offset_str);
+}
+
+static int known_access_ok_comparison(struct expression *expr)
+{
+	struct expression *array;
+	struct expression *size;
+	struct expression *offset;
+	int comparison;
+
+	array = get_array_base(expr);
+	size = get_size_variable(array);
+	if (!size)
+		return 0;
+	offset = get_array_offset(expr);
+	comparison = get_comparison(size, offset);
+	if (comparison == '>' || comparison == SPECIAL_UNSIGNED_GT)
+		return 1;
+
+	return 0;
+}
+
+static int known_access_ok_numbers(struct expression *expr)
+{
+	struct expression *array;
+	struct expression *offset;
+	sval_t max;
+	int size;
+
+	array = get_array_base(expr);
+	offset = get_array_offset(expr);
+
+	size = get_array_size(array);
+	if (size <= 0)
+		return 0;
+
+	get_absolute_max(offset, &max);
+	if (max.uvalue < size)
+		return 1;
+	return 0;
+}
+
+static void array_check_data_info(struct expression *expr)
+{
+	struct expression *array;
+	struct expression *offset;
+	struct state_list *slist;
+	struct sm_state *sm;
+	struct compare_data *comp;
+	char *offset_name;
+	const char *equal_name = NULL;
+
+	expr = strip_expr(expr);
+	if (!is_array(expr))
+		return;
+
+	if (known_access_ok_numbers(expr))
+		return;
+	if (known_access_ok_comparison(expr))
+		return;
+
+	array = get_array_base(expr);
+	offset = get_array_offset(expr);
+	offset_name = expr_to_var(offset);
+	if (!offset_name)
+		return;
+	slist = get_all_possible_equal_comparisons(offset);
+	if (!slist)
+		goto free;
+
+	FOR_EACH_PTR(slist, sm) {
+		comp = sm->state->data;
+		if (strcmp(comp->left_var, offset_name) == 0) {
+			if (db_var_is_array_limit(array, comp->right_var, comp->right_vsl)) {
+				equal_name = comp->right_var;
+				break;
+			}
+		} else if (strcmp(comp->right_var, offset_name) == 0) {
+			if (db_var_is_array_limit(array, comp->left_var, comp->left_vsl)) {
+				equal_name = comp->left_var;
+				break;
+			}
+		}
+	} END_FOR_EACH_PTR(sm);
+
+	if (equal_name) {
+		char *array_name = expr_to_str(array);
+
+		sm_warning("potential off by one '%s[]' limit '%s'", array_name, equal_name);
+		free_string(array_name);
+	}
+
+free:
+	free_slist(&slist);
+	free_string(offset_name);
+}
+
+void check_off_by_one_relative(int id)
+{
+	my_id = id;
+
+	add_hook(&array_check, OP_HOOK);
+	add_hook(&array_check_data_info, OP_HOOK);
+}
+
diff --git a/usr/src/tools/smatch/src/check_or_vs_and.c b/usr/src/tools/smatch/src/check_or_vs_and.c
new file mode 100644
index 0000000000..8d63c3d489
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_or_vs_and.c
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_function_hashtable.h"
+
+static int my_id;
+
+DEFINE_STRING_HASHTABLE_STATIC(unconstant_macros);
+
+static int does_inc_dec(struct expression *expr)
+{
+	if (expr->type == EXPR_PREOP || expr->type == EXPR_POSTOP) {
+		if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
+			return 1;
+		return does_inc_dec(expr->unop);
+	}
+	return 0;
+}
+
+static int expr_equiv_no_inc_dec(struct expression *one, struct expression *two)
+{
+	if (does_inc_dec(one) || does_inc_dec(two))
+		return 0;
+	return expr_equiv(one, two);
+}
+
+static int inconsistent_check(struct expression *left, struct expression *right)
+{
+	sval_t sval;
+
+	if (get_value(left->left, &sval)) {
+		if (get_value(right->left, &sval))
+			return expr_equiv_no_inc_dec(left->right, right->right);
+		if (get_value(right->right, &sval))
+			return expr_equiv_no_inc_dec(left->right, right->left);
+		return 0;
+	}
+	if (get_value(left->right, &sval)) {
+		if (get_value(right->left, &sval))
+			return expr_equiv_no_inc_dec(left->left, right->right);
+		if (get_value(right->right, &sval))
+			return expr_equiv_no_inc_dec(left->left, right->left);
+		return 0;
+	}
+
+	return 0;
+}
+
+static void check_or(struct expression *expr)
+{
+	struct expression *left, *right;
+
+	left = strip_expr(expr->left);
+	right = strip_expr(expr->right);
+
+	if (left->type != EXPR_COMPARE || left->op != SPECIAL_NOTEQUAL)
+		return;
+	if (right->type != EXPR_COMPARE || right->op != SPECIAL_NOTEQUAL)
+		return;
+	if (!inconsistent_check(left, right))
+		return;
+
+	sm_warning("was && intended here instead of ||?");
+}
+
+static int is_kernel_min_macro(struct expression *expr)
+{
+	char *macro;
+
+	if (option_project != PROJ_KERNEL)
+		return 0;
+	macro = get_macro_name(expr->pos);
+	if (!macro)
+		return 0;
+	if (strcmp(macro, "min") == 0 ||
+	    strcmp(macro, "min_t") == 0 ||
+	    strcmp(macro, "max") == 0 ||
+	    strcmp(macro, "max_t") == 0)
+		return 1;
+	return 0;
+}
+
+static void check_and(struct expression *expr)
+{
+	struct expression *left, *right;
+
+	if (is_kernel_min_macro(expr))
+		return;
+
+	left = strip_expr(expr->left);
+	right = strip_expr(expr->right);
+
+	if (left->type != EXPR_COMPARE || left->op != SPECIAL_EQUAL)
+		return;
+	if (right->type != EXPR_COMPARE || right->op != SPECIAL_EQUAL)
+		return;
+	if (!inconsistent_check(left, right))
+		return;
+
+	sm_warning("was || intended here instead of &&?");
+}
+
+static void match_logic(struct expression *expr)
+{
+	if (expr->type != EXPR_LOGICAL)
+		return;
+
+	if (expr->op == SPECIAL_LOGICAL_OR)
+		check_or(expr);
+	if (expr->op == SPECIAL_LOGICAL_AND)
+		check_and(expr);
+}
+
+static int is_unconstant_macro(struct expression *expr)
+{
+	char *macro;
+
+	macro = get_macro_name(expr->pos);
+	if (!macro)
+		return 0;
+	if (search_unconstant_macros(unconstant_macros, macro))
+		return 1;
+	return 0;
+}
+
+static void match_condition(struct expression *expr)
+{
+	sval_t sval;
+
+	if (expr->type != EXPR_BINOP)
+		return;
+	if (expr->op == '|') {
+		if (get_value(expr->left, &sval) || get_value(expr->right, &sval))
+			sm_warning("suspicious bitop condition");
+		return;
+	}
+
+	if (expr->op != '&')
+		return;
+
+	if (get_macro_name(expr->pos))
+		return;
+	if (is_unconstant_macro(expr->left) || is_unconstant_macro(expr->right))
+		return;
+
+	if ((get_value(expr->left, &sval) && sval.value == 0) ||
+	    (get_value(expr->right, &sval) && sval.value == 0))
+		sm_warning("bitwise AND condition is false here");
+}
+
+static void match_binop(struct expression *expr)
+{
+	sval_t left, right, sval;
+
+	if (expr->op != '&')
+		return;
+	if (!get_value(expr, &sval) || sval.value != 0)
+		return;
+	if (get_macro_name(expr->pos))
+		return;
+	if (!get_value(expr->left, &left) || !get_value(expr->right, &right))
+		return;
+	sm_warning("odd binop '0x%llx & 0x%llx'", left.uvalue, right.uvalue);
+}
+
+void check_or_vs_and(int id)
+{
+	my_id = id;
+
+	unconstant_macros = create_function_hashtable(100);
+	load_strings("unconstant_macros", unconstant_macros);
+
+	add_hook(&match_logic, LOGIC_HOOK);
+	add_hook(&match_condition, CONDITION_HOOK);
+	if (option_spammy)
+		add_hook(&match_binop, BINOP_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_param_mapper.c b/usr/src/tools/smatch/src/check_param_mapper.c
new file mode 100644
index 0000000000..b850f04dac
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_param_mapper.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The idea behind this test is that if we have:
+ * void foo(int bar)
+ * {
+ *         baz(1, bar);
+ * }
+ *
+ * Passing "bar" to foo() really means passing "bar" to baz();
+ * 
+ * In this case it would print:
+ * info: param_mapper 0 => bar 1
+ *
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+STATE(argument);
+
+static struct symbol *func_sym;
+
+static void delete(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &undefined);
+}
+
+static void match_function_def(struct symbol *sym)
+{
+	struct symbol *arg;
+
+	func_sym = sym;
+	FOR_EACH_PTR(func_sym->ctype.base_type->arguments, arg) {
+		if (!arg->ident) {
+			continue;
+		}
+		set_state(my_id, arg->ident->name, arg, &argument);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static int get_arg_num(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct symbol *arg;
+	struct symbol *this_arg;
+	int i;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_SYMBOL)
+		return -1;
+	this_arg = expr->symbol;
+
+	state = get_state_expr(my_id, expr);
+	if (!state || state != &argument)
+		return -1;
+	
+	i = 0;
+	FOR_EACH_PTR(func_sym->ctype.base_type->arguments, arg) {
+		if (arg == this_arg)
+			return i;
+		i++;
+	} END_FOR_EACH_PTR(arg);
+
+	return -1;
+}
+
+static void match_call(struct expression *expr)
+{
+	struct expression *tmp;
+	char *func;
+	int arg_num;
+	int i;
+
+	if (expr->fn->type != EXPR_SYMBOL)
+		return;
+
+	func = expr->fn->symbol_name->name;
+
+	i = 0;
+	FOR_EACH_PTR(expr->args, tmp) {
+		tmp = strip_expr(tmp);
+		arg_num = get_arg_num(tmp);
+		if (arg_num >= 0)
+			sm_msg("info: param_mapper %d => %s %d", arg_num, func, i);
+		i++;
+	} END_FOR_EACH_PTR(tmp);
+}
+
+void check_param_mapper(int id)
+{
+	if (!option_param_mapper)
+		return;
+	my_id = id;
+	add_modification_hook(my_id, &delete);
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_passes_sizeof.c b/usr/src/tools/smatch/src/check_passes_sizeof.c
new file mode 100644
index 0000000000..8dc2ba0816
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_passes_sizeof.c
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+#define NOBUF -2
+
+static int my_id;
+
+static struct expression *get_returned_expr(struct expression *expr)
+{
+	struct statement *stmt;
+
+	stmt = last_ptr_list((struct ptr_list *)big_statement_stack);
+	if (!stmt || stmt->type != STMT_EXPRESSION || !stmt->expression)
+		return NULL;
+	if (stmt->expression->type != EXPR_ASSIGNMENT)
+		return NULL;
+	if (stmt->expression->right != expr)
+		return NULL;
+	return stmt->expression->left;
+}
+
+static struct expression *remove_dereference(struct expression *expr)
+{
+	if (!expr || expr->type != EXPR_PREOP || expr->op != '*')
+		return expr;
+	expr = expr->unop;
+	if (!expr || expr->type != EXPR_PREOP || expr->op != '*')
+		return expr;
+	return expr->unop;
+}
+
+static int get_buf_number(struct expression *call, struct expression *size_arg)
+{
+	struct expression *arg;
+	int idx = -1;
+
+	size_arg = strip_expr(size_arg->cast_expression);
+	size_arg = remove_dereference(size_arg);
+
+	arg = get_returned_expr(call);
+	if (arg && expr_equiv(arg, size_arg))
+		return idx;
+
+	FOR_EACH_PTR(call->args, arg) {
+		idx++;
+		if (expr_equiv(arg, size_arg))
+			return idx;
+	} END_FOR_EACH_PTR(arg);
+
+	return NOBUF;
+}
+
+static void match_call(struct expression *call)
+{
+	struct expression *arg;
+	char *name;
+	int buf_nr;
+	int i = -1;
+
+	if (call->fn->type != EXPR_SYMBOL)
+		return;
+
+	name = expr_to_var(call->fn);
+	FOR_EACH_PTR(call->args, arg) {
+		i++;
+		if (arg->type != EXPR_SIZEOF)
+			continue;
+		buf_nr = get_buf_number(call, arg);
+		if (buf_nr == NOBUF)
+			sm_msg("info: sizeof_param '%s' %d", name, i);
+		else
+			sm_msg("info: sizeof_param '%s' %d %d", name, i, buf_nr);
+	} END_FOR_EACH_PTR(arg);
+	free_string(name);
+}
+
+void check_passes_sizeof(int id)
+{
+	if (!option_info)
+		return;
+
+	my_id = id;
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_platform_device_put.c b/usr/src/tools/smatch/src/check_platform_device_put.c
new file mode 100644
index 0000000000..bf744eb39d
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_platform_device_put.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+#define MAX_ERRNO 4095
+
+STATE(added);
+STATE(not_added);
+
+static void match_added(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *unused)
+{
+	struct expression *arg_expr;
+
+	arg_expr = get_argument_from_call_expr(call_expr->args, 0);
+	set_state_expr(my_id, arg_expr, &added);
+}
+
+static void match_not_added(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *unused)
+{
+	struct expression *arg_expr;
+
+	arg_expr = get_argument_from_call_expr(call_expr->args, 0);
+	set_state_expr(my_id, arg_expr, &not_added);
+}
+
+static void match_platform_device_del(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *arg_expr;
+	struct sm_state *sm;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 0);
+	sm = get_sm_state_expr(my_id, arg_expr);
+	if (!sm)
+		return;
+	if (!slist_has_state(sm->possible, &not_added))
+		return;
+	sm_warning("perhaps platform_device_put() was intended here?");
+}
+
+void check_platform_device_put(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	my_id = id;
+
+	return_implies_state("platform_device_add", 0, 0, &match_added, NULL);
+	return_implies_state("platform_device_add", -MAX_ERRNO, -1, &match_not_added, NULL);
+	add_function_hook("platform_device_del", &match_platform_device_del, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_pointer_math.c b/usr/src/tools/smatch/src/check_pointer_math.c
new file mode 100644
index 0000000000..d0b9a0b4c0
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_pointer_math.c
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+STATE(size_in_bytes);
+
+static void set_undefined(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state == &size_in_bytes)
+		set_state(my_id, sm->name, sm->sym, &undefined);
+}
+
+static int is_sizeof(struct expression *expr)
+{
+	return (expr->type == EXPR_SIZEOF);
+}
+
+static int is_macro(struct expression *expr, const char *macro_name)
+{
+	char *name;
+	struct expression *outside_expr;
+
+	/* check that we aren't inside the macro itself */
+	outside_expr = last_ptr_list((struct ptr_list *)big_expression_stack);
+	if (outside_expr && positions_eq(expr->pos, outside_expr->pos))
+		return 0;
+
+	name = get_macro_name(expr->pos);
+	if (name && strcmp(name, macro_name) == 0)
+		return 1;
+	return 0;
+}
+
+static int is_size_in_bytes(struct expression *expr)
+{
+	if (is_sizeof(expr))
+		return 1;
+
+	if (is_macro(expr, "offsetof"))
+		return 1;
+	if (is_macro(expr, "PAGE_SIZE"))
+		return 1;
+
+	if (get_state_expr(my_id, expr) == &size_in_bytes)
+		return 1;
+
+	return 0;
+}
+
+static void match_binop(struct expression *expr)
+{
+	struct symbol *type;
+	char *name;
+	int size;
+
+	if (expr->op != '+')
+		return;
+	type = get_pointer_type(expr->left);
+	if (!type)
+		return;
+	if (type_bits(type) <= 8) /* ignore void, bool and char pointers*/
+		return;
+	if (!is_size_in_bytes(expr->right))
+		return;
+
+	/* if we know it's within bounds then don't complain */
+	size = get_array_size(expr->left);
+	if (size) {
+		sval_t max;
+
+		get_absolute_max(expr->right, &max);
+		if (max.uvalue < size)
+			return;
+	}
+
+	name = expr_to_str(expr->left);
+	sm_warning("potential pointer math issue ('%s' is a %d bit pointer)",
+	       name, type_bits(type));
+	free_string(name);
+}
+
+static void match_assign(struct expression *expr)
+{
+	if (expr->op != '=')
+		return;
+
+	if (!is_size_in_bytes(expr->right))
+		return;
+	set_state_expr(my_id, expr->left, &size_in_bytes);
+}
+
+static void check_assign(struct expression *expr)
+{
+	struct symbol *type;
+	char *name;
+
+	if (expr->op != SPECIAL_ADD_ASSIGN && expr->op != SPECIAL_SUB_ASSIGN)
+		return;
+
+	type = get_pointer_type(expr->left);
+	if (!type)
+		return;
+	if (type_bits(type) == 8 || type_bits(type) == -1)
+		return;
+	if (!is_size_in_bytes(expr->right))
+		return;
+	name = expr_to_var(expr->left);
+	sm_warning("potential pointer math issue ('%s' is a %d bit pointer)",
+	       name, type_bits(type));
+	free_string(name);
+}
+
+void check_pointer_math(int id)
+{
+	my_id = id;
+	add_hook(&match_binop, BINOP_HOOK);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&check_assign, ASSIGNMENT_HOOK);
+	add_modification_hook(my_id, &set_undefined);
+}
diff --git a/usr/src/tools/smatch/src/check_precedence.c b/usr/src/tools/smatch/src/check_precedence.c
new file mode 100644
index 0000000000..3ee062295c
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_precedence.c
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static int is_bool(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+	if (type_bits(type) == 1 && type->ctype.modifiers & MOD_UNSIGNED)
+		return 1;
+	return 0;
+}
+
+static int is_bool_from_context(struct expression *expr)
+{
+	sval_t sval;
+
+	if (!get_implied_max(expr, &sval) || sval.uvalue > 1)
+		return 0;
+	if (!get_implied_min(expr, &sval) || sval.value < 0)
+		return 0;
+	return 1;
+}
+
+static int is_bool_op(struct expression *expr)
+{
+	expr = strip_expr(expr);
+
+	if (expr->type == EXPR_PREOP && expr->op == '!')
+		return 1;
+	if (expr->type == EXPR_COMPARE)
+		return 1;
+	if (expr->type == EXPR_LOGICAL)
+		return 1;
+	return is_bool(expr);
+}
+
+static void match_condition(struct expression *expr)
+{
+	int print = 0;
+
+	if (expr->type == EXPR_COMPARE) {
+		if (expr->left->type == EXPR_COMPARE || expr->right->type == EXPR_COMPARE)
+			print = 1;
+		if (expr->left->type == EXPR_PREOP && expr->left->op == '!') {
+			if (expr->left->unop->type == EXPR_PREOP && expr->left->unop->op == '!')
+				return;
+			if (expr->right->op == '!')
+				return;
+			if (is_bool(expr->right))
+				return;
+			if (is_bool(expr->left->unop))
+				return;
+			if (is_bool_from_context(expr->left->unop))
+				return;
+			print = 1;
+		}
+	}
+
+	if (expr->type == EXPR_BINOP) {
+		if (expr->left->type == EXPR_COMPARE || expr->right->type == EXPR_COMPARE)
+			print = 1;
+	}
+
+	if (print) {
+		sm_warning("add some parenthesis here?");
+		return;
+	}
+
+	if (expr->type == EXPR_BINOP && expr->op == '&') {
+		int i = 0;
+
+		if (is_bool_op(expr->left))
+			i++;
+		if (is_bool_op(expr->right))
+			i++;
+		if (i == 1)
+			sm_warning("maybe use && instead of &");
+	}
+}
+
+static void match_binop(struct expression *expr)
+{
+	if (expr->op != '&')
+		return;
+	if (expr->left->op == '!')
+		sm_warning("add some parenthesis here?");
+}
+
+static void match_mask(struct expression *expr)
+{
+	if (expr->op != '&')
+		return;
+	if (expr->right->type != EXPR_BINOP)
+		return;
+	if (expr->right->op != SPECIAL_RIGHTSHIFT)
+		return;
+
+	sm_warning("shift has higher precedence than mask");
+}
+
+static void match_subtract_shift(struct expression *expr)
+{
+	if (expr->op != SPECIAL_LEFTSHIFT)
+		return;
+	if (expr->right->type != EXPR_BINOP)
+		return;
+	if (expr->right->op != '-')
+		return;
+	sm_warning("subtract is higher precedence than shift");
+}
+
+void check_precedence(int id)
+{
+	my_id = id;
+
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_binop, BINOP_HOOK);
+	add_hook(&match_mask, BINOP_HOOK);
+	add_hook(&match_subtract_shift, BINOP_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_proc_create.c b/usr/src/tools/smatch/src/check_proc_create.c
new file mode 100644
index 0000000000..025d217467
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_proc_create.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static struct {
+	int name_param;
+	int mode_param;
+} param_index[] = {
+	{.name_param = 0, .mode_param = 1},
+	{.name_param = 1, .mode_param = 2},
+};
+
+#define S_IWOTH 00002
+
+static void match_create(const char *fn, struct expression *expr, void *_param_type)
+{
+	struct expression *arg_expr;
+	sval_t sval;
+	char *name;
+	int idx = PTR_INT(_param_type);
+
+	arg_expr = get_argument_from_call_expr(expr->args, param_index[idx].mode_param);
+	if (!get_implied_value(arg_expr, &sval))
+		return;
+	if (!(sval.uvalue & S_IWOTH))
+		return;
+	arg_expr = get_argument_from_call_expr(expr->args, param_index[idx].name_param);
+	name = expr_to_var(arg_expr);
+	sm_warning("proc file '%s' is world writable", name);
+	free_string(name);
+}
+
+void check_proc_create(int id)
+{
+	my_id = id;
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_function_hook("proc_create", &match_create, INT_PTR(0));
+	add_function_hook("create_proc_entry", &match_create, INT_PTR(0));
+	add_function_hook("proc_create_data", &match_create, INT_PTR(0));
+	add_function_hook("proc_net_fops_create", match_create, INT_PTR(1));
+}
diff --git a/usr/src/tools/smatch/src/check_puts_argument.c b/usr/src/tools/smatch/src/check_puts_argument.c
new file mode 100644
index 0000000000..a437b8d471
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_puts_argument.c
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/* 
+ * This script is for finding functions like hcd_buffer_free() which free
+ * their arguments.  After running it, add those functions to check_memory.c
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(putted);
+
+static struct symbol *this_func;
+static struct tracker_list *putted_args = NULL;
+
+static void match_function_def(struct symbol *sym)
+{
+	this_func = sym;
+}
+
+static int parent_is_arg(struct symbol *sym)
+{
+	struct symbol *arg;
+
+	FOR_EACH_PTR(this_func->ctype.base_type->arguments, arg) {
+		if (sym == arg)
+			return 1;
+	} END_FOR_EACH_PTR(arg);
+	return 0;
+}
+
+static void match_put(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *tmp;
+	struct symbol *sym;
+	char *name;
+
+	tmp = get_argument_from_call_expr(expr->args, 0);
+	tmp = strip_expr(tmp);
+	name = expr_to_var_sym(tmp, &sym);
+	free_string(name);
+	if (parent_is_arg(sym) && sym->ident)
+		set_state(my_id, sym->ident->name, sym, &putted);
+}
+
+static int return_count = 0;
+static void match_return(struct expression *ret_value)
+{
+	struct stree *stree;
+	struct sm_state *tmp;
+	struct tracker *tracker;
+
+	if (__inline_fn)
+		return;
+
+	if (!return_count) {
+		stree = __get_cur_stree();
+		FOR_EACH_MY_SM(my_id, stree, tmp) {
+			if (tmp->state == &putted)
+				add_tracker(&putted_args, my_id, tmp->name, 
+					    tmp->sym);
+		} END_FOR_EACH_SM(tmp);
+	} else {
+		FOR_EACH_PTR(putted_args, tracker) {
+			tmp = get_sm_state(my_id, tracker->name, tracker->sym);
+			if (tmp && tmp->state != &putted)
+				del_tracker(&putted_args, my_id, tracker->name, 
+					    tracker->sym);
+		} END_FOR_EACH_PTR(tracker);
+		
+	}
+}
+
+static void print_arg(struct symbol *sym)
+{
+	struct symbol *arg;
+	int i = 0;
+
+	FOR_EACH_PTR(this_func->ctype.base_type->arguments, arg) {
+		if (sym == arg) {
+			sm_info("puts_arg %s %d", get_function(), i);
+			return;
+		}
+		i++;
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	struct tracker *tracker;
+
+	if (__inline_fn)
+		return;
+	if (is_reachable())
+		match_return(NULL);
+
+	FOR_EACH_PTR(putted_args, tracker) {
+		print_arg(tracker->sym);
+	} END_FOR_EACH_PTR(tracker);
+
+	free_trackers_and_list(&putted_args);
+	return_count = 0;
+}
+
+void check_puts_argument(int id)
+{
+	if (!option_info || option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+	add_function_hook("kobject_put", &match_put, NULL);
+	add_function_hook("kref_put", &match_put, NULL);
+	add_hook(&match_return, RETURN_HOOK);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_readl_infinite_loops.c b/usr/src/tools/smatch/src/check_readl_infinite_loops.c
new file mode 100644
index 0000000000..8f3ca92ec5
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_readl_infinite_loops.c
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(readl);
+STATE(readl_ff);
+STATE(readl_00);
+
+DECLARE_PTR_LIST(state_stack, struct smatch_state);
+struct state_stack *state_at_start;
+
+static int readl_has_been_called;
+static int returned;
+
+static int is_readl_call(struct expression *expr)
+{
+	struct symbol *sym;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_CALL)
+		return 0;
+	if (expr->fn->type != EXPR_SYMBOL)
+		return 0;
+	sym = expr->fn->symbol;
+	if (!sym || !sym->ident)
+		return 0;
+	if (strcmp(sym->ident->name, "readl") != 0)
+		return 0;
+	return 1;
+}
+
+static int is_readl(struct expression *expr)
+{
+	if (is_readl_call(expr))
+		return 1;
+	if (get_state_expr(my_id, expr) == &readl)
+		return 1;
+	return 0;
+}
+
+static void match_assign(struct expression *expr)
+{
+	if (is_readl(expr->right))
+		set_state_expr(my_id, expr->left, &readl);
+	else if (get_state_expr(my_id, expr->left))
+		set_state_expr(my_id, expr->left, &undefined);
+}
+
+static int condition_depends_on_readl(struct expression *expr)
+{
+	if (expr->type == EXPR_BINOP) {
+		if (condition_depends_on_readl(expr->left))
+			return 1;
+		if (condition_depends_on_readl(expr->right))
+			return 1;
+		return 0;
+	}
+	if (is_readl(expr))
+		return 1;
+	return 0;
+}
+
+static void check_condition(struct expression *expr)
+{
+	if (expr->op != '&')
+		return;
+	if (!condition_depends_on_readl(expr))
+		return;
+	readl_has_been_called = 1;
+	set_true_false_states(my_id, "depends on", NULL, &readl_ff, &readl_00);
+}
+
+static void match_return(struct expression *expr)
+{
+
+	if (__inline_fn)
+		return;
+	returned = 1;
+#if 0
+	struct smatch_state *tmp;
+
+	if (!readl_has_been_called)
+		return;
+
+	FOR_EACH_PTR(state_at_start, tmp) {
+		REPLACE_CURRENT_PTR(tmp, NULL);
+	}
+#endif
+}
+
+static void push_state_at_start(struct smatch_state *state)
+{
+	add_ptr_list(&state_at_start, state);
+}
+
+static struct smatch_state *pop_state_at_start(void)
+{
+	struct smatch_state *state;
+
+	state = last_ptr_list((struct ptr_list *)state_at_start);
+	delete_ptr_list_last((struct ptr_list **)&state_at_start);
+	return state;
+}
+
+static void before_loop(struct statement *stmt)
+{
+	struct smatch_state *state;
+
+	if (!stmt || stmt->type != STMT_ITERATOR)
+		return;
+	if (ptr_list_empty(state_at_start))
+		returned = 0;
+	state = get_state(my_id, "depends on", NULL);
+	push_state_at_start(state);
+}
+
+static void after_loop(struct statement *stmt)
+{
+	struct smatch_state *old_state;
+
+	if (!stmt || stmt->type != STMT_ITERATOR)
+		return;
+	old_state = pop_state_at_start();
+	if (old_state == &readl_00)
+		return;
+	if (returned)
+		return;
+	if (get_state(my_id, "depends on", NULL) != &readl_00)
+		return;
+	sm_warning("this loop depends on readl() succeeding");
+}
+
+void check_readl_infinite_loops(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+
+	add_hook(match_assign, ASSIGNMENT_HOOK);
+	add_hook(check_condition, CONDITION_HOOK);
+
+	add_hook(&match_return, RETURN_HOOK);
+
+	add_hook(before_loop, STMT_HOOK);
+	add_hook(after_loop, STMT_HOOK_AFTER);
+}
diff --git a/usr/src/tools/smatch/src/check_release_resource.c b/usr/src/tools/smatch/src/check_release_resource.c
new file mode 100644
index 0000000000..b6f9d626e1
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_release_resource.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * I found a bug where someone released the wrong resource and wanted to 
+ * prevent that from happening again.
+ *
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static struct tracker_list *resource_list;
+
+static void match_request(const char *fn, struct expression *expr, void *_arg_no)
+{
+	struct expression *arg_expr;
+	int arg_no = PTR_INT(_arg_no);
+	char *name;
+	struct symbol *sym;
+
+	arg_expr = get_argument_from_call_expr(expr->args, arg_no);
+	arg_expr = strip_expr(arg_expr);
+
+	name = expr_to_var_sym(arg_expr, &sym);
+	if (!name || !sym)
+		goto free;
+	add_tracker(&resource_list, my_id, name, sym);
+free:
+	free_string(name);
+}
+
+static void match_release(const char *fn, struct expression *expr, void *_arg_no)
+{
+	struct expression *arg_expr;
+	int arg_no = PTR_INT(_arg_no);
+	char *name;
+	struct symbol *sym;
+
+	arg_expr = get_argument_from_call_expr(expr->args, arg_no);
+	arg_expr = strip_expr(arg_expr);
+
+	if (!resource_list)
+		return;
+
+	name = expr_to_var_sym(arg_expr, &sym);
+	if (!name || !sym)
+		goto free;
+	if (in_tracker_list(resource_list, my_id, name, sym))
+		goto free;
+	sm_warning("'%s' was not one of the resources you requested", name);
+free:
+	free_string(name);
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	free_trackers_and_list(&resource_list);
+}
+
+void check_release_resource(int id)
+{
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_function_hook("request_resource", &match_request, (void *)1);
+	add_function_hook("release_resource", &match_release, (void *)0);
+	add_function_hook("request_mem_resource", &match_request, (void *)0);
+	add_function_hook("release_mem_resource", &match_release, (void *)0);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_resource_size.c b/usr/src/tools/smatch/src/check_resource_size.c
new file mode 100644
index 0000000000..8bacb18e35
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_resource_size.c
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+extern int check_assigned_expr_id;
+
+static int is_probably_ok(struct expression *expr)
+{
+	expr = strip_expr(expr);
+
+	if (expr->type == EXPR_BINOP)
+		return 1;
+	if (expr->type == EXPR_SIZEOF)
+		return 1;
+
+	return 0;
+}
+
+static void verify_size_expr(struct expression *expr)
+{
+	if (expr->type != EXPR_BINOP)
+		return;
+	if (expr->op != '-')
+		return;
+	if (is_probably_ok(expr->left))
+		return;
+	if (is_probably_ok(expr->right))
+		return;
+	sm_warning("consider using resource_size() here");
+}
+
+static void handle_assigned_expr(struct expression *expr)
+{
+	struct smatch_state *state;
+
+	state = get_state_expr(check_assigned_expr_id, expr);
+	if (!state || !state->data)
+		return;
+	expr = (struct expression *)state->data;
+	verify_size_expr(expr);
+}
+
+static void match_resource(const char *fn, struct expression *expr, void *_arg_no)
+{
+	struct expression *arg_expr;
+	int arg_no = PTR_INT(_arg_no);
+
+	arg_expr = get_argument_from_call_expr(expr->args, arg_no);
+	arg_expr = strip_expr(arg_expr);
+	if (!arg_expr)
+		return;
+
+	if (arg_expr->type == EXPR_SYMBOL) {
+		handle_assigned_expr(arg_expr);
+		return;
+	}
+	verify_size_expr(arg_expr);
+}
+
+void check_resource_size(int id)
+{
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_function_hook("ioremap_nocache", &match_resource, (void *)1);
+	add_function_hook("ioremap", &match_resource, (void *)1);
+	add_function_hook("__request_region", &match_resource, (void *)2);
+	add_function_hook("__release_region", &match_resource, (void *)2);
+	add_function_hook("__devm_request_region", &match_resource, (void *)3);
+	add_function_hook("__devm_release_region", &match_resource, (void *)3);
+}
diff --git a/usr/src/tools/smatch/src/check_return.c b/usr/src/tools/smatch/src/check_return.c
new file mode 100644
index 0000000000..3915fbe080
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_return.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static void must_check(const char *fn, struct expression *expr, void *data)
+{
+	struct statement *stmt;
+
+	stmt = last_ptr_list((struct ptr_list *)big_statement_stack);
+	if (stmt->type == STMT_EXPRESSION && stmt->expression == expr)
+		sm_warning("unchecked '%s'", fn);
+}
+
+static void register_must_check_funcs(void)
+{
+	struct token *token;
+	const char *func;
+	static char name[256];
+
+
+	snprintf(name, 256, "%s.must_check_funcs", option_project_str);
+	name[255] = '\0';
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		add_function_hook(func, &must_check, NULL);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_return(int id)
+{
+	my_id = id;
+	register_must_check_funcs();
+}
diff --git a/usr/src/tools/smatch/src/check_return_cast.c b/usr/src/tools/smatch/src/check_return_cast.c
new file mode 100644
index 0000000000..5a87a6e27f
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_return_cast.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Complains about places that return -1 instead of -ENOMEM
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_return(struct expression *ret_value)
+{
+	struct symbol *func_type = get_real_base_type(cur_func_sym);
+	sval_t sval;
+
+	if (!func_type)
+		return;
+	if (!type_unsigned(func_type))
+		return;
+	if (type_bits(func_type) > 16)
+		return;
+	if (!get_fuzzy_min(ret_value, &sval))
+		return;
+	if (sval_is_positive(sval) || sval_cmp_val(sval, -1) == 0)
+		return;
+
+	sm_warning("signedness bug returning '%s'", sval_to_str(sval));
+}
+
+void check_return_cast(int id)
+{
+	my_id = id;
+	add_hook(&match_return, RETURN_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_return_efault.c b/usr/src/tools/smatch/src/check_return_efault.c
new file mode 100644
index 0000000000..20cb14ea46
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_return_efault.c
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This tries to find places which should probably return -EFAULT
+ * but return the number of bytes to copy instead.
+ */
+
+#include <string.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(remaining);
+STATE(ok);
+
+static void ok_to_use(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state != &ok)
+		set_state(my_id, sm->name, sm->sym, &ok);
+}
+
+static void match_copy(const char *fn, struct expression *expr, void *unused)
+{
+	if (expr->op == SPECIAL_SUB_ASSIGN)
+		return;
+	set_state_expr(my_id, expr->left, &remaining);
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (!get_state_expr(my_id, expr))
+		return;
+	/* If the variable is zero that's ok */
+	set_true_false_states_expr(my_id, expr, NULL, &ok);
+}
+
+/*
+ * This function is biased in favour of print out errors.
+ * The heuristic to print is:
+ *    If we have a potentially positive return from copy_to_user
+ *    and there is a possibility that we return negative as well
+ *    then complain.
+ */
+static void match_return_var(struct expression *ret_value)
+{
+	struct smatch_state *state;
+	struct sm_state *sm;
+	sval_t min;
+
+	sm = get_sm_state_expr(my_id, ret_value);
+	if (!sm)
+		return;
+	if (!slist_has_state(sm->possible, &remaining))
+		return;
+	state = get_state_expr(SMATCH_EXTRA, ret_value);
+	if (!state)
+		return;
+	if (!get_absolute_min(ret_value, &min))
+		return;
+	if (min.value == 0)
+		return;
+	sm_warning("maybe return -EFAULT instead of the bytes remaining?");
+}
+
+static void match_return_call(struct expression *ret_value)
+{
+	struct expression *fn;
+	struct range_list *rl;
+	const char *fn_name;
+	char *cur_func;
+
+	if (!ret_value || ret_value->type != EXPR_CALL)
+		return;
+	cur_func = get_function();
+	if (!cur_func)
+		return;
+	if (strstr(cur_func, "_to_user") ||
+	    strstr(cur_func, "_from_user"))
+		return;
+
+	fn = strip_expr(ret_value->fn);
+	if (fn->type != EXPR_SYMBOL)
+		return;
+	fn_name = fn->symbol_name->name;
+	if (strcmp(fn_name, "copy_to_user") != 0 &&
+	    strcmp(fn_name, "__copy_to_user") != 0 &&
+	    strcmp(fn_name, "copy_from_user") != 0 &&
+	    strcmp(fn_name, "__copy_from_user"))
+		return;
+
+	rl = db_return_vals_from_str(get_function());
+	if (!rl)
+		return;
+
+	if (!sval_is_negative(rl_min(rl)))
+		return;
+	sm_warning("maybe return -EFAULT instead of the bytes remaining?");
+}
+
+void check_return_efault(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_function_assign_hook("copy_to_user", &match_copy, NULL);
+	add_function_assign_hook("__copy_to_user", &match_copy, NULL);
+	add_function_assign_hook("copy_from_user", &match_copy, NULL);
+	add_function_assign_hook("__copy_from_user", &match_copy, NULL);
+	add_function_assign_hook("clear_user", &match_copy, NULL);
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_return_var, RETURN_HOOK);
+	add_hook(&match_return_call, RETURN_HOOK);
+	add_modification_hook(my_id, &ok_to_use);
+}
diff --git a/usr/src/tools/smatch/src/check_return_enomem.c b/usr/src/tools/smatch/src/check_return_enomem.c
new file mode 100644
index 0000000000..afd0f55676
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_return_enomem.c
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Complains about places that return -1 instead of -ENOMEM
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static void match_return(struct expression *ret_value)
+{
+	struct expression *expr;
+	struct sm_state *sm;
+	struct stree *stree;
+	sval_t sval;
+
+	if (!ret_value)
+		return;
+	if (returns_unsigned(cur_func_sym))
+		return;
+	if (returns_pointer(cur_func_sym))
+		return;
+	if (!get_value(ret_value, &sval) || sval.value != -1)
+		return;
+	if (get_macro_name(ret_value->pos))
+		return;
+
+	stree = __get_cur_stree();
+
+	FOR_EACH_MY_SM(SMATCH_EXTRA, stree, sm) {
+		if (!estate_get_single_value(sm->state, &sval) || sval.value != 0)
+			continue;
+		expr = get_assigned_expr_name_sym(sm->name, sm->sym);
+		if (!expr)
+			continue;
+		if (expr->type != EXPR_CALL || expr->fn->type != EXPR_SYMBOL)
+			continue;
+		if (!expr->fn->symbol_name)
+			continue;
+		/* To be honest the correct check is:
+		 * if (strstr(expr->fn->symbol_name->name, "alloc"))
+		 * 	complain();
+		 * But it generates too many warnings and it's too depressing.
+		 */
+		if (strcmp(expr->fn->symbol_name->name, "kmalloc") != 0 &&
+		    strcmp(expr->fn->symbol_name->name, "kzalloc") != 0)
+			continue;
+
+		sm_warning("returning -1 instead of -ENOMEM is sloppy");
+		return;
+
+	} END_FOR_EACH_SM(sm);
+}
+
+void check_return_enomem(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_hook(&match_return, RETURN_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_return_negative_var.c b/usr/src/tools/smatch/src/check_return_negative_var.c
new file mode 100644
index 0000000000..9a18a43f22
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_return_negative_var.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2011 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static void match_return(struct expression *ret_value)
+{
+	struct expression *expr;
+	char *macro;
+
+	if (!ret_value)
+		return;
+	expr = ret_value;
+	if (ret_value->type != EXPR_PREOP || ret_value->op != '-')
+		return;
+
+	macro = get_macro_name(expr->unop->pos);
+	if (macro && !strcmp(macro, "PTR_ERR")) {
+		sm_warning("returning -%s()", macro);
+		return;
+	}
+
+	if (!option_spammy)
+		return;
+
+	expr = get_assigned_expr(ret_value->unop);
+	if (!expr)
+		return;
+	if (expr->type != EXPR_CALL)
+		return;
+
+	sm_warning("should this return really be negated?");
+}
+
+void check_return_negative_var(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_hook(&match_return, RETURN_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_rosenberg.c b/usr/src/tools/smatch/src/check_rosenberg.c
new file mode 100644
index 0000000000..bde603a706
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_rosenberg.c
@@ -0,0 +1,387 @@
+/*
+ * Copyright (C) 2011 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/* Does a search for Dan Rosenberg style info leaks */
+
+/* fixme: struct includes a struct with a hole in it */
+/* function is called that clears the struct */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_function_hashtable.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_whole_id;
+static int my_member_id;
+
+STATE(cleared);
+
+static void extra_mod_hook(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	struct symbol *type;
+
+	type = get_real_base_type(sym);
+	if (!type || type->type != SYM_STRUCT)
+		return;
+
+	set_state(my_member_id, name, sym, state);
+}
+
+static void print_holey_warning(struct expression *data, const char *member)
+{
+	char *name;
+
+	name = expr_to_str(data);
+	if (member) {
+		sm_warning("check that '%s' doesn't leak information (struct has a hole after '%s')",
+		       name, member);
+	} else {
+		sm_warning("check that '%s' doesn't leak information (struct has holes)",
+		       name);
+	}
+	free_string(name);
+}
+
+static int check_struct(struct expression *expr, struct symbol *type)
+{
+	struct symbol *tmp, *base_type;
+	const char *prev = NULL;
+	int align;
+
+	if (type->ctype.alignment == 1)
+		return 0;
+
+	align = 0;
+	FOR_EACH_PTR(type->symbol_list, tmp) {
+		base_type = get_real_base_type(tmp);
+		if (base_type && base_type->type == SYM_STRUCT) {
+			if (check_struct(expr, base_type))
+				return 1;
+		}
+
+		if (!tmp->ctype.alignment) {
+			sm_perror("cannot determine the alignment here");
+		} else if (align % tmp->ctype.alignment) {
+			print_holey_warning(expr, prev);
+			return 1;
+		}
+
+		if (base_type == &bool_ctype)
+			align += 1;
+		else if (type_bits(tmp) <= 0)
+			align = 0;
+		else
+			align += type_bytes(tmp);
+
+		if (tmp->ident)
+			prev = tmp->ident->name;
+		else
+			prev = NULL;
+	} END_FOR_EACH_PTR(tmp);
+
+	if (align % type->ctype.alignment) {
+		print_holey_warning(expr, prev);
+		return 1;
+	}
+
+	return 0;
+}
+
+static int warn_on_holey_struct(struct expression *expr)
+{
+	struct symbol *type;
+	type = get_type(expr);
+	if (!type || type->type != SYM_STRUCT)
+		return 0;
+
+	return check_struct(expr, type);
+}
+
+static int has_global_scope(struct expression *expr)
+{
+	struct symbol *sym;
+
+	if (expr->type != EXPR_SYMBOL)
+		return FALSE;
+	sym = expr->symbol;
+	if (!sym)
+		return FALSE;
+	return toplevel(sym->scope);
+}
+
+static int was_initialized(struct expression *expr)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name)
+		return 0;
+	if (sym->initializer)
+		return 1;
+	return 0;
+}
+
+static void match_clear(const char *fn, struct expression *expr, void *_arg_no)
+{
+	struct expression *ptr;
+	int arg_no = PTR_INT(_arg_no);
+
+	ptr = get_argument_from_call_expr(expr->args, arg_no);
+	if (!ptr)
+		return;
+	ptr = strip_expr(ptr);
+	if (ptr->type != EXPR_PREOP || ptr->op != '&')
+		return;
+	ptr = strip_expr(ptr->unop);
+	set_state_expr(my_whole_id, ptr, &cleared);
+}
+
+static int was_memset(struct expression *expr)
+{
+	if (get_state_expr(my_whole_id, expr) == &cleared)
+		return 1;
+	return 0;
+}
+
+static int member_initialized(char *name, struct symbol *outer, struct symbol *member, int pointer)
+{
+	char buf[256];
+	struct symbol *base;
+
+	base = get_base_type(member);
+	if (!base || base->type != SYM_BASETYPE || !member->ident)
+		return FALSE;
+
+	if (pointer)
+		snprintf(buf, 256, "%s->%s", name, member->ident->name);
+	else
+		snprintf(buf, 256, "%s.%s", name, member->ident->name);
+
+	if (get_state(my_member_id, buf, outer))
+		return TRUE;
+
+	return FALSE;
+}
+
+static int member_uninitialized(char *name, struct symbol *outer, struct symbol *member, int pointer)
+{
+	char buf[256];
+	struct symbol *base;
+	struct sm_state *sm;
+
+	base = get_base_type(member);
+	if (!base || base->type != SYM_BASETYPE || !member->ident)
+		return FALSE;
+
+	if (pointer)
+		snprintf(buf, 256, "%s->%s", name, member->ident->name);
+	else
+		snprintf(buf, 256, "%s.%s", name, member->ident->name);
+
+	sm = get_sm_state(my_member_id, buf, outer);
+	if (sm && !slist_has_state(sm->possible, &undefined))
+		return FALSE;
+
+	sm_warning("check that '%s' doesn't leak information", buf);
+	return TRUE;
+}
+
+static int check_members_initialized(struct expression *expr)
+{
+	char *name;
+	struct symbol *outer;
+	struct symbol *sym;
+	struct symbol *tmp;
+	int pointer = 0;
+	int printed = 0;
+
+	sym = get_type(expr);
+	if (sym && sym->type == SYM_PTR) {
+		pointer = 1;
+		sym = get_real_base_type(sym);
+	}
+	if (!sym)
+		return 0;
+	if (sym->type != SYM_STRUCT)
+		return 0;
+
+	name = expr_to_var_sym(expr, &outer);
+
+	/*
+	 * check that at least one member was set.  If all of them were not set
+	 * it's more likely a problem in the check than a problem in the kernel
+	 * code.
+	 */
+	FOR_EACH_PTR(sym->symbol_list, tmp) {
+		if (member_initialized(name, outer, tmp, pointer))
+			goto check;
+	} END_FOR_EACH_PTR(tmp);
+	goto out;
+
+check:
+	FOR_EACH_PTR(sym->symbol_list, tmp) {
+		if (member_uninitialized(name, outer, tmp, pointer)) {
+			printed = 1;
+			goto out;
+		}
+	} END_FOR_EACH_PTR(tmp);
+out:
+	free_string(name);
+	return printed;
+}
+
+static void check_was_initialized(struct expression *data)
+{
+	data = strip_expr(data);
+	if (!data)
+		return;
+	if (data->type == EXPR_PREOP && data->op == '&')
+		data = strip_expr(data->unop);
+	if (data->type != EXPR_SYMBOL)
+		return;
+
+	if (has_global_scope(data))
+		return;
+	if (was_initialized(data))
+		return;
+	if (was_memset(data))
+		return;
+	if (warn_on_holey_struct(data))
+		return;
+	check_members_initialized(data);
+}
+
+static void match_copy_to_user(const char *fn, struct expression *expr, void *_arg)
+{
+	int arg = PTR_INT(_arg);
+	struct expression *data;
+
+	data = get_argument_from_call_expr(expr->args, arg);
+	data = strip_expr(data);
+	if (!data)
+		return;
+	if (data->type != EXPR_PREOP || data->op != '&')
+		return;
+	check_was_initialized(data);
+}
+
+static void db_param_cleared(struct expression *expr, int param, char *key, char *value)
+{
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	match_clear(NULL, expr, INT_PTR(param));
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr->left);
+	if (!type || type->type != SYM_STRUCT)
+		return;
+	set_state_expr(my_whole_id, expr->left, &cleared);
+}
+
+static void register_clears_argument(void)
+{
+	struct token *token;
+	const char *func;
+	int arg;
+
+	token = get_tokens_file("kernel.clears_argument");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		arg = atoi(token->number);
+
+		add_function_hook(func, &match_clear, INT_PTR(arg));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void register_copy_funcs_from_file(void)
+{
+	struct token *token;
+	const char *func;
+	int arg;
+
+	token = get_tokens_file("kernel.rosenberg_funcs");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		arg = atoi(token->number);
+		add_function_hook(func, &match_copy_to_user, INT_PTR(arg));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_rosenberg(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	my_whole_id = id;
+
+	add_function_hook("memset", &match_clear, INT_PTR(0));
+	add_function_hook("memcpy", &match_clear, INT_PTR(0));
+	add_function_hook("memzero", &match_clear, INT_PTR(0));
+	add_function_hook("__memset", &match_clear, INT_PTR(0));
+	add_function_hook("__memcpy", &match_clear, INT_PTR(0));
+	add_function_hook("__memzero", &match_clear, INT_PTR(0));
+	add_function_hook("__builtin_memset", &match_clear, INT_PTR(0));
+	add_function_hook("__builtin_memcpy", &match_clear, INT_PTR(0));
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	register_clears_argument();
+	select_return_states_hook(PARAM_CLEARED, &db_param_cleared);
+
+	register_copy_funcs_from_file();
+}
+
+void check_rosenberg2(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_member_id = id;
+	add_extra_mod_hook(&extra_mod_hook);
+}
+
diff --git a/usr/src/tools/smatch/src/check_select.c b/usr/src/tools/smatch/src/check_select.c
new file mode 100644
index 0000000000..b9e3d1bf8d
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_select.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static void match_select(struct expression *expr)
+{
+	if (expr->cond_true)
+		return;
+	expr = strip_expr(expr->conditional);
+	if (expr->type != EXPR_COMPARE)
+		return;
+	sm_warning("boolean comparison inside select");
+}
+
+void check_select(int id)
+{
+	my_id = id;
+	add_hook(&match_select, SELECT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_shift_to_zero.c b/usr/src/tools/smatch/src/check_shift_to_zero.c
new file mode 100644
index 0000000000..57cc3cbb84
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_shift_to_zero.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_binop(struct expression *expr)
+{
+	struct symbol *type;
+	sval_t bits;
+
+	if (expr->op != SPECIAL_RIGHTSHIFT)
+		return;
+
+	if (!get_implied_value(expr->right, &bits))
+		return;
+
+	type = get_type(expr->left);
+	if (!type)
+		return;
+	if (type_bits(type) == -1 || type_bits(type) > bits.value)
+		return;
+	sm_warning("right shifting more than type allows %d vs %lld", type_bits(type), bits.value);
+}
+
+static void match_binop2(struct expression *expr)
+{
+	struct expression *left;
+	struct expression *tmp;
+	sval_t mask, shift;
+
+	if (expr->op != SPECIAL_RIGHTSHIFT)
+		return;
+
+	left = strip_expr(expr->left);
+	tmp = get_assigned_expr(left);
+	if (tmp)
+		left = tmp;
+	if (left->type != EXPR_BINOP || left->op != '&')
+		return;
+
+	if (!get_implied_value(expr->right, &shift))
+		return;
+	if (!get_implied_value(left->right, &mask))
+		return;
+
+	if (mask.uvalue >> shift.uvalue)
+		return;
+
+	sm_warning("mask and shift to zero");
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct symbol *type;
+	sval_t bits;
+
+	if (expr->op != SPECIAL_SHR_ASSIGN)
+		return;
+
+	if (!get_implied_value(expr->right, &bits))
+		return;
+	type = get_type(expr->left);
+	if (!type)
+		return;
+	if (type_bits(type) > bits.value)
+		return;
+	sm_warning("right shift assign to zero");
+}
+
+void check_shift_to_zero(int id)
+{
+	my_id = id;
+
+	add_hook(&match_binop, BINOP_HOOK);
+	add_hook(&match_binop2, BINOP_HOOK);
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+
+}
diff --git a/usr/src/tools/smatch/src/check_signed.c b/usr/src/tools/smatch/src/check_signed.c
new file mode 100644
index 0000000000..d8435e9ce3
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_signed.c
@@ -0,0 +1,311 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Check for things which are signed but probably should be unsigned.
+ *
+ * Hm...  It seems like at this point in the processing, sparse makes all
+ * bitfields unsigned.  Which is logical but not what GCC does.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+#define VAR_ON_RIGHT 0
+#define VAR_ON_LEFT 1
+
+static void match_assign(struct expression *expr)
+{
+	struct symbol *sym;
+	sval_t sval;
+	sval_t max;
+	sval_t min;
+	char *left_name, *right_name;
+
+	if (__in_fake_assign)
+		return;
+	if (expr->op == SPECIAL_AND_ASSIGN || expr->op == SPECIAL_OR_ASSIGN)
+		return;
+
+	sym = get_type(expr->left);
+	if (!sym || sym->type != SYM_BASETYPE) {
+		//sm_msg("could not get type");
+		return;
+	}
+	if (type_bits(sym) < 0 || type_bits(sym) >= 32) /* max_val limits this */
+		return;
+	if (!get_implied_value(expr->right, &sval))
+		return;
+	max = sval_type_max(sym);
+	if (sym != &bool_ctype && sym != &uchar_ctype &&
+	    sval_cmp(max, sval) < 0 &&
+	    !(sval.value < 256 && max.value == 127)) {
+		left_name = expr_to_str(expr->left);
+		right_name = expr_to_str(expr->right);
+		sm_warning("'%s' %s can't fit into %s '%s'",
+		       right_name, sval_to_numstr(sval), sval_to_numstr(max), left_name);
+		free_string(left_name);
+	}
+	min = sval_type_min(sym);
+	if (sval_cmp_t(&llong_ctype, min, sval) > 0) {
+		if (min.value == 0 && sval.value == -1) /* assigning -1 to unsigned variables is idiomatic */
+			return;
+		if (expr->right->type == EXPR_PREOP && expr->right->op == '~')
+			return;
+		if (expr->op == SPECIAL_SUB_ASSIGN || expr->op == SPECIAL_ADD_ASSIGN)
+			return;
+		if (sval_positive_bits(sval) == 7)
+			return;
+		left_name = expr_to_str(expr->left);
+		if (min.value == 0) {
+			sm_warning("assigning %s to unsigned variable '%s'",
+			       sval_to_str(sval), left_name);
+		} else {
+			sm_warning("value %s can't fit into %s '%s'",
+			       sval_to_str(sval), sval_to_str(min), left_name);
+		}
+		free_string(left_name);
+	}
+}
+
+static int cap_gt_zero_and_lt(struct expression *expr)
+{
+
+	struct expression *var = expr->left;
+	struct expression *tmp;
+	char *name1 = NULL;
+	char *name2 = NULL;
+	sval_t known;
+	int ret = 0;
+	int i;
+
+	if (!get_value(expr->right, &known) || known.value != 0)
+		return 0;
+
+	i = 0;
+	FOR_EACH_PTR_REVERSE(big_expression_stack, tmp) {
+		if (!i++)
+			continue;
+		if (tmp->op == SPECIAL_LOGICAL_AND) {
+			struct expression *right = strip_expr(tmp->right);
+
+			if (right->op != '<' &&
+			    right->op != SPECIAL_UNSIGNED_LT &&
+			    right->op != SPECIAL_LTE &&
+			    right->op != SPECIAL_UNSIGNED_LTE)
+				return 0;
+
+			name1 = expr_to_str(var);
+			if (!name1)
+				goto free;
+
+			name2 = expr_to_str(right->left);
+			if (!name2)
+				goto free;
+			if (!strcmp(name1, name2))
+				ret = 1;
+			goto free;
+
+		}
+		return 0;
+	} END_FOR_EACH_PTR_REVERSE(tmp);
+
+free:
+	free_string(name1);
+	free_string(name2);
+	return ret;
+}
+
+static int cap_lt_zero_or_gt(struct expression *expr)
+{
+
+	struct expression *var = expr->left;
+	struct expression *tmp;
+	char *name1 = NULL;
+	char *name2 = NULL;
+	sval_t known;
+	int ret = 0;
+	int i;
+
+	if (!get_value(expr->right, &known) || known.value != 0)
+		return 0;
+
+	i = 0;
+	FOR_EACH_PTR_REVERSE(big_expression_stack, tmp) {
+		if (!i++)
+			continue;
+		if (tmp->op == SPECIAL_LOGICAL_OR) {
+			struct expression *right = strip_expr(tmp->right);
+
+			if (right->op != '>' &&
+			    right->op != SPECIAL_UNSIGNED_GT &&
+			    right->op != SPECIAL_GTE &&
+			    right->op != SPECIAL_UNSIGNED_GTE)
+				return 0;
+
+			name1 = expr_to_str(var);
+			if (!name1)
+				goto free;
+
+			name2 = expr_to_str(right->left);
+			if (!name2)
+				goto free;
+			if (!strcmp(name1, name2))
+				ret = 1;
+			goto free;
+
+		}
+		return 0;
+	} END_FOR_EACH_PTR_REVERSE(tmp);
+
+free:
+	free_string(name1);
+	free_string(name2);
+	return ret;
+}
+
+static int cap_both_sides(struct expression *expr)
+{
+	switch (expr->op) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+	case SPECIAL_LTE:
+	case SPECIAL_UNSIGNED_LTE:
+		return cap_lt_zero_or_gt(expr);
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+	case SPECIAL_GTE:
+	case SPECIAL_UNSIGNED_GTE:
+		return cap_gt_zero_and_lt(expr);
+	}
+	return 0;
+}
+
+static int compare_against_macro(struct expression *expr)
+{
+	sval_t known;
+
+	if (expr->op != SPECIAL_UNSIGNED_LT)
+		return 0;
+
+	if (!get_value(expr->right, &known) || known.value != 0)
+		return 0;
+	return !!get_macro_name(expr->right->pos);
+}
+
+static int print_unsigned_never_less_than_zero(struct expression *expr)
+{
+	sval_t known;
+	char *name;
+
+	if (expr->op != SPECIAL_UNSIGNED_LT)
+		return 0;
+
+	if (!get_value(expr->right, &known) || known.value != 0)
+		return 0;
+
+	name = expr_to_str(expr->left);
+	sm_warning("unsigned '%s' is never less than zero.", name);
+	free_string(name);
+	return 1;
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct symbol *type;
+	sval_t known;
+	sval_t min, max;
+	struct range_list *rl_left_orig, *rl_right_orig;
+	struct range_list *rl_left, *rl_right;
+
+	if (expr->type != EXPR_COMPARE)
+		return;
+
+	type = get_type(expr);
+	if (!type)
+		return;
+
+	/* screw it.  I am writing this to mark yoda code as buggy.
+	 * Valid comparisons between an unsigned and zero are:
+	 * 1) inside a macro.
+	 * 2) foo < LOWER_BOUND where LOWER_BOUND is a macro.
+	 * 3) foo < 0 || foo > X in exactly this format.  No Yoda.
+	 * 4) foo >= 0 && foo < X
+	 */
+	if (get_macro_name(expr->pos))
+		return;
+	if (compare_against_macro(expr))
+		return;
+	if (cap_both_sides(expr))
+		return;
+
+	/* This is a special case for the common error */
+	if (print_unsigned_never_less_than_zero(expr))
+		return;
+
+	/* check that one and only one side is known */
+	if (get_value(expr->left, &known)) {
+		if (get_value(expr->right, &known))
+			return;
+		rl_left_orig = alloc_rl(known, known);
+		rl_left = cast_rl(type, rl_left_orig);
+
+		min = sval_type_min(get_type(expr->right));
+		max = sval_type_max(get_type(expr->right));
+		rl_right_orig = alloc_rl(min, max);
+		rl_right = cast_rl(type, rl_right_orig);
+	} else if (get_value(expr->right, &known)) {
+		rl_right_orig = alloc_rl(known, known);
+		rl_right = cast_rl(type, rl_right_orig);
+
+		min = sval_type_min(get_type(expr->left));
+		max = sval_type_max(get_type(expr->left));
+		rl_left_orig = alloc_rl(min, max);
+		rl_left = cast_rl(type, rl_left_orig);
+	} else {
+		return;
+	}
+
+	if (!possibly_true_rl(rl_left, expr->op, rl_right)) {
+		char *name = expr_to_str(expr);
+
+		sm_warning("impossible condition '(%s) => (%s %s %s)'", name,
+		       show_rl(rl_left), show_special(expr->op),
+		       show_rl(rl_right));
+		free_string(name);
+	}
+
+	if (!possibly_false_rl(rl_left, expr->op, rl_right)) {
+		char *name = expr_to_str(expr);
+
+		sm_warning("always true condition '(%s) => (%s %s %s)'", name,
+		       show_rl(rl_left_orig), show_special(expr->op),
+		       show_rl(rl_right_orig));
+		free_string(name);
+	}
+}
+
+void check_signed(int id)
+{
+	my_id = id;
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_condition, CONDITION_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_signed_integer_overflow_check.c b/usr/src/tools/smatch/src/check_signed_integer_overflow_check.c
new file mode 100644
index 0000000000..aabd7ab9fe
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_signed_integer_overflow_check.c
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Looks for integers that we get from the user which can be attacked
+ * with an integer overflow.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static void match_condition(struct expression *expr)
+{
+	struct expression *left, *right;
+	struct symbol *type;
+	char *right_name;
+	char *left_name;
+
+	if (expr->type != EXPR_COMPARE)
+		return;
+	if (expr->op != '<')
+		return;
+
+	type = get_type(expr);
+	if (!type_signed(type))
+		return;
+
+	left = strip_expr(expr->left);
+	right = strip_expr(expr->right);
+
+	if (left->type != EXPR_BINOP) {
+		left = get_assigned_expr(left);
+		left = strip_expr(left);
+		if (!left || left->type != EXPR_BINOP)
+			return;
+	}
+
+	if (left->op != '+' && left->op != '*' && left->op != SPECIAL_LEFTSHIFT)
+		return;
+
+	if (has_variable(left, right) == 1) {
+		left_name = expr_to_str(left);
+		right_name = expr_to_str(right);
+		sm_warning("signed overflow undefined. '%s %s %s'", left_name, show_special(expr->op), right_name);
+		free_string(left_name);
+		free_string(right_name);
+	}
+}
+
+static void match_binop(struct expression *expr)
+{
+	sval_t left_val, right_min;
+	char *str;
+
+	if (expr->op != '-')
+		return;
+
+	if (!get_value(expr->left, &left_val))
+		return;
+
+	switch (left_val.uvalue) {
+	case SHRT_MAX:
+	case USHRT_MAX:
+	case INT_MAX:
+	case UINT_MAX:
+	case LLONG_MAX:
+	case ULLONG_MAX:
+		break;
+	default:
+		return;
+	}
+
+	get_absolute_min(expr->right, &right_min);
+	if (!sval_is_negative(right_min))
+		return;
+
+	str = expr_to_str(expr);
+	sm_warning("potential negative subtraction from max '%s'", str);
+	free_string(str);
+}
+
+void check_signed_integer_overflow_check(int id)
+{
+	my_id = id;
+
+	if (option_project == PROJ_KERNEL) {
+		/* The kernel uses -fno-strict-overflow so it's fine */
+		return;
+	}
+
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_binop, BINOP_HOOK);
+}
+
diff --git a/usr/src/tools/smatch/src/check_sizeof.c b/usr/src/tools/smatch/src/check_sizeof.c
new file mode 100644
index 0000000000..6f4f3a6e8f
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_sizeof.c
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void check_pointer(struct expression *expr, char *ptr_name)
+{
+	char *name;
+	sval_t sval;
+
+	if (!expr || expr->type != EXPR_SIZEOF)
+		return;
+
+	get_value(expr, &sval);
+
+	expr = strip_expr(expr->cast_expression);
+	name = expr_to_str(expr);
+	if (!name)
+		return;
+
+	if (strcmp(ptr_name, name) == 0)
+		sm_warning("was 'sizeof(*%s)' intended?", ptr_name);
+	free_string(name);
+}
+
+static void match_call_assignment(struct expression *expr)
+{
+	struct expression *call = strip_expr(expr->right);
+	struct expression *arg;
+	char *ptr_name;
+
+	if (!is_pointer(expr->left))
+		return;
+
+	ptr_name = expr_to_str(expr->left);
+	if (!ptr_name)
+		return;
+
+	FOR_EACH_PTR(call->args, arg) {
+		check_pointer(arg, ptr_name);
+	} END_FOR_EACH_PTR(arg);
+
+	free_string(ptr_name);
+}
+
+static void check_passes_pointer(char *name, struct expression *call)
+{
+	struct expression *arg;
+	char *ptr_name;
+
+	FOR_EACH_PTR(call->args, arg) {
+		ptr_name = expr_to_var(arg);
+		if (!ptr_name)
+			continue;
+		if (strcmp(name, ptr_name) == 0)
+			sm_warning("was 'sizeof(*%s)' intended?", name);
+		free_string(ptr_name);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void match_check_params(struct expression *call)
+{
+	struct expression *arg;
+	struct expression *obj;
+	char *name;
+
+	FOR_EACH_PTR(call->args, arg) {
+		if (arg->type != EXPR_SIZEOF)
+			continue;
+		obj = strip_expr(arg->cast_expression);
+		if (!is_pointer(obj))
+			continue;
+		name = expr_to_var(obj);
+		if (!name)
+			continue;
+		check_passes_pointer(name, call);
+		free_string(name);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static struct string_list *macro_takes_sizeof_argument;
+static void check_sizeof_number(struct expression *expr)
+{
+	char *macro, *tmp;
+
+	if (expr->type != EXPR_VALUE)
+		return;
+	macro = get_macro_name(expr->pos);
+	FOR_EACH_PTR(macro_takes_sizeof_argument, tmp) {
+		if (macro && strcmp(tmp, macro) == 0)
+			return;
+	} END_FOR_EACH_PTR(tmp);
+
+	sm_warning("sizeof(NUMBER)?");
+}
+
+static void match_sizeof(struct expression *expr)
+{
+	check_sizeof_number(expr);
+	if (expr->type == EXPR_PREOP && expr->op == '&')
+		sm_warning("sizeof(&pointer)?");
+	if (expr->type == EXPR_SIZEOF)
+		sm_warning("sizeof(sizeof())?");
+	/* the ilog2() macro is a valid place to check the size of a binop */
+	if (expr->type == EXPR_BINOP && !get_macro_name(expr->pos))
+		sm_warning("taking sizeof binop");
+}
+
+static void register_macro_takes_sizeof_argument(void)
+{
+	struct token *token;
+	char *macro;
+	char name[256];
+
+	snprintf(name, 256, "%s.macro_takes_sizeof_argument", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		macro = alloc_string(show_ident(token->ident));
+		add_ptr_list(&macro_takes_sizeof_argument, macro);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_sizeof(int id)
+{
+	my_id = id;
+
+	register_macro_takes_sizeof_argument();
+	add_hook(&match_call_assignment, CALL_ASSIGNMENT_HOOK);
+	add_hook(&match_check_params, FUNCTION_CALL_HOOK);
+	add_hook(&match_sizeof, SIZEOF_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_snprintf.c b/usr/src/tools/smatch/src/check_snprintf.c
new file mode 100644
index 0000000000..162e07c6db
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_snprintf.c
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static void ok_to_use(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &undefined);
+}
+
+static void match_snprintf(const char *fn, struct expression *expr, void *info)
+{
+	struct expression *call;
+	struct expression *arg;
+	sval_t buflen;
+
+	call = strip_expr(expr->right);
+	arg = get_argument_from_call_expr(call->args, 1);
+	if (!get_fuzzy_max(arg, &buflen))
+		return;
+	set_state_expr(my_id, expr->left, alloc_state_num(buflen.value));
+}
+
+static int get_old_buflen(struct sm_state *sm)
+{
+	struct sm_state *tmp;
+	int ret = 0;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (PTR_INT(tmp->state->data) > ret)
+			ret = PTR_INT(tmp->state->data);
+	} END_FOR_EACH_PTR(tmp);
+	return ret;
+}
+
+static void match_call(struct expression *expr)
+{
+	struct expression *arg;
+	struct sm_state *sm;
+	int old_buflen;
+	sval_t max;
+
+	FOR_EACH_PTR(expr->args, arg) {
+		sm = get_sm_state_expr(my_id, arg);
+		if (!sm)
+			continue;
+		old_buflen = get_old_buflen(sm);
+		if (!old_buflen)
+			return;
+		if (get_absolute_max(arg, &max) && sval_cmp_val(max, old_buflen) > 0)
+			sm_warning("'%s' returned from snprintf() might be larger than %d",
+				sm->name, old_buflen);
+	} END_FOR_EACH_PTR(arg);
+}
+
+void check_snprintf(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+	if (!option_spammy)
+		return;
+
+	my_id = id;
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+	add_function_assign_hook("snprintf", &match_snprintf, NULL);
+	add_modification_hook(my_id, &ok_to_use);
+}
+
diff --git a/usr/src/tools/smatch/src/check_snprintf_overflow.c b/usr/src/tools/smatch/src/check_snprintf_overflow.c
new file mode 100644
index 0000000000..5d676357f3
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_snprintf_overflow.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static void match_snprintf(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *dest;
+	struct expression *dest_size_expr;
+	struct expression *format_string;
+	struct expression *data;
+	char *data_name = NULL;
+	int dest_size;
+	sval_t limit_size;
+	char *format;
+	int data_size;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	dest_size_expr = get_argument_from_call_expr(expr->args, 1);
+	format_string = get_argument_from_call_expr(expr->args, 2);
+	data = get_argument_from_call_expr(expr->args, 3);
+
+	dest_size = get_array_size_bytes(dest);
+	if (!get_implied_value(dest_size_expr, &limit_size))
+		return;
+	if (dest_size > 1 && dest_size < limit_size.value)
+		sm_error("snprintf() is printing too much %s vs %d",
+			 sval_to_str(limit_size), dest_size);
+	format = expr_to_var(format_string);
+	if (!format)
+		return;
+	if (strcmp(format, "\"%s\""))
+		goto free;
+	data_name = expr_to_str(data);
+	data_size = get_size_from_strlen(data);
+	if (!data_size)
+		data_size = get_array_size_bytes(data);
+	if (limit_size.value < data_size)
+		sm_error("snprintf() chops off the last chars of '%s': %d vs %s",
+		       data_name, data_size, sval_to_str(limit_size));
+free:
+	free_string(data_name);
+	free_string(format);
+}
+
+void check_snprintf_overflow(int id)
+{
+	add_function_hook("snprintf", &match_snprintf, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_spectre.c b/usr/src/tools/smatch/src/check_spectre.c
new file mode 100644
index 0000000000..e35527b5e4
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_spectre.c
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2018 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static int suppress_multiple = 1;
+
+static int is_write(struct expression *expr)
+{
+	return 0;
+}
+
+static int is_read(struct expression *expr)
+{
+	struct expression *parent, *last_parent;
+	struct statement *stmt;
+
+	if (is_write(expr))
+		return 0;
+
+	last_parent = expr;
+	while ((parent = expr_get_parent_expr(expr))){
+
+		last_parent = parent;
+
+		/* If we pass a value as a parameter that's a read, probably? */
+//		if (parent->type == EXPR_CALL)
+//			return 1;
+
+		if (parent->type == EXPR_ASSIGNMENT) {
+			if (parent->right == expr)
+				return 1;
+			if (parent->left == expr)
+				return 0;
+		}
+		expr = parent;
+	}
+
+	stmt = expr_get_parent_stmt(last_parent);
+	if (stmt && stmt->type == STMT_RETURN)
+		return 1;
+
+	return 0;
+}
+
+static int is_harmless(struct expression *expr)
+{
+	struct expression *tmp, *parent;
+	struct statement *stmt;
+	int count = 0;
+
+	parent = expr;
+	while ((tmp = expr_get_parent_expr(parent))) {
+		if (tmp->type == EXPR_ASSIGNMENT || tmp->type == EXPR_CALL)
+			return 0;
+		parent = tmp;
+		if (count++ > 4)
+			break;
+	}
+
+	stmt = expr_get_parent_stmt(parent);
+	if (!stmt)
+		return 0;
+	if (stmt->type == STMT_IF && stmt->if_conditional == parent)
+		return 1;
+	if (stmt->type == STMT_ITERATOR &&
+	    (stmt->iterator_pre_condition == parent ||
+	     stmt->iterator_post_condition == parent))
+		return 1;
+
+	return 0;
+}
+
+static unsigned long long get_max_by_type(struct expression *expr)
+{
+	struct symbol *type;
+	int cnt = 0;
+	sval_t max;
+
+	max.type = &ullong_ctype;
+	max.uvalue = -1ULL;
+
+	while (true) {
+		expr = strip_parens(expr);
+		type = get_type(expr);
+		if (type && sval_type_max(type).uvalue < max.uvalue)
+			max = sval_type_max(type);
+		if (expr->type == EXPR_PREOP) {
+			expr = expr->unop;
+		} else if (expr->type == EXPR_BINOP) {
+			if (expr->op == '%' || expr->op == '&')
+				expr = expr->right;
+			else
+				return max.uvalue;
+		} else {
+			expr = get_assigned_expr(expr);
+			if (!expr)
+				return max.uvalue;
+		}
+		if (cnt++ > 5)
+			return max.uvalue;
+	}
+
+	return max.uvalue;
+}
+
+static unsigned long long get_mask(struct expression *expr)
+{
+	struct expression *tmp;
+	sval_t mask;
+	int cnt = 0;
+
+	expr = strip_expr(expr);
+
+	tmp = get_assigned_expr(expr);
+	while (tmp) {
+		expr = tmp;
+		if (++cnt > 3)
+			break;
+		tmp = get_assigned_expr(expr);
+	}
+
+	if (expr->type == EXPR_BINOP && expr->op == '&') {
+		if (get_value(expr->right, &mask))  /* right is the common case */
+			return mask.uvalue;
+		if (get_value(expr->left, &mask))
+			return mask.uvalue;
+	}
+
+	return ULLONG_MAX;
+}
+
+static void array_check(struct expression *expr)
+{
+	struct expression_list *conditions;
+	struct expression *array_expr, *offset;
+	unsigned long long mask;
+	int array_size;
+	char *name;
+
+	expr = strip_expr(expr);
+	if (!is_array(expr))
+		return;
+
+	if (is_impossible_path())
+		return;
+	if (is_harmless(expr))
+		return;
+
+	array_expr = get_array_base(expr);
+	if (suppress_multiple && is_ignored_expr(my_id, array_expr))
+		return;
+
+	offset = get_array_offset(expr);
+	if (!is_user_rl(offset))
+		return;
+	if (is_nospec(offset))
+		return;
+
+	array_size = get_array_size(array_expr);
+	if (array_size > 0 && get_max_by_type(offset) < array_size)
+		return;
+//	binfo = get_bit_info(offset);
+//	if (array_size > 0 && binfo && binfo->possible < array_size)
+//		return;
+
+	mask = get_mask(offset);
+	if (mask <= array_size)
+		return;
+
+	conditions = get_conditions(offset);
+
+	name = expr_to_str(array_expr);
+	sm_warning("potential spectre issue '%s' [%s]%s",
+	       name,
+	       is_read(expr) ? "r" : "w",
+	       conditions ? " (local cap)" : "");
+	if (suppress_multiple)
+		add_ignore_expr(my_id, array_expr);
+	free_string(name);
+}
+
+void check_spectre(int id)
+{
+	my_id = id;
+
+	suppress_multiple = getenv("FULL_SPECTRE") == NULL;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_hook(&array_check, OP_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_sprintf_overflow.c b/usr/src/tools/smatch/src/check_sprintf_overflow.c
new file mode 100644
index 0000000000..46d97942aa
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_sprintf_overflow.c
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static void match_sprintf(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *dest;
+	struct expression *format_string;
+	struct expression *data;
+	char *data_name = NULL;
+	int dest_size;
+	char *format;
+	int data_size;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	format_string = get_argument_from_call_expr(expr->args, 1);
+	data = get_argument_from_call_expr(expr->args, 2);
+
+	dest_size = get_array_size_bytes(dest);
+	if (!dest_size)
+		return;
+	format = expr_to_var(format_string);
+	if (!format)
+		return;
+	if (strcmp(format, "\"%s\""))
+		goto free;
+	data_name = expr_to_str(data);
+	data_size = get_size_from_strlen(data);
+	if (!data_size)
+		data_size = get_array_size_bytes(data);
+	if (dest_size < data_size)
+		sm_error("sprintf() copies too much data from '%s': %d vs %d",
+		       data_name, data_size, dest_size);
+free:
+	free_string(data_name);
+	free_string(format);
+}
+
+void check_sprintf_overflow(int id)
+{
+	add_function_hook("sprintf", &match_sprintf, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_stack.c b/usr/src/tools/smatch/src/check_stack.c
new file mode 100644
index 0000000000..b91586fab8
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_stack.c
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The kernel has a small stack so putting huge structs and arrays on the
+ * stack is a bug.
+ *
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static int total_size;
+static int max_size;
+static int max_lineno;
+static int complained;
+
+#define MAX_ALLOWED 1000
+
+static void scope_end(void *_size)
+{
+	int size = PTR_INT(_size);
+	total_size -= size;
+}
+
+static void match_declarations(struct symbol *sym)
+{
+	struct symbol *base;
+	const char *name;
+
+	base = get_base_type(sym);
+	if (sym->ctype.modifiers & MOD_STATIC)
+		return;
+	name = sym->ident->name;
+	total_size += type_bytes(base);
+	if (total_size > max_size) {
+		max_size = total_size;
+		max_lineno = get_lineno();
+	}
+	if (type_bytes(base) >= MAX_ALLOWED) {
+		complained = 1;
+		sm_warning("'%s' puts %d bytes on stack", name, type_bytes(base));
+	}
+	add_scope_hook(&scope_end, INT_PTR(type_bytes(base))); 
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+
+	if ((max_size >= MAX_ALLOWED) && !complained) {
+		sm_printf("%s:%d %s() ", get_filename(), max_lineno, get_function());
+		sm_printf("warn: function puts %d bytes on stack\n", max_size);
+	}
+	total_size = 0;
+	complained = 0;
+	max_size = 0;
+	max_lineno = 0;
+}
+
+void check_stack(int id)
+{
+	if (option_project != PROJ_KERNEL || !option_spammy)
+		return;
+
+	my_id = id;
+	add_hook(&match_declarations, DECLARATION_HOOK);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_strcpy_overflow.c b/usr/src/tools/smatch/src/check_strcpy_overflow.c
new file mode 100644
index 0000000000..00731f965f
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_strcpy_overflow.c
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static void match_strcpy(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *dest;
+	struct expression *data;
+	char *dest_name = NULL;
+	char *data_name = NULL;
+	int dest_size;
+	int data_size;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	data = get_argument_from_call_expr(expr->args, 1);
+	dest_size = get_array_size_bytes(dest);
+	if (!dest_size)
+		return;
+
+	data_size = get_size_from_strlen(data);
+	if (!data_size)
+		data_size = get_array_size_bytes(data);
+
+	/* If the size of both arrays is known and the destination
+	 * buffer is larger than the source buffer, we're okay.
+	 */
+	if (data_size && dest_size >= data_size)
+		return;
+
+	dest_name = expr_to_str(dest);
+	data_name = expr_to_str(data);
+
+	if (data_size)
+		sm_error("%s() '%s' too large for '%s' (%d vs %d)",
+			fn, data_name, dest_name, data_size, dest_size);
+	else if (option_spammy)
+		sm_warning("%s() '%s' of unknown size might be too large for '%s'",
+			fn, data_name, dest_name);
+
+	free_string(dest_name);
+	free_string(data_name);
+}
+
+void check_strcpy_overflow(int id)
+{
+	add_function_hook("strcpy", &match_strcpy, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_string_len.c b/usr/src/tools/smatch/src/check_string_len.c
new file mode 100644
index 0000000000..3d6fd7f105
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_string_len.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This tries to find buffer overflows in sprintf().
+ * I'll freely admit that the code is sort of crap.
+ * Also if it sees "sprintf("%2d\n", x)" then it assumes x is less than 99.
+ * That might not be true so there maybe buffer overflows which are missed.
+ *
+ */
+
+#include <ctype.h>
+#include "smatch.h"
+
+static int my_id;
+
+struct param_info {
+	int buf_or_limit;
+	int string;
+};
+
+struct param_info zero_one = {0, 1};
+
+static int handle_format(struct expression *call, char **pp, int *arg_nr)
+{
+	struct expression *arg;
+	char *p = *pp;
+	int ret = 1;
+	char buf[256];
+	sval_t max;
+
+	p++;  /* we passed it with *p == '%' */
+
+	if (*p == '%') {
+		p++;
+		ret = 1;
+		goto out_no_arg;
+	}
+	if (*p == 'c') {
+		p++;
+		ret = 1;
+		goto out;
+	}
+
+
+	if (isdigit(*p) || *p == '.') {
+		unsigned long num;
+
+		if (*p == '.')
+			p++;
+
+		num = strtoul(p, &p, 10);
+		ret = num;
+
+		while (*p == 'l')
+			p++;
+		p++; /* eat the 'd' char */
+		goto out;
+	}
+
+	if (*p == 'l') {
+		p++;
+		if (*p == 'l')
+			p++;
+	}
+
+	if (option_project == PROJ_KERNEL && *p == 'z')
+		p++;
+
+	if (option_project == PROJ_KERNEL && *p == 'p') {
+		if (*(p + 1) == 'I' || *(p + 1) == 'i') {
+			char *eye;
+
+			eye = p + 1;
+			p += 2;
+			if (*p == 'h' || *p == 'n' || *p == 'b' || *p == 'l')
+				p++;
+			if (*p == '4') {
+				p++;
+				ret = 15;
+				goto out;
+			}
+			if (*p == '6') {
+				p++;
+				if (*p == 'c')
+					p++;
+				if (*eye == 'I')
+					ret = 39;
+				if (*eye == 'i')
+					ret = 32;
+				goto out;
+			}
+		}
+		if (*(p + 1) == 'M') {
+			p += 2;
+			if (*p == 'R' || *p == 'F')
+				p++;
+			ret = 17;
+			goto out;
+		}
+		if (*(p + 1) == 'm') {
+			p += 2;
+			if (*p == 'R')
+				p++;
+			ret = 12;
+			goto out;
+		}
+	}
+
+	arg = get_argument_from_call_expr(call->args, *arg_nr);
+	if (!arg)
+		goto out;
+
+	if (*p == 's') {
+		ret = get_array_size_bytes(arg);
+		if (ret < 0)
+			ret = 1;
+		/* we don't print the NUL here */
+		ret--;
+		p++;
+		goto out;
+	}
+
+	if (*p != 'd' && *p != 'i' && *p != 'x' && *p != 'X' && *p != 'u' && *p != 'p') {
+		ret = 1;
+		p++;
+		goto out;
+	}
+
+	get_absolute_max(arg, &max);
+
+	if (*p == 'x' || *p == 'X' || *p == 'p') {
+		ret = snprintf(buf, sizeof(buf), "%llx", max.uvalue);
+	} else if (*p == 'u') {
+		ret = snprintf(buf, sizeof(buf), "%llu", max.uvalue);
+	} else if (!expr_unsigned(arg)) {
+		sval_t min;
+		int tmp;
+
+		ret = snprintf(buf, sizeof(buf), "%lld", max.value);
+		get_absolute_min(arg, &min);
+		tmp = snprintf(buf, sizeof(buf), "%lld", min.value);
+		if (tmp > ret)
+			ret = tmp;
+	} else {
+		ret = snprintf(buf, sizeof(buf), "%lld", max.value);
+	}
+	p++;
+
+out:
+	(*arg_nr)++;
+out_no_arg:
+	*pp = p;
+	return ret;
+}
+
+int get_formatted_string_size(struct expression *call, int arg)
+{
+	struct expression *expr;
+	char *p;
+	int count;
+
+	expr = get_argument_from_call_expr(call->args, arg);
+	if (!expr || expr->type != EXPR_STRING)
+		return -1;
+
+	arg++;
+	count = 0;
+	p = expr->string->data;
+	while (*p) {
+
+		if (*p == '%') {
+			count += handle_format(call, &p, &arg);
+		} else if (*p == '\\') {
+			p++;
+		}else {
+			p++;
+			count++;
+		}
+	}
+
+	count++; /* count the NUL terminator */
+	return count;
+}
+
+static void match_not_limited(const char *fn, struct expression *call, void *info)
+{
+	struct param_info *params = info;
+	struct range_list *rl;
+	struct expression *dest;
+	struct expression *arg;
+	int buf_size, size;
+	int user = 0;
+	int i;
+	int offset = 0;
+
+	dest = get_argument_from_call_expr(call->args, params->buf_or_limit);
+	dest = strip_expr(dest);
+	if (dest->type == EXPR_BINOP && dest->op == '+') {
+		sval_t max;
+
+		if (get_hard_max(dest->right, &max))
+			offset = max.value;
+		dest = dest->left;
+	}
+
+
+	buf_size = get_array_size_bytes(dest);
+	if (buf_size <= 0)
+		return;
+
+	size = get_formatted_string_size(call, params->string);
+	if (size <= 0)
+		return;
+	if (size < offset)
+		size -= offset;
+	if (size <= buf_size)
+		return;
+
+	i = 0;
+	FOR_EACH_PTR(call->args, arg) {
+		if (i++ <= params->string)
+			continue;
+		if (get_user_rl(arg, &rl))
+			user = 1;
+	} END_FOR_EACH_PTR(arg);
+
+	sm_error("format string overflow. buf_size: %d length: %d%s",
+	       buf_size, size, user ? " [user data]": "");
+}
+
+void check_string_len(int id)
+{
+	my_id = id;
+	add_function_hook("sprintf", &match_not_limited, &zero_one);
+}
+
diff --git a/usr/src/tools/smatch/src/check_struct_type.c b/usr/src/tools/smatch/src/check_struct_type.c
new file mode 100644
index 0000000000..bbe74da252
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_struct_type.c
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_assign(const char *fn, struct expression *expr, void *_size_arg)
+{
+	int size_arg = PTR_INT(_size_arg);
+	struct expression *left;
+	struct expression *call;
+	struct expression *arg;
+	struct symbol *left_type;
+	struct symbol *size_type;
+
+	left = strip_expr(expr->left);
+	left_type = get_type(left);
+	if (!left_type || left_type->type != SYM_PTR)
+		return;
+	left_type = get_real_base_type(left_type);
+	if (!left_type || left_type->type != SYM_STRUCT)
+		return;
+
+	call = strip_expr(expr->right);
+	arg = get_argument_from_call_expr(call->args, size_arg);
+	if (!arg || arg->type != EXPR_SIZEOF || !arg->cast_type)
+		return;
+	size_type = arg->cast_type;
+	if (size_type->type != SYM_NODE)
+		return;
+	size_type = get_real_base_type(size_type);
+	if (size_type->type != SYM_STRUCT)
+		return;
+	if (strcmp(left_type->ident->name, size_type->ident->name) == 0)
+		return;
+	sm_warning("struct type mismatch '%s vs %s'", left_type->ident->name,
+	       size_type->ident->name);
+
+}
+
+void check_struct_type(int id)
+{
+	my_id = id;
+
+	if (option_project == PROJ_KERNEL) {
+		add_function_assign_hook("kmalloc", &match_assign, INT_PTR(0));
+		add_function_assign_hook("kzalloc", &match_assign, INT_PTR(0));
+	}
+}
diff --git a/usr/src/tools/smatch/src/check_syscall_arg_type.c b/usr/src/tools/smatch/src/check_syscall_arg_type.c
new file mode 100644
index 0000000000..1beb27f33c
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_syscall_arg_type.c
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is to help create Trinity fuzzer templates.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(ARG_FD);
+#if 0
+STATE(arg_range);
+STATE(arg_op);
+STATE(arg_list);
+STATE(arg_cpu);
+STATE(arg_pathname);
+#endif
+// nr_segs * sizeof(struct iovec)
+// if (nr_segs > UIO_MAXIOV)
+#if 0
+STATE(arg_ioveclen);
+STATE(arg_sockaddrlen);
+STATE(arg_socketinfo);
+#endif
+
+struct smatch_state *merge_states(struct smatch_state *s1, struct smatch_state *s2)
+{
+	if (s1 == &undefined)
+		return s2;
+	return s1;
+}
+
+struct typedef_lookup {
+	const char *name;
+	struct symbol *sym;
+	int failed;
+};
+
+static struct symbol *_typedef_lookup(const char *name)
+{
+	struct ident *id;
+	struct symbol *node;
+
+	id = built_in_ident(name);
+	if (!id)
+		return NULL;
+	node = lookup_symbol(id, NS_TYPEDEF);
+	if (!node || node->type != SYM_NODE)
+		return NULL;
+	return get_real_base_type(node);
+}
+
+static void typedef_lookup(struct typedef_lookup *tl)
+{
+	if (tl->sym || tl->failed)
+		return;
+	tl->sym = _typedef_lookup(tl->name);
+	if (!tl->sym)
+		tl->failed = 1;
+}
+
+static int is_mode_t(struct symbol *sym)
+{
+	static struct typedef_lookup umode_t = { .name = "umode_t" };
+	struct symbol *type;
+
+	typedef_lookup(&umode_t);
+	if (!umode_t.sym)
+		return 0;
+	type = get_base_type(sym);
+	if (type == umode_t.sym)
+		return 1;
+	return 0;
+}
+
+static int is_pid_t(struct symbol *sym)
+{
+	static struct typedef_lookup pid_t = { .name = "pid_t" };
+	struct symbol *type;
+
+	typedef_lookup(&pid_t);
+	if (!pid_t.sym)
+		return 0;
+	type = get_base_type(sym);
+	if (type == pid_t.sym)
+		return 1;
+	return 0;
+}
+
+static const char *get_arg_type_from_type(struct symbol *sym)
+{
+	struct symbol *type;
+
+	if (is_mode_t(sym))
+		return "ARG_MODE_T";
+	if (is_pid_t(sym))
+		return "ARG_PID";
+
+	type = get_real_base_type(sym);
+	if (!type || type->type != SYM_PTR)
+		return NULL;
+	type = get_real_base_type(type);
+	if (!type)
+		return NULL;
+	if (type == &char_ctype)
+		return "ARG_MMAP";
+	if (!type->ident)
+		return NULL;
+	if (strcmp(type->ident->name, "iovec") == 0)
+		return "ARG_IOVEC";
+	if (strcmp(type->ident->name, "sockaddr") == 0)
+		return "ARG_SOCKADDR";
+	return "ARG_ADDRESS";
+}
+
+static void match_fdget(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	set_state_expr(my_id, arg, &ARG_FD);
+}
+
+const char *get_syscall_arg_type(struct symbol *sym)
+{
+	struct smatch_state *state;
+	const char *type;
+
+	if (!sym || !sym->ident)
+		return "ARG_UNDEFINED";
+	type = get_arg_type_from_type(sym);
+	if (type)
+		return type;
+	state = get_state(my_id, sym->ident->name, sym);
+	if (!state)
+		return "ARG_UNDEFINED";
+	return state->name;
+}
+
+void check_syscall_arg_type(int id)
+{
+	my_id = id;
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_merge_hook(my_id, &merge_states);
+	add_function_hook("fdget", &match_fdget, NULL);
+}
+
+
diff --git a/usr/src/tools/smatch/src/check_template.c b/usr/src/tools/smatch/src/check_template.c
new file mode 100644
index 0000000000..6e8b6aa556
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_template.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 20XX Your Name.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * First of all, it's best if you lower your expectations from finding
+ * errors to just finding suspicious code.  There tends to be a lot
+ * of false positives so having low expectations helps.
+ *
+ * For this test let's look for functions that return a negative value
+ * with a semaphore held.
+ *
+ * This is just a template check.  It's designed for teaching
+ * only and is deliberately less useful than it could be.  check_locking.c
+ * is a better real world test.
+ *
+ * The biggest short coming is that it assumes a function isn't supposed
+ * to return negative with a lock held.  Also it assumes the function was
+ * called without the lock held. It would be better if it handled the stuff
+ * like this:
+ *     ret = -ENOMEM;
+ *     return ret;
+ * Another idea would be to test other kinds of locks besides just semaphores.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+STATE(lock);
+STATE(unlock);
+
+/*
+ * unmatched_state() deals with the case where code is known to be
+ * locked on one path but not known on the other side of a merge.  Here
+ * we assume it's the opposite.
+ */
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	if (sm->state == &lock)
+		return &unlock;
+	if (sm->state == &unlock)
+		return &lock;
+	return &undefined;
+}
+
+static void match_call(struct expression *expr)
+{
+	char *fn_name;
+	struct expression *sem_expr;
+	char *sem_name;
+
+	fn_name = expr_to_var(expr->fn);
+	if (!fn_name || (strcmp(fn_name, "down") && strcmp(fn_name, "up")))
+		goto free_fn;
+
+	sem_expr = get_argument_from_call_expr(expr->args, 0);
+	sem_name = expr_to_var(sem_expr);
+	if (!strcmp(fn_name, "down")) {
+		set_state(my_id, sem_name, NULL, &lock);
+	} else {
+		set_state(my_id, sem_name, NULL, &unlock);
+	}
+	free_string(sem_name);
+free_fn:
+	free_string(fn_name);
+}
+
+static void match_return(struct expression *ret_value)
+{
+	sval_t ret_val;
+	struct stree *stree;
+	struct sm_state *tmp;
+
+	if (!get_value(ret_value, &ret_val) || sval_cmp_val(ret_val, 0) >= 0)
+		return;
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(my_id, stree, tmp) {
+		if (tmp->state != &unlock)
+			sm_warning("returned negative with %s semaphore held",
+				   tmp->name);
+	} END_FOR_EACH_SM(tmp);
+}
+
+void check_template(int id)
+{
+	my_id = id;
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+	add_hook(&match_return, RETURN_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_test_bit.c b/usr/src/tools/smatch/src/check_test_bit.c
new file mode 100644
index 0000000000..a26a12ab64
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_test_bit.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2015 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static void match_test_bit(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg;
+	char *macro;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	arg = strip_expr(arg);
+
+	if (!arg || arg->type != EXPR_BINOP)
+		return;
+	if (arg->op != '|' && arg->op != SPECIAL_LEFTSHIFT)
+		return;
+	macro = get_macro_name(arg->pos);
+	if (macro && strstr(macro, "cpu_has"))
+		return;
+	sm_warning("test_bit() takes a bit number");
+}
+
+void check_test_bit(int id)
+{
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_function_hook("test_bit", &match_test_bit, NULL);
+	add_function_hook("variable_test_bit", &match_test_bit, NULL);
+	add_function_hook("set_bit", &match_test_bit, NULL);
+	add_function_hook("clear_bit", &match_test_bit, NULL);
+	add_function_hook("test_and_clear_bit", &match_test_bit, NULL);
+	add_function_hook("test_and_set_bit", &match_test_bit, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_testing_index_after_use.c b/usr/src/tools/smatch/src/check_testing_index_after_use.c
new file mode 100644
index 0000000000..18b0fcffe6
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_testing_index_after_use.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdlib.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+/*
+ * This check has two smatch IDs.
+ * my_used_id - keeps a record of array offsets that have been used.
+ *              If the code checks that they are within bounds later on,
+ *              we complain about using an array offset before checking
+ *              that it is within bounds.
+ */
+static int my_used_id;
+
+static void delete(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_used_id, sm->name, sm->sym, &undefined);
+}
+
+static int get_the_max(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+
+	if (get_hard_max(expr, sval))
+		return 1;
+	if (!option_spammy)
+		return 0;
+	if (get_fuzzy_max(expr, sval))
+		return 1;
+	if (get_user_rl(expr, &rl)) {
+		*sval = rl_max(rl);
+		return 1;
+	}
+	return 0;
+}
+
+static void array_check(struct expression *expr)
+{
+	struct expression *array_expr;
+	int array_size;
+	struct expression *offset;
+	sval_t max;
+
+	expr = strip_expr(expr);
+	if (!is_array(expr))
+		return;
+
+	array_expr = get_array_base(expr);
+	array_size = get_array_size(array_expr);
+	if (!array_size || array_size == 1)
+		return;
+
+	offset = get_array_offset(expr);
+	if (!get_the_max(offset, &max)) {
+		if (getting_address())
+			return;
+		if (is_capped(offset))
+			return;
+		set_state_expr(my_used_id, offset, alloc_state_num(array_size));
+	}
+}
+
+static void match_condition(struct expression *expr)
+{
+	int left;
+	sval_t sval;
+	struct state_list *slist;
+	struct sm_state *tmp;
+	int boundary;
+
+	if (!expr || expr->type != EXPR_COMPARE)
+		return;
+	if (get_macro_name(expr->pos))
+		return;
+	if (get_implied_value(expr->left, &sval))
+		left = 1;
+	else if (get_implied_value(expr->right, &sval))
+		left = 0;
+	else
+		return;
+
+	if (left)
+		slist = get_possible_states_expr(my_used_id, expr->right);
+	else
+		slist = get_possible_states_expr(my_used_id, expr->left);
+	if (!slist)
+		return;
+	FOR_EACH_PTR(slist, tmp) {
+		if (tmp->state == &merged || tmp->state == &undefined)
+			continue;
+		boundary = PTR_INT(tmp->state->data);
+		boundary -= sval.value;
+		if (boundary < 1 && boundary > -1) {
+			char *name;
+
+			name = expr_to_var(left ? expr->right : expr->left);
+			sm_error("testing array offset '%s' after use.", name);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+void check_testing_index_after_use(int id)
+{
+	my_used_id = id;
+	add_hook(&array_check, OP_HOOK);
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_modification_hook(my_used_id, &delete);
+}
diff --git a/usr/src/tools/smatch/src/check_trinity_generator.c b/usr/src/tools/smatch/src/check_trinity_generator.c
new file mode 100644
index 0000000000..0a52aa5bb7
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_trinity_generator.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The idea is to generate syscall templates for the Trinity fuzzer.  There
+ * isn't currently quite enough information to do it right but I want to start
+ * and see how far I can get.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+FILE *sysc_fd;
+
+static int gen_custom_struct(int nr, struct symbol *arg)
+{
+	return 0;
+}
+
+static void print_arg(int nr, struct symbol *arg)
+{
+	fprintf(sysc_fd, "\t.arg%dname = \"%s\",\n", nr + 1, arg->ident->name);
+	fprintf(sysc_fd, "\t.arg%dtype = %s,\n", nr + 1, get_syscall_arg_type(arg));
+}
+
+static void match_return(struct expression *ret_value)
+{
+	struct symbol *arg;
+	int num_args;
+	char *name;
+	int i;
+	char buf[256];
+	int has_custom_struct[6];
+
+	if (!get_function() || !cur_func_sym)
+		return;
+	if (strncmp(get_function(), "SYSC_", 5) != 0)
+		return;
+
+	num_args = ptr_list_size((struct ptr_list *)cur_func_sym->ctype.base_type->arguments);
+	name = get_function() + 5;
+
+	snprintf(buf, sizeof(buf), "smatch_trinity_%s", name);
+	sysc_fd = fopen(buf, "w");
+	if (!sm_outfd) {
+		printf("Error:  Cannot open %s\n", buf);
+		return;
+	}
+
+	i = 0;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
+		if (gen_custom_struct(i, arg))
+			has_custom_struct[i] = true;
+		else
+			has_custom_struct[i] = false;
+		i++;
+	} END_FOR_EACH_PTR(arg);
+
+	fprintf(sysc_fd, "struct syscallentry sm_%s = {\n", name);
+	fprintf(sysc_fd, "\t.name = \"%s\",\n", name);
+	fprintf(sysc_fd, "\t.num_args = %d,\n", num_args);
+
+	i = 0;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
+		if (has_custom_struct[i])
+			;
+		else
+			print_arg(i++, arg);
+	} END_FOR_EACH_PTR(arg);
+
+	fprintf(sysc_fd, "};\n");
+}
+
+void check_trinity_generator(int id)
+{
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+	add_hook(&match_return, RETURN_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_type.c b/usr/src/tools/smatch/src/check_type.c
new file mode 100644
index 0000000000..ac0f5b8ad5
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_type.c
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static int in_function(const char *fn)
+{
+	char *cur_func = get_function();
+
+	if (!cur_func)
+		return 0;
+	if (!strcmp(cur_func, fn))
+		return 1;
+	return 0;
+}
+
+static void match_free(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg_expr;
+	char *name;
+	struct symbol *type;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 0);
+	type = get_pointer_type(arg_expr);
+	if (!type || !type->ident)
+		return;
+
+	name = expr_to_str(arg_expr);
+
+	if (!strcmp("sk_buff", type->ident->name)) {
+		sm_error("use kfree_skb() here instead of kfree(%s)", name);
+	} else if (!strcmp("net_device", type->ident->name)) {
+		if (in_function("alloc_netdev"))
+			return;
+		if (in_function("alloc_netdev_mqs"))
+			return;
+		sm_error("use free_netdev() here instead of kfree(%s)", name);
+	}
+
+	free_string(name);
+}
+
+void check_type(int id)
+{
+	my_id = id;
+	if (option_project == PROJ_KERNEL)
+		add_function_hook("kfree", &match_free, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_uninitialized.c b/usr/src/tools/smatch/src/check_uninitialized.c
new file mode 100644
index 0000000000..9cf28f3612
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_uninitialized.c
@@ -0,0 +1,365 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(uninitialized);
+STATE(initialized);
+
+static void pre_merge_hook(struct sm_state *sm)
+{
+	if (is_impossible_path())
+		set_state(my_id, sm->name, sm->sym, &initialized);
+}
+
+static void mark_members_uninitialized(struct symbol *sym)
+{
+	struct symbol *struct_type, *tmp, *base_type;
+	char buf[256];
+
+	struct_type = get_real_base_type(sym);
+	FOR_EACH_PTR(struct_type->symbol_list, tmp) {
+		if (!tmp->ident)
+			continue;
+		base_type = get_real_base_type(tmp);
+		if (!base_type ||
+		    base_type->type == SYM_STRUCT ||
+		    base_type->type == SYM_ARRAY ||
+		    base_type->type == SYM_UNION)
+			continue;
+		snprintf(buf, sizeof(buf), "%s.%s", sym->ident->name, tmp->ident->name);
+		set_state(my_id, buf, sym, &uninitialized);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void match_declarations(struct symbol *sym)
+{
+	struct symbol *type;
+
+	if (sym->initializer)
+		return;
+
+	type = get_real_base_type(sym);
+	/* Smatch is crap at tracking arrays */
+	if (type->type == SYM_ARRAY)
+		return;
+	if (type->type == SYM_UNION)
+		return;
+	if (sym->ctype.modifiers & MOD_STATIC)
+		return;
+
+	if (!sym->ident)
+		return;
+
+	if (type->type == SYM_STRUCT) {
+		mark_members_uninitialized(sym);
+		return;
+	}
+
+	set_state(my_id, sym->ident->name, sym, &uninitialized);
+}
+
+static void extra_mod_hook(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	if (!sym || !sym->ident)
+		return;
+	if (strcmp(name, sym->ident->name) != 0)
+		return;
+	set_state(my_id, name, sym, &initialized);
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *right;
+
+	right = strip_expr(expr->right);
+	if (right->type == EXPR_PREOP && right->op == '&')
+		set_state_expr(my_id, right->unop, &initialized);
+}
+
+static int is_initialized(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_SYMBOL)
+		return 1;
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return 1;
+	if (!slist_has_state(sm->possible, &uninitialized))
+		return 1;
+	return 0;
+}
+
+static void match_dereferences(struct expression *expr)
+{
+	char *name;
+
+	if (parse_error)
+		return;
+
+	if (expr->type != EXPR_PREOP)
+		return;
+	if (is_impossible_path())
+		return;
+	if (is_initialized(expr->unop))
+		return;
+
+	name = expr_to_str(expr->unop);
+	sm_error("potentially dereferencing uninitialized '%s'.", name);
+	free_string(name);
+
+	set_state_expr(my_id, expr->unop, &initialized);
+}
+
+static void match_condition(struct expression *expr)
+{
+	char *name;
+
+	if (parse_error)
+		return;
+
+	if (is_impossible_path())
+		return;
+
+	if (is_initialized(expr))
+		return;
+
+	name = expr_to_str(expr);
+	sm_error("potentially using uninitialized '%s'.", name);
+	free_string(name);
+
+	set_state_expr(my_id, expr, &initialized);
+}
+
+static void match_call(struct expression *expr)
+{
+	struct expression *arg;
+	char *name;
+
+	if (parse_error)
+		return;
+
+	if (is_impossible_path())
+		return;
+
+	FOR_EACH_PTR(expr->args, arg) {
+		if (is_initialized(arg))
+			continue;
+
+		name = expr_to_str(arg);
+		sm_warning("passing uninitialized '%s'", name);
+		free_string(name);
+
+		set_state_expr(my_id, arg, &initialized);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static int param_used_callback(void *found, int argc, char **argv, char **azColName)
+{
+	*(int *)found = 1;
+	return 0;
+}
+
+static int member_is_used(struct expression *call, int param, char *printed_name)
+{
+	int found;
+
+	/* for function pointers assume everything is used */
+	if (call->fn->type != EXPR_SYMBOL)
+		return 0;
+
+	found = 0;
+	run_sql(&param_used_callback, &found,
+		"select * from return_implies where %s and type = %d and parameter = %d and key = '%s';",
+		get_static_filter(call->fn->symbol), PARAM_USED, param, printed_name);
+	return found;
+}
+
+static void match_call_struct_members(struct expression *expr)
+{
+	struct symbol *type, *sym;
+	struct expression *arg;
+	struct sm_state *sm;
+	char *arg_name;
+	char buf[256];
+	int param;
+
+	return;
+
+	if (parse_error)
+		return;
+
+	param = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		param++;
+		if (arg->type != EXPR_PREOP || arg->op != '&')
+			continue;
+		type = get_type(arg->unop);
+		if (!type || type->type != SYM_STRUCT)
+			continue;
+		arg_name = expr_to_var_sym(arg->unop, &sym);
+		if (!arg_name || !sym)
+			goto free;
+		FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+			if (sm->sym != sym)
+				continue;
+			if (!slist_has_state(sm->possible, &uninitialized))
+				continue;
+			snprintf(buf, sizeof(buf), "$->%s", sm->name + strlen(arg_name) + 1);
+			if (!member_is_used(expr, param, buf))
+				goto free;
+			sm_warning("struct member %s is uninitialized", sm->name);
+		} END_FOR_EACH_SM(sm);
+
+free:
+		free_string(arg_name);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static int is_being_modified(struct expression *expr)
+{
+	struct expression *parent;
+	struct statement *stmt;
+
+	parent = expr_get_parent_expr(expr);
+	if (!parent)
+		return 0;
+	while (parent->type == EXPR_PREOP && parent->op == '(') {
+		parent = expr_get_parent_expr(parent);
+		if (!parent)
+			return 0;
+	}
+	if (parent->type == EXPR_PREOP && parent->op == '&')
+		return 1;
+	if (parent->type == EXPR_ASSIGNMENT && expr_equiv(parent->left, expr))
+		return 1;
+
+	stmt = last_ptr_list((struct ptr_list *)big_statement_stack);
+	if (stmt && stmt->type == STMT_ASM)
+		return 1;
+
+	return 0;
+}
+
+static void match_symbol(struct expression *expr)
+{
+	char *name;
+
+	if (parse_error)
+		return;
+
+	if (is_impossible_path())
+		return;
+
+	if (is_initialized(expr))
+		return;
+
+	if (is_being_modified(expr))
+		return;
+
+	name = expr_to_str(expr);
+	sm_error("uninitialized symbol '%s'.", name);
+	free_string(name);
+
+	set_state_expr(my_id, expr, &initialized);
+}
+
+static void match_untracked(struct expression *call, int param)
+{
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(call->args, param);
+	arg = strip_expr(arg);
+	if (!arg || arg->type != EXPR_PREOP || arg->op != '&')
+		return;
+	arg = strip_expr(arg->unop);
+	set_state_expr(my_id, arg, &initialized);
+}
+
+static void match_ignore_param(const char *fn, struct expression *expr, void *_arg_nr)
+{
+	int arg_nr = PTR_INT(_arg_nr);
+	struct expression *arg;
+
+	arg = get_argument_from_call_expr(expr->args, arg_nr);
+	arg = strip_expr(arg);
+	if (!arg)
+		return;
+	if (arg->type != EXPR_PREOP || arg->op != '&')
+		return;
+	arg = strip_expr(arg->unop);
+	set_state_expr(my_id, arg, &initialized);
+}
+
+static void register_ignored_params_from_file(void)
+{
+	char name[256];
+	struct token *token;
+	const char *func;
+	char prev_func[256];
+	int param;
+
+	memset(prev_func, 0, sizeof(prev_func));
+	snprintf(name, 256, "%s.ignore_uninitialized_param", option_project_str);
+	name[255] = '\0';
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		param = atoi(token->number);
+
+		add_function_hook(func, &match_ignore_param, INT_PTR(param));
+
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_uninitialized(int id)
+{
+	my_id = id;
+
+	add_hook(&match_declarations, DECLARATION_HOOK);
+	add_extra_mod_hook(&extra_mod_hook);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_untracked_param_hook(&match_untracked);
+	add_pre_merge_hook(my_id, &pre_merge_hook);
+
+	add_hook(&match_dereferences, DEREF_HOOK);
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+	add_hook(&match_call_struct_members, FUNCTION_CALL_HOOK);
+	add_hook(&match_symbol, SYM_HOOK);
+
+	register_ignored_params_from_file();
+}
diff --git a/usr/src/tools/smatch/src/check_unreachable.c b/usr/src/tools/smatch/src/check_unreachable.c
new file mode 100644
index 0000000000..9762ddcfa0
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_unreachable.c
@@ -0,0 +1,291 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static int print_unreached = 1;
+static struct string_list *turn_off_names;
+static struct string_list *ignore_names;
+
+static int empty_statement(struct statement *stmt)
+{
+	if (!stmt)
+		return 0;
+	if (stmt->type == STMT_EXPRESSION && !stmt->expression)
+		return 1;
+	return 0;
+}
+
+static int is_last_stmt(struct statement *cur_stmt)
+{
+	struct symbol *fn = get_base_type(cur_func_sym);
+	struct statement *stmt;
+
+	if (!fn)
+		return 0;
+	stmt = fn->stmt;
+	if (!stmt)
+		stmt = fn->inline_stmt;
+	if (!stmt || stmt->type != STMT_COMPOUND)
+		return 0;
+	stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
+	if (stmt == cur_stmt)
+		return 1;
+	return 0;
+}
+
+static void print_unreached_initializers(struct symbol_list *sym_list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(sym_list, sym) {
+		if (sym->initializer && !(sym->ctype.modifiers & MOD_STATIC))
+			sm_msg("info: '%s' is not actually initialized (unreached code).",
+				(sym->ident ? sym->ident->name : "this variable"));
+	} END_FOR_EACH_PTR(sym);
+}
+
+static int is_ignored_macro(struct statement *stmt)
+{
+	char *name;
+	char *tmp;
+
+	name = get_macro_name(stmt->pos);
+	if (!name)
+		return 0;
+
+	FOR_EACH_PTR(ignore_names, tmp) {
+		if (strcmp(tmp, name) == 0)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static int prev_line_was_endif(struct statement *stmt)
+{
+	struct token *token;
+	struct position pos = stmt->pos;
+
+	pos.line--;
+	pos.pos = 2;
+
+	token = pos_get_token(pos);
+	if (token && token_type(token) == TOKEN_IDENT &&
+	    strcmp(show_ident(token->ident), "endif") == 0)
+		return 1;
+
+	pos.line--;
+	token = pos_get_token(pos);
+	if (token && token_type(token) == TOKEN_IDENT &&
+	    strcmp(show_ident(token->ident), "endif") == 0)
+		return 1;
+
+	return 0;
+}
+
+static int we_jumped_into_the_middle_of_a_loop(struct statement *stmt)
+{
+	struct statement *prev;
+
+	/*
+	 * Smatch doesn't handle loops correctly and this is a hack.  What we
+	 * do is that if the first unreachable statement is a loop and the
+	 * previous statement was a goto then it's probably code like this:
+	 * 	goto first;
+	 * 	for (;;) {
+	 *		frob();
+	 * first:
+	 *		more_frob();
+	 * 	}
+	 * Every statement is reachable but only on the second iteration.
+	 */
+
+	if (stmt->type != STMT_ITERATOR)
+		return 0;
+	prev = get_prev_statement();
+	if (prev && prev->type == STMT_GOTO)
+		return 1;
+	return 0;
+}
+
+static void unreachable_stmt(struct statement *stmt)
+{
+
+	if (__inline_fn)
+		return;
+
+	if (!__path_is_null()) {
+		print_unreached = 1;
+		return;
+	}
+
+	/* if we hit a label then assume there is a matching goto */
+	if (stmt->type == STMT_LABEL)
+		print_unreached = 0;
+	if (prev_line_was_endif(stmt))
+		print_unreached = 0;
+	if (we_jumped_into_the_middle_of_a_loop(stmt))
+		print_unreached = 0;
+
+	if (!print_unreached)
+		return;
+	if (empty_statement(stmt))
+		return;
+	if (is_ignored_macro(stmt))
+		return;
+
+	switch (stmt->type) {
+	case STMT_COMPOUND: /* after a switch before a case stmt */
+	case STMT_RANGE:
+	case STMT_CASE:
+		return;
+	case STMT_DECLARATION: /* switch (x) { int a; case foo: ... */
+		print_unreached_initializers(stmt->declaration);
+		return;
+	case STMT_RETURN: /* gcc complains if you don't have a return statement */
+		if (is_last_stmt(stmt))
+			return;
+		break;
+	case STMT_GOTO:
+		/* people put extra breaks inside switch statements */
+		if (stmt->goto_label && stmt->goto_label->type == SYM_NODE &&
+		    strcmp(stmt->goto_label->ident->name, "break") == 0)
+			return;
+		break;
+	default:
+		break;
+	}
+	sm_msg("info: ignoring unreachable code.");
+	print_unreached = 0;
+}
+
+static int is_turn_off(char *name)
+{
+	char *tmp;
+
+	if (!name)
+		return 0;
+
+	FOR_EACH_PTR(turn_off_names, tmp) {
+		if (strcmp(tmp, name) == 0)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static char *get_function_name(struct statement *stmt)
+{
+	struct expression *expr;
+
+	if (stmt->type != STMT_EXPRESSION)
+		return NULL;
+	expr = stmt->expression;
+	if (!expr || expr->type != EXPR_CALL)
+		return NULL;
+	if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol_name)
+		return NULL;
+	return expr->fn->symbol_name->name;
+}
+
+static void turn_off_unreachable(struct statement *stmt)
+{
+	char *name;
+
+	name = get_macro_name(stmt->pos);
+	if (is_turn_off(name)) {
+		print_unreached = 0;
+		return;
+	}
+
+	if (stmt->type == STMT_IF &&
+	    known_condition_true(stmt->if_conditional) &&  __path_is_null()) {
+		print_unreached = 0;
+		return;
+	}
+
+	name = get_function_name(stmt);
+	if (is_turn_off(name))
+		print_unreached = 0;
+}
+
+static void register_turn_off_macros(void)
+{
+	struct token *token;
+	char *macro;
+	char name[256];
+
+	if (option_project == PROJ_NONE)
+		strcpy(name, "unreachable.turn_off");
+	else
+		snprintf(name, 256, "%s.unreachable.turn_off", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		macro = alloc_string(show_ident(token->ident));
+		add_ptr_list(&turn_off_names, macro);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void register_ignored_macros(void)
+{
+	struct token *token;
+	char *macro;
+	char name[256];
+
+	if (option_project == PROJ_NONE)
+		strcpy(name, "unreachable.ignore");
+	else
+		snprintf(name, 256, "%s.unreachable.ignore", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		macro = alloc_string(show_ident(token->ident));
+		add_ptr_list(&ignore_names, macro);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void check_unreachable(int id)
+{
+	my_id = id;
+
+	register_turn_off_macros();
+	register_ignored_macros();
+	add_hook(&unreachable_stmt, STMT_HOOK);
+	add_hook(&turn_off_unreachable, STMT_HOOK_AFTER);
+}
diff --git a/usr/src/tools/smatch/src/check_unused_ret.c b/usr/src/tools/smatch/src/check_unused_ret.c
new file mode 100644
index 0000000000..0729713b0f
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_unused_ret.c
@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This check is supposed to find places like this:
+ * err = foo();
+ * err = bar();
+ * if (err)
+ *         return err;
+ * (the first assignment isn't used)
+ *
+ * How the check works is that every assignment gets an ID.
+ * We store that assignment ID in a list of assignments that
+ * haven't been used.  We also set the state of 'err' from
+ * the example above to be.  Then when we use 'err' we remove
+ * it from the list.  At the end of the function we print
+ * a list of assignments that still haven't been used.
+ *
+ * Note that this check only works for assignments to
+ * EXPR_SYMBOL.  Maybe it could be modified to cover other
+ * assignments later but then you would have to deal with
+ * scope issues.
+ *
+ * Also this state is quite tied to the order the callbacks
+ * are called in smatch_flow.c.  (If the order changed it
+ * would break).
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_function_hashtable.h"
+
+static int my_id;
+
+struct assignment {
+	int assign_id;
+	char *name;
+	char *function;
+	int line;
+};
+ALLOCATOR(assignment, "assignment id");
+DECLARE_PTR_LIST(assignment_list, struct assignment);
+static struct assignment_list *assignment_list;
+
+static struct expression *skip_this;
+static int assign_id;
+
+static DEFINE_HASHTABLE_INSERT(insert_func, char, int);
+static DEFINE_HASHTABLE_SEARCH(search_func, char, int);
+static struct hashtable *ignored_funcs;
+
+static const char *kernel_ignored[] = {
+	"inb",
+	"inl",
+	"inw",
+	"readb",
+	"readl",
+	"readw",
+};
+
+static char *get_fn_name(struct expression *expr)
+{
+	if (expr->type != EXPR_CALL)
+		return NULL;
+	if (expr->fn->type != EXPR_SYMBOL)
+		return NULL;
+	return expr_to_var(expr->fn);
+}
+
+static int ignored_function(struct expression *expr)
+{
+	char *func;
+	int ret = 0;
+
+	func = get_fn_name(expr);
+	if (!func)
+		return 0;
+	if (search_func(ignored_funcs, func))
+		ret = 1;
+	free_string(func);
+	return ret;
+}
+
+static void match_assign_call(struct expression *expr)
+{
+	struct expression *left;
+	struct assignment *assign;
+
+	if (final_pass)
+		return;
+	if (in_condition())
+		return;
+	if (expr->op != '=')
+		return;
+	if (unreachable())
+		return;
+	if (ignored_function(expr->right))
+		return;
+	left = strip_expr(expr->left);
+	if (!left || left->type != EXPR_SYMBOL)
+		return;
+	if (left->symbol->ctype.modifiers & (MOD_TOPLEVEL | MOD_EXTERN | MOD_STATIC))
+		return;
+
+	skip_this = left;
+
+	set_state_expr(my_id, left, alloc_state_num(assign_id));
+
+	assign = __alloc_assignment(0);
+	assign->assign_id = assign_id++;
+	assign->name = expr_to_var(left);
+	assign->function = get_fn_name(expr->right);
+	assign->line = get_lineno();
+	add_ptr_list(&assignment_list, assign);
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *left;
+
+	if (expr->op != '=')
+		return;
+	left = strip_expr(expr->left);
+	if (!left || left->type != EXPR_SYMBOL)
+		return;
+	set_state_expr(my_id, left, &undefined);
+}
+
+static void delete_used(int assign_id)
+{
+	struct assignment *tmp;
+
+ 	FOR_EACH_PTR(assignment_list, tmp) {
+		if (tmp->assign_id == assign_id) {
+			DELETE_CURRENT_PTR(tmp);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void delete_used_symbols(struct state_list *possible)
+{
+	struct sm_state *tmp;
+
+ 	FOR_EACH_PTR(possible, tmp) {
+		delete_used(PTR_INT(tmp->state->data));
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void match_symbol(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	expr = strip_expr(expr);
+	if (expr == skip_this)
+		return;
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return;
+	delete_used_symbols(sm->possible);
+	set_state_expr(my_id, expr, &undefined);
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	struct assignment *tmp;
+
+	if (__inline_fn)
+		return;
+ 	FOR_EACH_PTR(assignment_list, tmp) {
+		sm_printf("%s:%d %s() ", get_filename(), tmp->line, get_function());
+		sm_printf("warn: unused return: %s = %s()\n",
+			tmp->name, tmp->function);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void match_after_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	clear_assignment_alloc();
+	__free_ptr_list((struct ptr_list **)&assignment_list);
+}
+
+void check_unused_ret(int id)
+{
+	my_id = id;
+
+	/* It turns out that this test is worthless unless you use --two-passes.  */
+	if (!option_two_passes)
+		return;
+	add_hook(&match_assign_call, CALL_ASSIGNMENT_HOOK);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_symbol, SYM_HOOK);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+	add_hook(&match_after_func, AFTER_FUNC_HOOK);
+	ignored_funcs = create_function_hashtable(100);
+	if (option_project == PROJ_KERNEL) {
+		int i;
+
+		for (i = 0; i < ARRAY_SIZE(kernel_ignored); i++)
+			insert_func(ignored_funcs, (char *)kernel_ignored[i], (int *)1);
+	}
+}
diff --git a/usr/src/tools/smatch/src/check_unwind.c b/usr/src/tools/smatch/src/check_unwind.c
new file mode 100644
index 0000000000..9fa6d0cfe2
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_unwind.c
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is a kernel check to make sure we unwind everything on
+ * on errors.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+#define EBUSY 16
+#define MAX_ERRNO 4095
+
+static int my_id;
+
+STATE(allocated);
+STATE(unallocated);
+
+/* state of unwind function */
+STATE(called);
+
+static int was_passed_as_param(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	struct symbol *arg;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name)
+		return 0;
+	free_string(name);
+
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
+		if (arg == sym)
+			return 1;
+	} END_FOR_EACH_PTR(arg);
+	return 0;
+}
+
+static void print_unwind_functions(const char *fn, struct expression *expr, void *_arg_no)
+{
+	struct expression *arg_expr;
+	int arg_no = PTR_INT(_arg_no);
+	static struct symbol *last_printed = NULL;
+
+	arg_expr = get_argument_from_call_expr(expr->args, arg_no);
+	if (!was_passed_as_param(arg_expr))
+		return;
+	if (last_printed == cur_func_sym)
+		return;
+	last_printed = cur_func_sym;
+	sm_msg("info: is unwind function");
+}
+
+static void request_granted(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *_arg_no)
+{
+	struct expression *arg_expr;
+	int arg_no = PTR_INT(_arg_no);
+
+	if (arg_no == -1) {
+		if (!assign_expr)
+			return;
+		arg_expr = assign_expr->left;
+	} else {
+		arg_expr = get_argument_from_call_expr(call_expr->args, arg_no);
+	}
+	set_state_expr(my_id, arg_expr, &allocated);
+}
+
+static void request_denied(const char *fn, struct expression *call_expr,
+			struct expression *assign_expr, void *_arg_no)
+{
+	struct expression *arg_expr;
+	int arg_no = PTR_INT(_arg_no);
+
+	if (arg_no == -1) {
+		if (!assign_expr)
+			return;
+		arg_expr = assign_expr->left;
+	} else {
+		arg_expr = get_argument_from_call_expr(call_expr->args, arg_no);
+	}
+	set_state_expr(my_id, arg_expr, &unallocated);
+}
+
+static void match_release(const char *fn, struct expression *expr, void *_arg_no)
+{
+	struct expression *arg_expr;
+	int arg_no = PTR_INT(_arg_no);
+
+	arg_expr = get_argument_from_call_expr(expr->args, arg_no);
+	if (get_state_expr(my_id, arg_expr))
+		set_state_expr(my_id, arg_expr, &unallocated);
+	set_equiv_state_expr(my_id, arg_expr, &unallocated);
+}
+
+static void match_unwind_function(const char *fn, struct expression *expr, void *unused)
+{
+	set_state(my_id, "unwind_function", NULL, &called);
+}
+
+static int func_returns_int(void)
+{
+	struct symbol *type;
+
+	type = get_base_type(cur_func_sym);
+	if (!type || type->type != SYM_FN)
+		return 0;
+	type = get_base_type(type);
+	if (type->ctype.base_type == &int_type) {
+		return 1;
+	}
+	return 0;
+}
+
+static void match_return(struct expression *ret_value)
+{
+	struct stree *stree;
+	struct sm_state *tmp;
+	sval_t sval;
+
+	if (!func_returns_int())
+		return;
+	if (get_value(ret_value, &sval) && sval_cmp_val(sval, 0) >= 0)
+		return;
+	if (!implied_not_equal(ret_value, 0))
+		return;
+	if (get_state(my_id, "unwind_function", NULL) == &called)
+		return;
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(my_id, stree, tmp) {
+		if (slist_has_state(tmp->possible, &allocated))
+			sm_warning("'%s' was not released on error", tmp->name);
+	} END_FOR_EACH_SM(tmp);
+}
+
+static void register_unwind_functions(void)
+{
+	struct token *token;
+	const char *func;
+
+	token = get_tokens_file("kernel.unwind_functions");
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		add_function_hook(func, &match_unwind_function, NULL);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void release_function_indicator(const char *name)
+{
+	if (!option_info)
+		return;
+	add_function_hook(name, &print_unwind_functions, INT_PTR(0));
+}
+
+void check_unwind(int id)
+{
+	if (option_project != PROJ_KERNEL || !option_spammy)
+		return;
+	my_id = id;
+
+	register_unwind_functions();
+
+	return_implies_state("request_resource", 0, 0, &request_granted, INT_PTR(1));
+	return_implies_state("request_resource", -EBUSY, -EBUSY, &request_denied, INT_PTR(1));
+	add_function_hook("release_resource", &match_release, INT_PTR(0));
+	release_function_indicator("release_resource");
+
+	return_implies_state("__request_region", valid_ptr_min, valid_ptr_max, &request_granted, INT_PTR(1));
+	return_implies_state("__request_region", 0, 0, &request_denied, INT_PTR(1));
+	add_function_hook("__release_region", &match_release, INT_PTR(1));
+	release_function_indicator("__release_region");
+
+	return_implies_state("ioremap", valid_ptr_min, valid_ptr_max, &request_granted, INT_PTR(-1));
+	return_implies_state("ioremap", 0, 0, &request_denied, INT_PTR(-1));
+	add_function_hook("iounmap", &match_release, INT_PTR(0));
+
+	return_implies_state("pci_iomap", valid_ptr_min, valid_ptr_max, &request_granted, INT_PTR(-1));
+	return_implies_state("pci_iomap", 0, 0, &request_denied, INT_PTR(-1));
+	add_function_hook("pci_iounmap", &match_release, INT_PTR(1));
+	release_function_indicator("pci_iounmap");
+
+	return_implies_state("__create_workqueue_key", valid_ptr_min, valid_ptr_max, &request_granted,
+			INT_PTR(-1));
+	return_implies_state("__create_workqueue_key", 0, 0, &request_denied, INT_PTR(-1));
+	add_function_hook("destroy_workqueue", &match_release, INT_PTR(0));
+
+	return_implies_state("request_irq", 0, 0, &request_granted, INT_PTR(0));
+	return_implies_state("request_irq", -MAX_ERRNO, -1, &request_denied, INT_PTR(0));
+	add_function_hook("free_irq", &match_release, INT_PTR(0));
+	release_function_indicator("free_irq");
+
+	return_implies_state("register_netdev", 0, 0, &request_granted, INT_PTR(0));
+	return_implies_state("register_netdev", -MAX_ERRNO, -1, &request_denied, INT_PTR(0));
+	add_function_hook("unregister_netdev", &match_release, INT_PTR(0));
+	release_function_indicator("unregister_netdev");
+
+	return_implies_state("misc_register", 0, 0, &request_granted, INT_PTR(0));
+	return_implies_state("misc_register", -MAX_ERRNO, -1, &request_denied, INT_PTR(0));
+	add_function_hook("misc_deregister", &match_release, INT_PTR(0));
+	release_function_indicator("misc_deregister");
+
+
+	add_hook(&match_return, RETURN_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_wait_for_common.c b/usr/src/tools/smatch/src/check_wait_for_common.c
new file mode 100644
index 0000000000..8efb457414
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_wait_for_common.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2011 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_wait_for_common(const char *fn, struct expression *expr, void *unused)
+{
+	char *name;
+
+	if (!expr_unsigned(expr->left))
+		return;
+	name = expr_to_str(expr->left);
+	sm_error("'%s()' returns negative and '%s' is unsigned", fn, name);
+	free_string(name);
+}
+
+void check_wait_for_common(int id)
+{
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+	add_function_assign_hook("wait_for_common", &match_wait_for_common, NULL);
+	add_function_assign_hook("wait_for_completion_interruptible_timeout", &match_wait_for_common, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_wine.c b/usr/src/tools/smatch/src/check_wine.c
new file mode 100644
index 0000000000..af56b2f224
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_wine.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is wine specific stuff for smatch_extra.
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_extra.h"
+
+/* report (R_FATAL, "Can't get OS version."); */
+void match_fatal_report(const char *fn, struct expression *expr,
+			void *unused)
+{
+	struct expression *arg;
+	sval_t sval;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	if (!get_implied_value(arg, &sval))
+		return;
+
+	/* R_FATAL is 9. */
+	if (sval.value == 9)
+		nullify_path();
+}
+
+
+void check_wine(int id)
+{
+	if (option_project != PROJ_WINE)
+		return;
+
+	add_function_hook("report", &match_fatal_report, NULL);
+}
diff --git a/usr/src/tools/smatch/src/check_wine_WtoA.c b/usr/src/tools/smatch/src/check_wine_WtoA.c
new file mode 100644
index 0000000000..4ef4529231
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_wine_WtoA.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Idea from Michael Stefaniuc and Vincent Béron's earlier WtoA
+ * check.
+ *
+ * Apparently when you are coding WINE, you are not allowed to call 
+ * functions that end in capital 'A' from functions that end in 
+ * capital 'W'
+ *
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static int in_w = 0;
+
+static void match_function_def(struct symbol *sym)
+{
+	char *func = get_function();
+	int len;
+
+	if (!func) {
+		in_w = 0;
+		return;
+	}
+	len = strlen(func);
+	if (func[len - 1] == 'W' && len > 2 && func[len - 2] != 'A' )
+		in_w = 1;
+	else
+		in_w = 0;
+}
+
+static int allowed_func(const char *fn)
+{
+	if (!strcmp("lstrcatA", fn))
+		return 1;
+	if (!strcmp("lstrcpyA", fn))
+		return 1;
+	if (!strcmp("lstrcpynA", fn))
+		return 1;
+	if (!strcmp("lstrlenA", fn))
+		return 1;
+	return 0;
+}
+
+static void match_call(struct expression *expr)
+{
+	char *fn_name;
+	int len;
+
+	if (!in_w)
+		return;
+
+	fn_name = expr_to_var(expr->fn);
+	if (!fn_name)
+		goto free;
+	len = strlen(fn_name);
+	if (fn_name[len - 1] == 'A' && !allowed_func(fn_name)) {
+		sm_warning("WtoA call '%s()'", fn_name);
+	}
+free:
+	free_string(fn_name);
+}
+
+void check_wine_WtoA(int id)
+{
+	if (option_project != PROJ_WINE)
+		return;
+
+	my_id = id;
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/check_wine_filehandles.c b/usr/src/tools/smatch/src/check_wine_filehandles.c
new file mode 100644
index 0000000000..c4bf8a7aa1
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_wine_filehandles.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * In wine you aren't allowed to compare file handles with 0,
+ * only with INVALID_HANDLE_VALUE.
+ *
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+STATE(filehandle);
+STATE(oktocheck);
+
+/* originally:
+ *  "(?:CreateFile|CreateMailslot|CreateNamedPipe|FindFirstFile(?:Ex)?|OpenConsole|SetupOpenInfFile|socket)[AW]?"
+ *
+ */
+static const char *filehandle_funcs[] = {
+	"CreateFile",
+	"CreateMailslot",
+	"CreateNamedPipe",
+	"FindFirstFile",
+	"FindFirstFileEx",
+	"OpenConsole",
+	"SetupOpenInfFile",
+	"socket",
+	NULL,
+};
+
+static void ok_to_use(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state != &oktocheck)
+		set_state(my_id, sm->name, sm->sym, &oktocheck);
+}
+
+static void match_returns_handle(const char *fn, struct expression *expr,
+			     void *info)
+{
+	char *left_name = NULL;
+	struct symbol *left_sym;
+
+	left_name = expr_to_var_sym(expr->left, &left_sym);
+	if (!left_name || !left_sym)
+		goto free;
+	set_state_expr(my_id, expr->left, &filehandle);
+free:
+	free_string(left_name);
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (expr->type == EXPR_ASSIGNMENT)
+		match_condition(expr->left);
+
+	if (get_state_expr(my_id, expr) == &filehandle) {
+		char *name;
+
+		name = expr_to_var(expr);
+		sm_error("comparing a filehandle against zero '%s'", name);
+		set_state_expr(my_id, expr, &oktocheck);
+		free_string(name);
+	}
+}
+
+void check_wine_filehandles(int id)
+{
+	int i;
+
+	if (option_project != PROJ_WINE)
+		return;
+
+	my_id = id;
+	for (i = 0; filehandle_funcs[i]; i++) {
+		add_function_assign_hook(filehandle_funcs[i],
+					 &match_returns_handle, NULL);
+	}
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_modification_hook(my_id, ok_to_use);
+}
diff --git a/usr/src/tools/smatch/src/check_wrong_size_arg.c b/usr/src/tools/smatch/src/check_wrong_size_arg.c
new file mode 100644
index 0000000000..06753d23bf
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_wrong_size_arg.c
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static int my_id;
+
+static void match_parameter(const char *fn, struct expression *expr, void *_param)
+{
+	int param = PTR_INT(_param);
+	struct expression *arg;
+	char *name;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	arg = strip_expr(arg);
+	if (!arg)
+		return;
+	if (arg->type != EXPR_COMPARE)
+		return;
+
+	name = expr_to_str_sym(arg, NULL);
+	sm_warning("expected a buffer size but got a comparison '%s'", name);
+	free_string(name);
+}
+
+static void register_funcs_from_file(void)
+{
+	char name[256];
+	struct token *token;
+	const char *func;
+	char prev_func[256];
+	int size;
+
+	memset(prev_func, 0, sizeof(prev_func));
+	snprintf(name, 256, "%s.sizeof_param", option_project_str);
+	name[255] = '\0';
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			break;
+		func = show_ident(token->ident);
+
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			break;
+		size = atoi(token->number);
+
+		token = token->next;
+		if (token_type(token) == TOKEN_SPECIAL) {
+			if (token->special != '-')
+				break;
+			token = token->next;
+		}
+		if (token_type(token) != TOKEN_NUMBER)
+			break;
+		/* we don't care which argument hold the buf pointer */
+		token = token->next;
+
+		if (strcmp(func, prev_func) == 0)
+			continue;
+		strncpy(prev_func, func, 255);
+
+		add_function_hook(func, &match_parameter, INT_PTR(size));
+
+	}
+	if (token_type(token) != TOKEN_STREAMEND)
+		sm_perror("problem parsing '%s'", name);
+	clear_token_alloc();
+}
+
+void check_wrong_size_arg(int id)
+{
+	my_id = id;
+	register_funcs_from_file();
+}
diff --git a/usr/src/tools/smatch/src/check_zero_to_err_ptr.c b/usr/src/tools/smatch/src/check_zero_to_err_ptr.c
new file mode 100644
index 0000000000..8d5984a183
--- /dev/null
+++ b/usr/src/tools/smatch/src/check_zero_to_err_ptr.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static int is_comparison_call(struct expression *expr)
+{
+	expr = expr_get_parent_expr(expr);
+	if (!expr || expr->type != EXPR_COMPARE)
+		return 0;
+	if (expr->op != SPECIAL_EQUAL && expr->op != SPECIAL_NOTEQUAL)
+		return 0;
+	return 1;
+}
+
+static int next_line_is_if(struct expression *expr)
+{
+	struct expression *next;
+
+	if (!__next_stmt || __next_stmt->type != STMT_IF)
+		return 0;
+
+	next = strip_expr(__next_stmt->if_conditional);
+	while (next->type == EXPR_PREOP && next->op == '!')
+		next = strip_expr(next->unop);
+	if (expr_equiv(expr, next))
+		return 1;
+	return 0;
+}
+
+static int next_line_checks_IS_ERR(struct expression *call, struct expression *arg)
+{
+	struct expression *next;
+	struct expression *tmp;
+
+	tmp = expr_get_parent_expr(call);
+	if (tmp && tmp->type == EXPR_ASSIGNMENT) {
+		if (next_line_checks_IS_ERR(NULL, tmp->left))
+			return 1;
+	}
+
+	if (!__next_stmt || __next_stmt->type != STMT_IF)
+		return 0;
+
+	next = strip_expr(__next_stmt->if_conditional);
+	while (next->type == EXPR_PREOP && next->op == '!')
+		next = strip_expr(next->unop);
+	if (!next || next->type != EXPR_CALL)
+		return 0;
+	if (next->fn->type != EXPR_SYMBOL || !next->fn->symbol ||
+	    !next->fn->symbol->ident ||
+	    (strcmp(next->fn->symbol->ident->name, "IS_ERR") != 0 &&
+	     strcmp(next->fn->symbol->ident->name, "IS_ERR_OR_NULL") != 0))
+		return 0;
+	next = get_argument_from_call_expr(next->args, 0);
+	return expr_equiv(next, arg);
+}
+
+static int is_valid_ptr(sval_t sval)
+{
+	if (sval.type == &int_ctype &&
+	    (sval.value == INT_MIN || sval.value == INT_MAX))
+		return 0;
+
+	if (sval_cmp(valid_ptr_min_sval, sval) <= 0 &&
+	    sval_cmp(valid_ptr_max_sval, sval) >= 0)
+		return 1;
+	return 0;
+}
+
+static void match_err_ptr(const char *fn, struct expression *expr, void *data)
+{
+	struct expression *arg_expr;
+	struct sm_state *sm, *tmp;
+	sval_t sval;
+
+	arg_expr = get_argument_from_call_expr(expr->args, 0);
+	sm = get_sm_state_expr(SMATCH_EXTRA, arg_expr);
+	if (!sm)
+		return;
+
+	if (is_comparison_call(expr))
+		return;
+
+	if (next_line_checks_IS_ERR(expr, arg_expr))
+		return;
+	if (strcmp(fn, "ERR_PTR") == 0 &&
+	    next_line_is_if(arg_expr))
+		return;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (!estate_rl(tmp->state))
+			continue;
+		if (is_valid_ptr(estate_min(tmp->state)) &&
+		    is_valid_ptr(estate_max(tmp->state))) {
+			sm_warning("passing a valid pointer to '%s'", fn);
+			return;
+		}
+		if (!rl_to_sval(estate_rl(tmp->state), &sval))
+			continue;
+		if (sval.value != 0)
+			continue;
+		sm_warning("passing zero to '%s'", fn);
+		return;
+	} END_FOR_EACH_PTR(tmp);
+}
+
+void check_zero_to_err_ptr(int id)
+{
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	my_id = id;
+	add_function_hook("ERR_PTR", &match_err_ptr, NULL);
+	add_function_hook("ERR_CAST", &match_err_ptr, NULL);
+	add_function_hook("PTR_ERR", &match_err_ptr, NULL);
+}
diff --git a/usr/src/tools/smatch/src/compat-bsd.c b/usr/src/tools/smatch/src/compat-bsd.c
new file mode 100644
index 0000000000..d8acf40b1d
--- /dev/null
+++ b/usr/src/tools/smatch/src/compat-bsd.c
@@ -0,0 +1,36 @@
+/*
+ * BSD Compatibility functions
+ *
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <string.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+
+#include "compat/mmap-blob.c"
+
+long double string_to_ld(const char *nptr, char **endptr)
+{
+	return strtod(nptr, endptr);
+}
diff --git a/usr/src/tools/smatch/src/compat-cygwin.c b/usr/src/tools/smatch/src/compat-cygwin.c
new file mode 100644
index 0000000000..40f291e2b1
--- /dev/null
+++ b/usr/src/tools/smatch/src/compat-cygwin.c
@@ -0,0 +1,56 @@
+/*	
+ * Cygwin Compatibility functions	
+ *	
+ *	
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */	
+	
+	
+	
+#include <sys/mman.h>	
+#include <stdlib.h>	
+#include <string.h>	
+#include <sys/stat.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+	
+void *blob_alloc(unsigned long size)	
+{	
+	void *ptr;	
+	size = (size + 4095) & ~4095;	
+	ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);	
+	if (ptr == MAP_FAILED)	
+		ptr = NULL;	
+	else	
+		memset(ptr, 0, size);	
+	return ptr;	
+}	
+	
+void blob_free(void *addr, unsigned long size)	
+{	
+	size = (size + 4095) & ~4095;	
+	munmap(addr, size);	
+}	
+	
+long double string_to_ld(const char *nptr, char **endptr) 	
+{	
+	return strtod(nptr, endptr);	
+}
diff --git a/usr/src/tools/smatch/src/compat-linux.c b/usr/src/tools/smatch/src/compat-linux.c
new file mode 100644
index 0000000000..a7a61406fa
--- /dev/null
+++ b/usr/src/tools/smatch/src/compat-linux.c
@@ -0,0 +1,7 @@
+#define _GNU_SOURCE
+
+#include "lib.h"
+#include "allocate.h"
+
+#include "compat/mmap-blob.c"
+#include "compat/strtold.c"
diff --git a/usr/src/tools/smatch/src/compat-mingw.c b/usr/src/tools/smatch/src/compat-mingw.c
new file mode 100644
index 0000000000..43f00365bf
--- /dev/null
+++ b/usr/src/tools/smatch/src/compat-mingw.c
@@ -0,0 +1,53 @@
+/*	
+ * MinGW Compatibility functions	
+ *	
+ *	
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */	
+	
+	
+	
+#include <stdarg.h>	
+#include <windef.h>	
+#include <winbase.h>	
+#include <stdlib.h>	
+#include <string.h>	
+	
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+	
+void *blob_alloc(unsigned long size)	
+{	
+	void *ptr;	
+	ptr = malloc(size);	
+	if (ptr != NULL)	
+		memset(ptr, 0, size);	
+	return ptr;	
+}	
+	
+void blob_free(void *addr, unsigned long size)	
+{	
+	free(addr);	
+}	
+	
+long double string_to_ld(const char *nptr, char **endptr) 	
+{	
+	return strtod(nptr, endptr);	
+}
diff --git a/usr/src/tools/smatch/src/compat-solaris.c b/usr/src/tools/smatch/src/compat-solaris.c
new file mode 100644
index 0000000000..7253a892d5
--- /dev/null
+++ b/usr/src/tools/smatch/src/compat-solaris.c
@@ -0,0 +1,33 @@
+#include "lib.h"
+#include "allocate.h"
+
+#include "compat/mmap-blob.c"
+
+#include <floatingpoint.h>
+#include <limits.h>
+#include <errno.h>
+
+long double string_to_ld(const char *str, char **endptr)
+{
+	long double res;
+	decimal_record dr;
+	enum decimal_string_form form;
+	decimal_mode dm;
+	fp_exception_field_type excp;
+	char *echar;
+
+	string_to_decimal ((char **)&str, INT_MAX, 0,
+			   &dr, &form, &echar);
+	if (endptr) *endptr = (char *)str;
+
+	if (form == invalid_form) {
+		errno = EINVAL;
+		return 0.0;
+	}
+
+	dm.rd = fp_nearest;
+	decimal_to_quadruple (&res, &dm, &dr, &excp);
+        if (excp & ((1 << fp_overflow) | (1 << fp_underflow)))
+                errno = ERANGE;
+	return res;
+}
diff --git a/usr/src/tools/smatch/src/compat.h b/usr/src/tools/smatch/src/compat.h
new file mode 100644
index 0000000000..9814ae3e89
--- /dev/null
+++ b/usr/src/tools/smatch/src/compat.h
@@ -0,0 +1,28 @@
+#ifndef COMPAT_H
+#define COMPAT_H
+
+/*
+ * Various systems get these things wrong. So
+ * we create a small compat library for them.
+ *
+ *  - zeroed anonymous mmap
+ *	Missing in MinGW
+ *  - "string to long double" (C99 strtold())
+ *	Missing in Solaris and MinGW
+ */
+struct stream;
+struct stat;
+
+/*
+ * Our "blob" allocator works on chunks that are multiples
+ * of this size (the underlying allocator may be a mmap that
+ * cannot handle smaller chunks, for example, so trying to
+ * allocate blobs that aren't aligned is not going to work).
+ */
+#define CHUNK 32768
+
+void *blob_alloc(unsigned long size);
+void blob_free(void *addr, unsigned long size);
+long double string_to_ld(const char *nptr, char **endptr);
+
+#endif
diff --git a/usr/src/tools/smatch/src/compat/bswap.h b/usr/src/tools/smatch/src/compat/bswap.h
new file mode 100644
index 0000000000..f0b7e93cc2
--- /dev/null
+++ b/usr/src/tools/smatch/src/compat/bswap.h
@@ -0,0 +1,54 @@
+#ifndef _COMPAT_BSWAP_H_
+#define _COMPAT_BSWAP_H_
+
+#if defined(__GNUC__)
+#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8))
+#define	__HAS_BUILTIN_BSWAP16
+#endif
+#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
+#define	__HAS_BUILTIN_BSWAP32
+#define	__HAS_BUILTIN_BSWAP64
+#endif
+#endif
+
+#if defined(__clang__)
+#if (__clang_major__ > 3) || ((__clang_major__ == 3) && (__clang_minor__ >= 2))
+#define	__HAS_BUILTIN_BSWAP16
+#endif
+#if (__clang_major__ > 3) || ((__clang_major__ == 3) && (__clang_minor__ >= 0))
+#define	__HAS_BUILTIN_BSWAP32
+#define	__HAS_BUILTIN_BSWAP64
+#endif
+#endif
+
+#ifdef __HAS_BUILTIN_BSWAP16
+#define bswap16(x)	__builtin_bswap16(x)
+#else
+#include <stdint.h>
+static inline uint16_t bswap16(uint16_t x)
+{
+	return x << 8 | x >> 8;
+}
+#endif
+
+#ifdef __HAS_BUILTIN_BSWAP32
+#define bswap32(x)	__builtin_bswap32(x)
+#else
+#include <stdint.h>
+static inline uint32_t bswap32(uint32_t x)
+{
+	return x >> 24 | (x >> 8 & 0xff00) | (x << 8 & 0xff0000) | x << 24;
+}
+#endif
+
+#ifdef __HAS_BUILTIN_BSWAP64
+#define bswap64(x)	__builtin_bswap64(x)
+#else
+#include <stdint.h>
+static inline uint64_t bswap64(uint64_t x)
+{
+	return ((uint64_t)bswap32(x)) << 32 | bswap32(x >> 32);
+}
+#endif
+
+#endif
diff --git a/usr/src/tools/smatch/src/compat/mmap-blob.c b/usr/src/tools/smatch/src/compat/mmap-blob.c
new file mode 100644
index 0000000000..1cab4dead9
--- /dev/null
+++ b/usr/src/tools/smatch/src/compat/mmap-blob.c
@@ -0,0 +1,37 @@
+#include <sys/mman.h>
+#include <sys/types.h>
+
+/*
+ * Allow old BSD naming too, it would be a pity to have to make a
+ * separate file just for this.
+ */
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+/*
+ * Our blob allocator enforces the strict CHUNK size
+ * requirement, as a portability check.
+ */
+void *blob_alloc(unsigned long size)
+{
+	void *ptr;
+
+	if (size & ~CHUNK)
+		die("internal error: bad allocation size (%lu bytes)", size);
+	ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	if (ptr == MAP_FAILED)
+		ptr = NULL;
+	return ptr;
+}
+
+void blob_free(void *addr, unsigned long size)
+{
+	if (!size || (size & ~CHUNK) || ((unsigned long) addr & 512))
+		die("internal error: bad blob free (%lu bytes at %p)", size, addr);
+#ifndef DEBUG
+	munmap(addr, size);
+#else
+	mprotect(addr, size, PROT_NONE);
+#endif
+}
diff --git a/usr/src/tools/smatch/src/compat/strtold.c b/usr/src/tools/smatch/src/compat/strtold.c
new file mode 100644
index 0000000000..1b6ad7d516
--- /dev/null
+++ b/usr/src/tools/smatch/src/compat/strtold.c
@@ -0,0 +1,6 @@
+#include <stdlib.h>
+
+long double string_to_ld(const char *nptr, char **endptr)
+{
+	return strtold(nptr, endptr);
+}
diff --git a/usr/src/tools/smatch/src/compile-i386.c b/usr/src/tools/smatch/src/compile-i386.c
new file mode 100644
index 0000000000..1242d38419
--- /dev/null
+++ b/usr/src/tools/smatch/src/compile-i386.c
@@ -0,0 +1,2405 @@
+/*
+ * sparse/compile-i386.c
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ * Copyright 2003 Jeff Garzik
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * x86 backend
+ *
+ * TODO list:
+ * in general, any non-32bit SYM_BASETYPE is unlikely to work.
+ * complex initializers
+ * bitfields
+ * global struct/union variables
+ * addressing structures, and members of structures (as opposed to
+ *     scalars) on the stack.  Requires smarter stack frame allocation.
+ * labels / goto
+ * any function argument that isn't 32 bits (or promoted to such)
+ * inline asm
+ * floating point
+ *
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <assert.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "scope.h"
+#include "expression.h"
+#include "target.h"
+#include "compile.h"
+#include "bitmap.h"
+#include "version.h"
+
+struct textbuf {
+	unsigned int	len;	/* does NOT include terminating null */
+	char		*text;
+	struct textbuf	*next;
+	struct textbuf	*prev;
+};
+
+struct loop_stack {
+	int		continue_lbl;
+	int		loop_bottom_lbl;
+	struct loop_stack *next;
+};
+
+struct atom;
+struct storage;
+DECLARE_PTR_LIST(str_list, struct atom);
+DECLARE_PTR_LIST(atom_list, struct atom);
+DECLARE_PTR_LIST(storage_list, struct storage);
+
+struct function {
+	int stack_size;
+	int pseudo_nr;
+	struct storage_list *pseudo_list;
+	struct atom_list *atom_list;
+	struct str_list *str_list;
+	struct loop_stack *loop_stack;
+	struct symbol **argv;
+	unsigned int argc;
+	int ret_target;
+};
+
+enum storage_type {
+	STOR_PSEUDO,	/* variable stored on the stack */
+	STOR_ARG,	/* function argument */
+	STOR_SYM,	/* a symbol we can directly ref in the asm */
+	STOR_REG,	/* scratch register */
+	STOR_VALUE,	/* integer constant */
+	STOR_LABEL,	/* label / jump target */
+	STOR_LABELSYM,	/* label generated from symbol's pointer value */
+};
+
+struct reg_info {
+	const char	*name;
+	struct storage	*contains;
+	const unsigned char aliases[12];
+#define own_regno aliases[0]
+};
+
+struct storage {
+	enum storage_type type;
+	unsigned long flags;
+
+	/* STOR_REG */
+	struct reg_info *reg;
+	struct symbol *ctype;
+
+	union {
+		/* STOR_PSEUDO */
+		struct {
+			int pseudo;
+			int offset;
+			int size;
+		};
+		/* STOR_ARG */
+		struct {
+			int idx;
+		};
+		/* STOR_SYM */
+		struct {
+			struct symbol *sym;
+		};
+		/* STOR_VALUE */
+		struct {
+			long long value;
+		};
+		/* STOR_LABEL */
+		struct {
+			int label;
+		};
+		/* STOR_LABELSYM */
+		struct {
+			struct symbol *labelsym;
+		};
+	};
+};
+
+enum {
+	STOR_LABEL_VAL	= (1 << 0),
+	STOR_WANTS_FREE	= (1 << 1),
+};
+
+struct symbol_private {
+	struct storage *addr;
+};
+
+enum atom_type {
+	ATOM_TEXT,
+	ATOM_INSN,
+	ATOM_CSTR,
+};
+
+struct atom {
+	enum atom_type type;
+	union {
+		/* stuff for text */
+		struct {
+			char *text;
+			unsigned int text_len;  /* w/o terminating null */
+		};
+
+		/* stuff for insns */
+		struct {
+			char insn[32];
+			char comment[40];
+			struct storage *op1;
+			struct storage *op2;
+		};
+
+		/* stuff for C strings */
+		struct {
+			struct string *string;
+			int label;
+		};
+	};
+};
+
+
+static struct function *current_func = NULL;
+static struct textbuf *unit_post_text = NULL;
+static const char *current_section;
+
+static void emit_comment(const char * fmt, ...) FORMAT_ATTR(1);
+static void emit_move(struct storage *src, struct storage *dest,
+		      struct symbol *ctype, const char *comment);
+static int type_is_signed(struct symbol *sym);
+static struct storage *x86_address_gen(struct expression *expr);
+static struct storage *x86_symbol_expr(struct symbol *sym);
+static void x86_symbol(struct symbol *sym);
+static struct storage *x86_statement(struct statement *stmt);
+static struct storage *x86_expression(struct expression *expr);
+
+enum registers {
+	NOREG,
+	 AL,  DL,  CL,  BL,  AH,  DH,  CH,  BH,	// 8-bit
+	 AX,  DX,  CX,  BX,  SI,  DI,  BP,  SP,	// 16-bit
+	EAX, EDX, ECX, EBX, ESI, EDI, EBP, ESP,	// 32-bit
+	EAX_EDX, ECX_EBX, ESI_EDI,		// 64-bit
+};
+
+/* This works on regno's, reg_info's and hardreg_storage's */
+#define byte_reg(reg) ((reg) - 16)
+#define highbyte_reg(reg) ((reg)-12)
+#define word_reg(reg) ((reg)-8)
+
+#define REGINFO(nr, str, conflicts...)	[nr] = { .name = str, .aliases = { nr , conflicts } }
+
+static struct reg_info reg_info_table[] = {
+	REGINFO( AL,  "%al", AX, EAX, EAX_EDX),
+	REGINFO( DL,  "%dl", DX, EDX, EAX_EDX),
+	REGINFO( CL,  "%cl", CX, ECX, ECX_EBX),
+	REGINFO( BL,  "%bl", BX, EBX, ECX_EBX),
+	REGINFO( AH,  "%ah", AX, EAX, EAX_EDX),
+	REGINFO( DH,  "%dh", DX, EDX, EAX_EDX),
+	REGINFO( CH,  "%ch", CX, ECX, ECX_EBX),
+	REGINFO( BH,  "%bh", BX, EBX, ECX_EBX),
+	REGINFO( AX,  "%ax", AL, AH, EAX, EAX_EDX),
+	REGINFO( DX,  "%dx", DL, DH, EDX, EAX_EDX),
+	REGINFO( CX,  "%cx", CL, CH, ECX, ECX_EBX),
+	REGINFO( BX,  "%bx", BL, BH, EBX, ECX_EBX),
+	REGINFO( SI,  "%si", ESI, ESI_EDI),
+	REGINFO( DI,  "%di", EDI, ESI_EDI),
+	REGINFO( BP,  "%bp", EBP),
+	REGINFO( SP,  "%sp", ESP),
+	REGINFO(EAX, "%eax", AL, AH, AX, EAX_EDX),
+	REGINFO(EDX, "%edx", DL, DH, DX, EAX_EDX),
+	REGINFO(ECX, "%ecx", CL, CH, CX, ECX_EBX),
+	REGINFO(EBX, "%ebx", BL, BH, BX, ECX_EBX),
+	REGINFO(ESI, "%esi", SI, ESI_EDI),
+	REGINFO(EDI, "%edi", DI, ESI_EDI),
+	REGINFO(EBP, "%ebp", BP),
+	REGINFO(ESP, "%esp", SP),
+	REGINFO(EAX_EDX, "%eax:%edx", AL, AH, AX, EAX, DL, DH, DX, EDX),
+	REGINFO(ECX_EBX, "%ecx:%ebx", CL, CH, CX, ECX, BL, BH, BX, EBX),
+	REGINFO(ESI_EDI, "%esi:%edi", SI, ESI, DI, EDI),
+};
+
+#define REGSTORAGE(nr) [nr] = { .type = STOR_REG, .reg = reg_info_table + (nr) }
+
+static struct storage hardreg_storage_table[] = {
+	REGSTORAGE(AL), REGSTORAGE(DL), REGSTORAGE(CL), REGSTORAGE(BL),
+	REGSTORAGE(AH), REGSTORAGE(DH), REGSTORAGE(CH), REGSTORAGE(BH),
+	REGSTORAGE(AX), REGSTORAGE(DX), REGSTORAGE(CX), REGSTORAGE(BX),
+	REGSTORAGE(SI), REGSTORAGE(DI), REGSTORAGE(BP), REGSTORAGE(SP),
+	REGSTORAGE(EAX), REGSTORAGE(EDX), REGSTORAGE(ECX), REGSTORAGE(EBX),
+	REGSTORAGE(ESI), REGSTORAGE(EDI), REGSTORAGE(EBP), REGSTORAGE(ESP),
+	REGSTORAGE(EAX_EDX), REGSTORAGE(ECX_EBX), REGSTORAGE(ESI_EDI),
+};
+
+#define REG_EAX (&hardreg_storage_table[EAX])
+#define REG_ECX (&hardreg_storage_table[ECX])
+#define REG_EDX (&hardreg_storage_table[EDX])
+#define REG_ESP (&hardreg_storage_table[ESP])
+#define REG_DL	(&hardreg_storage_table[DL])
+#define REG_DX	(&hardreg_storage_table[DX])
+#define REG_AL	(&hardreg_storage_table[AL])
+#define REG_AX	(&hardreg_storage_table[AX])
+
+static DECLARE_BITMAP(regs_in_use, 256);
+
+static inline struct storage * reginfo_reg(struct reg_info *info)
+{
+	return hardreg_storage_table + info->own_regno;
+}
+
+static struct storage * get_hardreg(struct storage *reg, int clear)
+{
+	struct reg_info *info = reg->reg;
+	const unsigned char *aliases;
+	int regno;
+
+	aliases = info->aliases;
+	while ((regno = *aliases++) != NOREG) {
+		if (test_bit(regno, regs_in_use))
+			goto busy;
+		if (clear)
+			reg_info_table[regno].contains = NULL;
+	}
+	set_bit(info->own_regno, regs_in_use);
+	return reg;
+busy:
+	fprintf(stderr, "register %s is busy\n", info->name);
+	if (regno + reg_info_table != info)
+		fprintf(stderr, "  conflicts with %s\n", reg_info_table[regno].name);
+	exit(1);
+}
+
+static void put_reg(struct storage *reg)
+{
+	struct reg_info *info = reg->reg;
+	int regno = info->own_regno;
+
+	if (test_and_clear_bit(regno, regs_in_use))
+		return;
+	fprintf(stderr, "freeing already free'd register %s\n", reg_info_table[regno].name);
+}
+
+struct regclass {
+	const char *name;
+	const unsigned char regs[30];
+};
+
+static struct regclass regclass_8 = { "8-bit", { AL, DL, CL, BL, AH, DH, CH, BH }};
+static struct regclass regclass_16 = { "16-bit", { AX, DX, CX, BX, SI, DI, BP }};
+static struct regclass regclass_32 = { "32-bit", { EAX, EDX, ECX, EBX, ESI, EDI, EBP }};
+static struct regclass regclass_64 = { "64-bit", { EAX_EDX, ECX_EBX, ESI_EDI }};
+
+static struct regclass regclass_32_8 = { "32-bit bytes", { EAX, EDX, ECX, EBX }};
+
+static struct regclass *get_regclass_bits(int bits)
+{
+	switch (bits) {
+	case 8: return &regclass_8;
+	case 16: return &regclass_16;
+	case 64: return &regclass_64;
+	default: return &regclass_32;
+	}
+}
+
+static struct regclass *get_regclass(struct expression *expr)
+{
+	return get_regclass_bits(expr->ctype->bit_size);
+}
+
+static int register_busy(int regno)
+{
+	if (!test_bit(regno, regs_in_use)) {
+		struct reg_info *info = reg_info_table + regno;
+		const unsigned char *regs = info->aliases+1;
+
+		while ((regno = *regs) != NOREG) {
+			regs++;
+			if (test_bit(regno, regs_in_use))
+				goto busy;
+		}
+		return 0;
+	}
+busy:
+	return 1;
+}
+
+static struct storage *get_reg(struct regclass *class)
+{
+	const unsigned char *regs = class->regs;
+	int regno;
+
+	while ((regno = *regs) != NOREG) {
+		regs++;
+		if (register_busy(regno))
+			continue;
+		return get_hardreg(hardreg_storage_table + regno, 1);
+	}
+	fprintf(stderr, "Ran out of %s registers\n", class->name);
+	exit(1);
+}
+
+static struct storage *get_reg_value(struct storage *value, struct regclass *class)
+{
+	struct reg_info *info;
+	struct storage *reg;
+
+	/* Do we already have it somewhere */
+	info = value->reg;
+	if (info && info->contains == value) {
+		emit_comment("already have register %s", info->name);
+		return get_hardreg(hardreg_storage_table + info->own_regno, 0);
+	}
+
+	reg = get_reg(class);
+	emit_move(value, reg, value->ctype, "reload register");
+	info = reg->reg;
+	info->contains = value;
+	value->reg = info;
+	return reg;
+}
+
+static struct storage *temp_from_bits(unsigned int bit_size)
+{
+	return get_reg(get_regclass_bits(bit_size));
+}
+
+static inline unsigned int pseudo_offset(struct storage *s)
+{
+	if (s->type != STOR_PSEUDO)
+		return 123456;	/* intentionally bogus value */
+
+	return s->offset;
+}
+
+static inline unsigned int arg_offset(struct storage *s)
+{
+	if (s->type != STOR_ARG)
+		return 123456;	/* intentionally bogus value */
+
+	/* FIXME: this is wrong wrong wrong */
+	return current_func->stack_size + ((1 + s->idx) * 4);
+}
+
+static const char *pretty_offset(int ofs)
+{
+	static char esp_buf[64];
+
+	if (ofs)
+		sprintf(esp_buf, "%d(%%esp)", ofs);
+	else
+		strcpy(esp_buf, "(%esp)");
+
+	return esp_buf;
+}
+
+static void stor_sym_init(struct symbol *sym)
+{
+	struct storage *stor;
+	struct symbol_private *priv;
+
+	priv = calloc(1, sizeof(*priv) + sizeof(*stor));
+	if (!priv)
+		die("OOM in stor_sym_init");
+
+	stor = (struct storage *) (priv + 1);
+
+	priv->addr = stor;
+	stor->type = STOR_SYM;
+	stor->sym = sym;
+}
+
+static const char *stor_op_name(struct storage *s)
+{
+	static char name[32];
+
+	switch (s->type) {
+	case STOR_PSEUDO:
+		strcpy(name, pretty_offset((int) pseudo_offset(s)));
+		break;
+	case STOR_ARG:
+		strcpy(name, pretty_offset((int) arg_offset(s)));
+		break;
+	case STOR_SYM:
+		strcpy(name, show_ident(s->sym->ident));
+		break;
+	case STOR_REG:
+		strcpy(name, s->reg->name);
+		break;
+	case STOR_VALUE:
+		sprintf(name, "$%Ld", s->value);
+		break;
+	case STOR_LABEL:
+		sprintf(name, "%s.L%d", s->flags & STOR_LABEL_VAL ? "$" : "",
+			s->label);
+		break;
+	case STOR_LABELSYM:
+		sprintf(name, "%s.LS%p", s->flags & STOR_LABEL_VAL ? "$" : "",
+			s->labelsym);
+		break;
+	}
+
+	return name;
+}
+
+static struct atom *new_atom(enum atom_type type)
+{
+	struct atom *atom;
+
+	atom = calloc(1, sizeof(*atom));	/* TODO: chunked alloc */
+	if (!atom)
+		die("nuclear OOM");
+
+	atom->type = type;
+
+	return atom;
+}
+
+static inline void push_cstring(struct function *f, struct string *str,
+				int label)
+{
+	struct atom *atom;
+
+	atom = new_atom(ATOM_CSTR);
+	atom->string = str;
+	atom->label = label;
+
+	add_ptr_list(&f->str_list, atom);	/* note: _not_ atom_list */
+}
+
+static inline void push_atom(struct function *f, struct atom *atom)
+{
+	add_ptr_list(&f->atom_list, atom);
+}
+
+static void push_text_atom(struct function *f, const char *text)
+{
+	struct atom *atom = new_atom(ATOM_TEXT);
+
+	atom->text = strdup(text);
+	atom->text_len = strlen(text);
+
+	push_atom(f, atom);
+}
+
+static struct storage *new_storage(enum storage_type type)
+{
+	struct storage *stor;
+
+	stor = calloc(1, sizeof(*stor));
+	if (!stor)
+		die("OOM in new_storage");
+
+	stor->type = type;
+
+	return stor;
+}
+
+static struct storage *stack_alloc(int n_bytes)
+{
+	struct function *f = current_func;
+	struct storage *stor;
+
+	assert(f != NULL);
+
+	stor = new_storage(STOR_PSEUDO);
+	stor->type = STOR_PSEUDO;
+	stor->pseudo = f->pseudo_nr;
+	stor->offset = f->stack_size; /* FIXME: stack req. natural align */
+	stor->size = n_bytes;
+	f->stack_size += n_bytes;
+	f->pseudo_nr++;
+
+	add_ptr_list(&f->pseudo_list, stor);
+
+	return stor;
+}
+
+static struct storage *new_labelsym(struct symbol *sym)
+{
+	struct storage *stor;
+
+	stor = new_storage(STOR_LABELSYM);
+
+	if (stor) {
+		stor->flags |= STOR_WANTS_FREE;
+		stor->labelsym = sym;
+	}
+
+	return stor;
+}
+
+static struct storage *new_val(long long value)
+{
+	struct storage *stor;
+
+	stor = new_storage(STOR_VALUE);
+
+	if (stor) {
+		stor->flags |= STOR_WANTS_FREE;
+		stor->value = value;
+	}
+
+	return stor;
+}
+
+static int new_label(void)
+{
+	static int label = 0;
+	return ++label;
+}
+
+static void textbuf_push(struct textbuf **buf_p, const char *text)
+{
+	struct textbuf *tmp, *list = *buf_p;
+	unsigned int text_len = strlen(text);
+	unsigned int alloc_len = text_len + 1 + sizeof(*list);
+
+	tmp = calloc(1, alloc_len);
+	if (!tmp)
+		die("OOM on textbuf alloc");
+
+	tmp->text = ((void *) tmp) + sizeof(*tmp);
+	memcpy(tmp->text, text, text_len + 1);
+	tmp->len = text_len;
+
+	/* add to end of list */
+	if (!list) {
+		list = tmp;
+		tmp->prev = tmp;
+	} else {
+		tmp->prev = list->prev;
+		tmp->prev->next = tmp;
+		list->prev = tmp;
+	}
+	tmp->next = list;
+
+	*buf_p = list;
+}
+
+static void textbuf_emit(struct textbuf **buf_p)
+{
+	struct textbuf *tmp, *list = *buf_p;
+
+	while (list) {
+		tmp = list;
+		if (tmp->next == tmp)
+			list = NULL;
+		else {
+			tmp->prev->next = tmp->next;
+			tmp->next->prev = tmp->prev;
+			list = tmp->next;
+		}
+
+		fputs(tmp->text, stdout);
+
+		free(tmp);
+	}
+
+	*buf_p = list;
+}
+
+static void insn(const char *insn, struct storage *op1, struct storage *op2,
+		 const char *comment_in)
+{
+	struct function *f = current_func;
+	struct atom *atom = new_atom(ATOM_INSN);
+
+	assert(insn != NULL);
+
+	strcpy(atom->insn, insn);
+	if (comment_in && (*comment_in))
+		strncpy(atom->comment, comment_in,
+			sizeof(atom->comment) - 1);
+
+	atom->op1 = op1;
+	atom->op2 = op2;
+
+	push_atom(f, atom);
+}
+
+static void emit_comment(const char *fmt, ...)
+{
+	struct function *f = current_func;
+	static char tmpbuf[100] = "\t# ";
+	va_list args;
+	int i;
+
+	va_start(args, fmt);
+	i = vsnprintf(tmpbuf+3, sizeof(tmpbuf)-4, fmt, args);
+	va_end(args);
+	tmpbuf[i+3] = '\n';
+	tmpbuf[i+4] = '\0';
+	push_text_atom(f, tmpbuf);
+}
+
+static void emit_label (int label, const char *comment)
+{
+	struct function *f = current_func;
+	char s[64];
+
+	if (!comment)
+		sprintf(s, ".L%d:\n", label);
+	else
+		sprintf(s, ".L%d:\t\t\t\t\t# %s\n", label, comment);
+
+	push_text_atom(f, s);
+}
+
+static void emit_labelsym (struct symbol *sym, const char *comment)
+{
+	struct function *f = current_func;
+	char s[64];
+
+	if (!comment)
+		sprintf(s, ".LS%p:\n", sym);
+	else
+		sprintf(s, ".LS%p:\t\t\t\t# %s\n", sym, comment);
+
+	push_text_atom(f, s);
+}
+
+void emit_unit_begin(const char *basename)
+{
+	printf("\t.file\t\"%s\"\n", basename);
+}
+
+void emit_unit_end(void)
+{
+	textbuf_emit(&unit_post_text);
+	printf("\t.ident\t\"sparse silly x86 backend (version %s)\"\n", SPARSE_VERSION);
+}
+
+/* conditionally switch sections */
+static void emit_section(const char *s)
+{
+	if (s == current_section)
+		return;
+	if (current_section && (!strcmp(s, current_section)))
+		return;
+
+	printf("\t%s\n", s);
+	current_section = s;
+}
+
+static void emit_insn_atom(struct function *f, struct atom *atom)
+{
+	char s[128];
+	char comment[64];
+	struct storage *op1 = atom->op1;
+	struct storage *op2 = atom->op2;
+
+	if (atom->comment[0])
+		sprintf(comment, "\t\t# %s", atom->comment);
+	else
+		comment[0] = 0;
+
+	if (atom->op2) {
+		char tmp[16];
+		strcpy(tmp, stor_op_name(op1));
+		sprintf(s, "\t%s\t%s, %s%s\n",
+			atom->insn, tmp, stor_op_name(op2), comment);
+	} else if (atom->op1)
+		sprintf(s, "\t%s\t%s%s%s\n",
+			atom->insn, stor_op_name(op1),
+			comment[0] ? "\t" : "", comment);
+	else
+		sprintf(s, "\t%s\t%s%s\n",
+			atom->insn,
+			comment[0] ? "\t\t" : "", comment);
+
+	if (write(STDOUT_FILENO, s, strlen(s)) < 0)
+		die("can't write to stdout");
+}
+
+static void emit_atom_list(struct function *f)
+{
+	struct atom *atom;
+
+	FOR_EACH_PTR(f->atom_list, atom) {
+		switch (atom->type) {
+		case ATOM_TEXT: {
+			if (write(STDOUT_FILENO, atom->text, atom->text_len) < 0)
+				die("can't write to stdout");
+			break;
+		}
+		case ATOM_INSN:
+			emit_insn_atom(f, atom);
+			break;
+		case ATOM_CSTR:
+			assert(0);
+			break;
+		}
+	} END_FOR_EACH_PTR(atom);
+}
+
+static void emit_string_list(struct function *f)
+{
+	struct atom *atom;
+
+	emit_section(".section\t.rodata");
+
+	FOR_EACH_PTR(f->str_list, atom) {
+		/* FIXME: escape " in string */
+		printf(".L%d:\n", atom->label);
+		printf("\t.string\t%s\n", show_string(atom->string));
+
+		free(atom);
+	} END_FOR_EACH_PTR(atom);
+}
+
+static void func_cleanup(struct function *f)
+{
+	struct storage *stor;
+	struct atom *atom;
+
+	FOR_EACH_PTR(f->atom_list, atom) {
+		if ((atom->type == ATOM_TEXT) && (atom->text))
+			free(atom->text);
+		if (atom->op1 && (atom->op1->flags & STOR_WANTS_FREE))
+			free(atom->op1);
+		if (atom->op2 && (atom->op2->flags & STOR_WANTS_FREE))
+			free(atom->op2);
+		free(atom);
+	} END_FOR_EACH_PTR(atom);
+
+	FOR_EACH_PTR(f->pseudo_list, stor) {
+		free(stor);
+	} END_FOR_EACH_PTR(stor);
+
+	free_ptr_list(&f->pseudo_list);
+	free(f);
+}
+
+/* function prologue */
+static void emit_func_pre(struct symbol *sym)
+{
+	struct function *f;
+	struct symbol *arg;
+	unsigned int i, argc = 0, alloc_len;
+	unsigned char *mem;
+	struct symbol_private *privbase;
+	struct storage *storage_base;
+	struct symbol *base_type = sym->ctype.base_type;
+
+	FOR_EACH_PTR(base_type->arguments, arg) {
+		argc++;
+	} END_FOR_EACH_PTR(arg);
+
+	alloc_len =
+		sizeof(*f) +
+		(argc * sizeof(struct symbol *)) +
+		(argc * sizeof(struct symbol_private)) +
+		(argc * sizeof(struct storage));
+	mem = calloc(1, alloc_len);
+	if (!mem)
+		die("OOM on func info");
+
+	f		=  (struct function *) mem;
+	mem		+= sizeof(*f);
+	f->argv		=  (struct symbol **) mem;
+	mem		+= (argc * sizeof(struct symbol *));
+	privbase	=  (struct symbol_private *) mem;
+	mem		+= (argc * sizeof(struct symbol_private));
+	storage_base	=  (struct storage *) mem;
+
+	f->argc = argc;
+	f->ret_target = new_label();
+
+	i = 0;
+	FOR_EACH_PTR(base_type->arguments, arg) {
+		f->argv[i] = arg;
+		arg->aux = &privbase[i];
+		storage_base[i].type = STOR_ARG;
+		storage_base[i].idx = i;
+		privbase[i].addr = &storage_base[i];
+		i++;
+	} END_FOR_EACH_PTR(arg);
+
+	assert(current_func == NULL);
+	current_func = f;
+}
+
+/* function epilogue */
+static void emit_func_post(struct symbol *sym)
+{
+	const char *name = show_ident(sym->ident);
+	struct function *f = current_func;
+	int stack_size = f->stack_size;
+
+	if (f->str_list)
+		emit_string_list(f);
+
+	/* function prologue */
+	emit_section(".text");
+	if ((sym->ctype.modifiers & MOD_STATIC) == 0)
+		printf(".globl %s\n", name);
+	printf("\t.type\t%s, @function\n", name);
+	printf("%s:\n", name);
+
+	if (stack_size) {
+		char pseudo_const[16];
+
+		sprintf(pseudo_const, "$%d", stack_size);
+		printf("\tsubl\t%s, %%esp\n", pseudo_const);
+	}
+
+	/* function epilogue */
+
+	/* jump target for 'return' statements */
+	emit_label(f->ret_target, NULL);
+
+	if (stack_size) {
+		struct storage *val;
+
+		val = new_storage(STOR_VALUE);
+		val->value = (long long) (stack_size);
+		val->flags = STOR_WANTS_FREE;
+
+		insn("addl", val, REG_ESP, NULL);
+	}
+
+	insn("ret", NULL, NULL, NULL);
+
+	/* output everything to stdout */
+	fflush(stdout);		/* paranoia; needed? */
+	emit_atom_list(f);
+
+	/* function footer */
+	name = show_ident(sym->ident);
+	printf("\t.size\t%s, .-%s\n", name, name);
+
+	func_cleanup(f);
+	current_func = NULL;
+}
+
+/* emit object (a.k.a. variable, a.k.a. data) prologue */
+static void emit_object_pre(const char *name, unsigned long modifiers,
+			    unsigned long alignment, unsigned int byte_size)
+{
+	if ((modifiers & MOD_STATIC) == 0)
+		printf(".globl %s\n", name);
+	emit_section(".data");
+	if (alignment)
+		printf("\t.align %lu\n", alignment);
+	printf("\t.type\t%s, @object\n", name);
+	printf("\t.size\t%s, %d\n", name, byte_size);
+	printf("%s:\n", name);
+}
+
+/* emit value (only) for an initializer scalar */
+static void emit_scalar(struct expression *expr, unsigned int bit_size)
+{
+	const char *type;
+	long long ll;
+
+	assert(expr->type == EXPR_VALUE);
+
+	if (expr->value == 0ULL) {
+		printf("\t.zero\t%d\n", bit_size / 8);
+		return;
+	}
+
+	ll = (long long) expr->value;
+
+	switch (bit_size) {
+	case 8:		type = "byte";	ll = (char) ll; break;
+	case 16:	type = "value";	ll = (short) ll; break;
+	case 32:	type = "long";	ll = (int) ll; break;
+	case 64:	type = "quad";	break;
+	default:	type = NULL;	break;
+	}
+
+	assert(type != NULL);
+
+	printf("\t.%s\t%Ld\n", type, ll);
+}
+
+static void emit_global_noinit(const char *name, unsigned long modifiers,
+			       unsigned long alignment, unsigned int byte_size)
+{
+	char s[64];
+
+	if (modifiers & MOD_STATIC) {
+		sprintf(s, "\t.local\t%s\n", name);
+		textbuf_push(&unit_post_text, s);
+	}
+	if (alignment)
+		sprintf(s, "\t.comm\t%s,%d,%lu\n", name, byte_size, alignment);
+	else
+		sprintf(s, "\t.comm\t%s,%d\n", name, byte_size);
+	textbuf_push(&unit_post_text, s);
+}
+
+static int ea_current, ea_last;
+
+static void emit_initializer(struct symbol *sym,
+			     struct expression *expr)
+{
+	int distance = ea_current - ea_last - 1;
+
+	if (distance > 0)
+		printf("\t.zero\t%d\n", (sym->bit_size / 8) * distance);
+
+	if (expr->type == EXPR_VALUE) {
+		struct symbol *base_type = sym->ctype.base_type;
+		assert(base_type != NULL);
+
+		emit_scalar(expr, sym->bit_size / get_expression_value(base_type->array_size));
+		return;
+	}
+	if (expr->type != EXPR_INITIALIZER)
+		return;
+
+	assert(0); /* FIXME */
+}
+
+static int sort_array_cmp(const struct expression *a,
+			  const struct expression *b)
+{
+	int a_ofs = 0, b_ofs = 0;
+
+	if (a->type == EXPR_POS)
+		a_ofs = (int) a->init_offset;
+	if (b->type == EXPR_POS)
+		b_ofs = (int) b->init_offset;
+
+	return a_ofs - b_ofs;
+}
+
+/* move to front-end? */
+static void sort_array(struct expression *expr)
+{
+	struct expression *entry, **list;
+	unsigned int elem, sorted, i;
+
+	elem = expression_list_size(expr->expr_list);
+	if (!elem)
+		return;
+
+	list = malloc(sizeof(entry) * elem);
+	if (!list)
+		die("OOM in sort_array");
+
+	/* this code is no doubt evil and ignores EXPR_INDEX possibly
+	 * to its detriment and other nasty things.  improvements
+	 * welcome.
+	 */
+	i = 0;
+	sorted = 0;
+	FOR_EACH_PTR(expr->expr_list, entry) {
+		if ((entry->type == EXPR_POS) || (entry->type == EXPR_VALUE)) {
+			/* add entry to list[], in sorted order */
+			if (sorted == 0) {
+				list[0] = entry;
+				sorted = 1;
+			} else {
+				for (i = 0; i < sorted; i++)
+					if (sort_array_cmp(entry, list[i]) <= 0)
+						break;
+
+				/* If inserting into the middle of list[]
+				 * instead of appending, we memmove.
+				 * This is ugly, but thankfully
+				 * uncommon.  Input data with tons of
+				 * entries very rarely have explicit
+				 * offsets.  convert to qsort eventually...
+				 */
+				if (i != sorted)
+					memmove(&list[i + 1], &list[i],
+						(sorted - i) * sizeof(entry));
+				list[i] = entry;
+				sorted++;
+			}
+		}
+	} END_FOR_EACH_PTR(entry);
+
+	i = 0;
+	FOR_EACH_PTR(expr->expr_list, entry) {
+		if ((entry->type == EXPR_POS) || (entry->type == EXPR_VALUE))
+			*THIS_ADDRESS(entry) = list[i++];
+	} END_FOR_EACH_PTR(entry);
+
+	free(list);
+}
+
+static void emit_array(struct symbol *sym)
+{
+	struct symbol *base_type = sym->ctype.base_type;
+	struct expression *expr = sym->initializer;
+	struct expression *entry;
+
+	assert(base_type != NULL);
+
+	stor_sym_init(sym);
+
+	ea_last = -1;
+
+	emit_object_pre(show_ident(sym->ident), sym->ctype.modifiers,
+		        sym->ctype.alignment,
+			sym->bit_size / 8);
+
+	sort_array(expr);
+
+	FOR_EACH_PTR(expr->expr_list, entry) {
+		if (entry->type == EXPR_VALUE) {
+			ea_current = 0;
+			emit_initializer(sym, entry);
+			ea_last = ea_current;
+		} else if (entry->type == EXPR_POS) {
+			ea_current =
+			    entry->init_offset / (base_type->bit_size / 8);
+			emit_initializer(sym, entry->init_expr);
+			ea_last = ea_current;
+		}
+	} END_FOR_EACH_PTR(entry);
+}
+
+void emit_one_symbol(struct symbol *sym)
+{
+	x86_symbol(sym);
+}
+
+static void emit_copy(struct storage *dest, struct storage *src,
+		      struct symbol *ctype)
+{
+	struct storage *reg = NULL;
+	unsigned int bit_size;
+
+	/* FIXME: Bitfield copy! */
+
+	bit_size = src->size * 8;
+	if (!bit_size)
+		bit_size = 32;
+	if ((src->type == STOR_ARG) && (bit_size < 32))
+		bit_size = 32;
+
+	reg = temp_from_bits(bit_size);
+	emit_move(src, reg, ctype, "begin copy ..");
+
+	bit_size = dest->size * 8;
+	if (!bit_size)
+		bit_size = 32;
+	if ((dest->type == STOR_ARG) && (bit_size < 32))
+		bit_size = 32;
+
+	emit_move(reg, dest, ctype, ".... end copy");
+	put_reg(reg);
+}
+
+static void emit_store(struct expression *dest_expr, struct storage *dest,
+		       struct storage *src, int bits)
+{
+	/* FIXME: Bitfield store! */
+	printf("\tst.%d\t\tv%d,[v%d]\n", bits, src->pseudo, dest->pseudo);
+}
+
+static void emit_scalar_noinit(struct symbol *sym)
+{
+	emit_global_noinit(show_ident(sym->ident),
+			   sym->ctype.modifiers, sym->ctype.alignment,
+			   sym->bit_size / 8);
+	stor_sym_init(sym);
+}
+
+static void emit_array_noinit(struct symbol *sym)
+{
+	emit_global_noinit(show_ident(sym->ident),
+			   sym->ctype.modifiers, sym->ctype.alignment,
+			   get_expression_value(sym->array_size) * (sym->bit_size / 8));
+	stor_sym_init(sym);
+}
+
+static const char *opbits(const char *insn, unsigned int bits)
+{
+	static char opbits_str[32];
+	char c;
+
+	switch (bits) {
+	case 8:	 c = 'b'; break;
+	case 16: c = 'w'; break;
+	case 32: c = 'l'; break;
+	case 64: c = 'q'; break;
+	default: abort(); break;
+	}
+
+	sprintf(opbits_str, "%s%c", insn, c);
+
+	return opbits_str;
+}
+
+static void emit_move(struct storage *src, struct storage *dest,
+		      struct symbol *ctype, const char *comment)
+{
+	unsigned int bits;
+	unsigned int is_signed;
+	unsigned int is_dest = (src->type == STOR_REG);
+	const char *opname;
+
+	if (ctype) {
+		bits = ctype->bit_size;
+		is_signed = type_is_signed(ctype);
+	} else {
+		bits = 32;
+		is_signed = 0;
+	}
+
+	/*
+	 * Are we moving from a register to a register?
+	 * Make the new reg to be the "cache".
+	 */
+	if ((dest->type == STOR_REG) && (src->type == STOR_REG)) {
+		struct storage *backing;
+
+reg_reg_move:
+		if (dest == src)
+			return;
+
+		backing = src->reg->contains;
+		if (backing) {
+			/* Is it still valid? */
+			if (backing->reg != src->reg)
+				backing = NULL;
+			else
+				backing->reg = dest->reg;
+		}
+		dest->reg->contains = backing;
+		insn("mov", src, dest, NULL);
+		return;
+	}
+
+	/*
+	 * Are we moving to a register from a non-reg?
+	 *
+	 * See if we have the non-reg source already cached
+	 * in a register..
+	 */
+	if (dest->type == STOR_REG) {
+		if (src->reg) {
+			struct reg_info *info = src->reg;
+			if (info->contains == src) {
+				src = reginfo_reg(info);
+				goto reg_reg_move;
+			}
+		}
+		dest->reg->contains = src;
+		src->reg = dest->reg;
+	}
+
+	if (src->type == STOR_REG) {
+		/* We could just mark the register dirty here and do lazy store.. */
+		src->reg->contains = dest;
+		dest->reg = src->reg;
+	}
+
+	if ((bits == 8) || (bits == 16)) {
+		if (is_dest)
+			opname = "mov";
+		else
+			opname = is_signed ? "movsx" : "movzx";
+	} else
+		opname = "mov";
+
+	insn(opbits(opname, bits), src, dest, comment);
+}
+
+static struct storage *emit_compare(struct expression *expr)
+{
+	struct storage *left = x86_expression(expr->left);
+	struct storage *right = x86_expression(expr->right);
+	struct storage *reg1, *reg2;
+	struct storage *new, *val;
+	const char *opname = NULL;
+	unsigned int right_bits = expr->right->ctype->bit_size;
+
+	switch(expr->op) {
+	case '<': 		opname = "setl";	break;
+	case '>':		opname = "setg";	break;
+	case SPECIAL_LTE:
+				opname = "setle";	break;
+	case SPECIAL_GTE:
+				opname = "setge";	break;
+	case SPECIAL_EQUAL:	opname = "sete";	break;
+	case SPECIAL_NOTEQUAL:	opname = "setne";	break;
+	case SPECIAL_UNSIGNED_LT:
+				opname = "setb";	break;
+	case SPECIAL_UNSIGNED_GT:
+				opname = "seta";	break;
+	case SPECIAL_UNSIGNED_LTE:
+				opname = "setb";	break;
+	case SPECIAL_UNSIGNED_GTE:
+				opname = "setae";	break;
+	default:
+		assert(0);
+		break;
+	}
+
+	/* init EDX to 0 */
+	val = new_storage(STOR_VALUE);
+	val->flags = STOR_WANTS_FREE;
+
+	reg1 = get_reg(&regclass_32_8);
+	emit_move(val, reg1, NULL, NULL);
+
+	/* move op1 into EAX */
+	reg2 = get_reg_value(left, get_regclass(expr->left));
+
+	/* perform comparison, RHS (op1, right) and LHS (op2, EAX) */
+	insn(opbits("cmp", right_bits), right, reg2, NULL);
+	put_reg(reg2);
+
+	/* store result of operation, 0 or 1, in DL using SETcc */
+	insn(opname, byte_reg(reg1), NULL, NULL);
+
+	/* finally, store the result (DL) in a new pseudo / stack slot */
+	new = stack_alloc(4);
+	emit_move(reg1, new, NULL, "end EXPR_COMPARE");
+	put_reg(reg1);
+
+	return new;
+}
+
+static struct storage *emit_value(struct expression *expr)
+{
+#if 0 /* old and slow way */
+	struct storage *new = stack_alloc(4);
+	struct storage *val;
+
+	val = new_storage(STOR_VALUE);
+	val->value = (long long) expr->value;
+	val->flags = STOR_WANTS_FREE;
+	insn("movl", val, new, NULL);
+
+	return new;
+#else
+	struct storage *val;
+
+	val = new_storage(STOR_VALUE);
+	val->value = (long long) expr->value;
+
+	return val;	/* FIXME: memory leak */
+#endif
+}
+
+static struct storage *emit_divide(struct expression *expr, struct storage *left, struct storage *right)
+{
+	struct storage *eax_edx;
+	struct storage *reg, *new;
+	struct storage *val = new_storage(STOR_VALUE);
+
+	emit_comment("begin DIVIDE");
+	eax_edx = get_hardreg(hardreg_storage_table + EAX_EDX, 1);
+
+	/* init EDX to 0 */
+	val->flags = STOR_WANTS_FREE;
+	emit_move(val, REG_EDX, NULL, NULL);
+
+	new = stack_alloc(expr->ctype->bit_size / 8);
+
+	/* EAX is dividend */
+	emit_move(left, REG_EAX, NULL, NULL);
+
+	reg = get_reg_value(right, &regclass_32);
+
+	/* perform binop */
+	insn("div", reg, REG_EAX, NULL);
+	put_reg(reg);
+
+	reg = REG_EAX;
+	if (expr->op == '%')
+		reg = REG_EDX;
+	emit_move(reg, new, NULL, NULL);
+
+	put_reg(eax_edx);
+	emit_comment("end DIVIDE");
+	return new;
+}
+
+static struct storage *emit_binop(struct expression *expr)
+{
+	struct storage *left = x86_expression(expr->left);
+	struct storage *right = x86_expression(expr->right);
+	struct storage *new;
+	struct storage *dest, *src;
+	const char *opname = NULL;
+	const char *suffix = NULL;
+	char opstr[16];
+	int is_signed;
+
+	/* Divides have special register constraints */
+	if ((expr->op == '/') || (expr->op == '%'))
+		return emit_divide(expr, left, right);
+
+	is_signed = type_is_signed(expr->ctype);
+
+	switch (expr->op) {
+	case '+':
+		opname = "add";
+		break;
+	case '-':
+		opname = "sub";
+		break;
+	case '&':
+		opname = "and";
+		break;
+	case '|':
+		opname = "or";
+		break;
+	case '^':
+		opname = "xor";
+		break;
+	case SPECIAL_LEFTSHIFT:
+		opname = "shl";
+		break;
+	case SPECIAL_RIGHTSHIFT:
+		if (is_signed)
+			opname = "sar";
+		else
+			opname = "shr";
+		break;
+	case '*':
+		if (is_signed)
+			opname = "imul";
+		else
+			opname = "mul";
+		break;
+	case SPECIAL_LOGICAL_AND:
+		warning(expr->pos, "bogus bitwise and for logical op (should use '2*setne + and' or something)");
+		opname = "and";
+		break;
+	case SPECIAL_LOGICAL_OR:
+		warning(expr->pos, "bogus bitwise or for logical op (should use 'or + setne' or something)");
+		opname = "or";
+		break;
+	default:
+		error_die(expr->pos, "unhandled binop '%s'\n", show_special(expr->op));
+		break;
+	}
+
+	dest = get_reg_value(right, &regclass_32);
+	src = get_reg_value(left, &regclass_32);
+	switch (expr->ctype->bit_size) {
+	case 8:
+		suffix = "b";
+		break;
+	case 16:
+		suffix = "w";
+		break;
+	case 32:
+		suffix = "l";
+		break;
+	case 64:
+		suffix = "q";		/* FIXME */
+		break;
+	default:
+		assert(0);
+		break;
+	}
+
+	snprintf(opstr, sizeof(opstr), "%s%s", opname, suffix);
+
+	/* perform binop */
+	insn(opstr, src, dest, NULL);
+	put_reg(src);
+
+	/* store result in new pseudo / stack slot */
+	new = stack_alloc(expr->ctype->bit_size / 8);
+	emit_move(dest, new, NULL, "end EXPR_BINOP");
+
+	put_reg(dest);
+
+	return new;
+}
+
+static int emit_conditional_test(struct storage *val)
+{
+	struct storage *reg;
+	struct storage *target_val;
+	int target_false;
+
+	/* load result into EAX */
+	emit_comment("begin if/conditional");
+	reg = get_reg_value(val, &regclass_32);
+
+	/* compare result with zero */
+	insn("test", reg, reg, NULL);
+	put_reg(reg);
+
+	/* create conditional-failed label to jump to */
+	target_false = new_label();
+	target_val = new_storage(STOR_LABEL);
+	target_val->label = target_false;
+	target_val->flags = STOR_WANTS_FREE;
+	insn("jz", target_val, NULL, NULL);
+
+	return target_false;
+}
+
+static int emit_conditional_end(int target_false)
+{
+	struct storage *cond_end_st;
+	int cond_end;
+
+	/* finished generating code for if-true statement.
+	 * add a jump-to-end jump to avoid falling through
+	 * to the if-false statement code.
+	 */
+	cond_end = new_label();
+	cond_end_st = new_storage(STOR_LABEL);
+	cond_end_st->label = cond_end;
+	cond_end_st->flags = STOR_WANTS_FREE;
+	insn("jmp", cond_end_st, NULL, NULL);
+
+	/* if we have both if-true and if-false statements,
+	 * the failed-conditional case will fall through to here
+	 */
+	emit_label(target_false, NULL);
+
+	return cond_end;
+}
+
+static void emit_if_conditional(struct statement *stmt)
+{
+	struct storage *val;
+	int cond_end;
+
+	/* emit test portion of conditional */
+	val = x86_expression(stmt->if_conditional);
+	cond_end = emit_conditional_test(val);
+
+	/* emit if-true statement */
+	x86_statement(stmt->if_true);
+
+	/* emit if-false statement, if present */
+	if (stmt->if_false) {
+		cond_end = emit_conditional_end(cond_end);
+		x86_statement(stmt->if_false);
+	}
+
+	/* end of conditional; jump target for if-true branch */
+	emit_label(cond_end, "end if");
+}
+
+static struct storage *emit_inc_dec(struct expression *expr, int postop)
+{
+	struct storage *addr = x86_address_gen(expr->unop);
+	struct storage *retval;
+	char opname[16];
+
+	strcpy(opname, opbits(expr->op == SPECIAL_INCREMENT ? "inc" : "dec",
+			      expr->ctype->bit_size));
+
+	if (postop) {
+		struct storage *new = stack_alloc(4);
+
+		emit_copy(new, addr, expr->unop->ctype);
+
+		retval = new;
+	} else
+		retval = addr;
+
+	insn(opname, addr, NULL, NULL);
+
+	return retval;
+}
+
+static struct storage *emit_postop(struct expression *expr)
+{
+	return emit_inc_dec(expr, 1);
+}
+
+static struct storage *emit_return_stmt(struct statement *stmt)
+{
+	struct function *f = current_func;
+	struct expression *expr = stmt->ret_value;
+	struct storage *val = NULL, *jmplbl;
+
+	if (expr && expr->ctype) {
+		val = x86_expression(expr);
+		assert(val != NULL);
+		emit_move(val, REG_EAX, expr->ctype, "return");
+	}
+
+	jmplbl = new_storage(STOR_LABEL);
+	jmplbl->flags |= STOR_WANTS_FREE;
+	jmplbl->label = f->ret_target;
+	insn("jmp", jmplbl, NULL, NULL);
+
+	return val;
+}
+
+static struct storage *emit_conditional_expr(struct expression *expr)
+{
+	struct storage *cond, *true = NULL, *false = NULL;
+	struct storage *new = stack_alloc(expr->ctype->bit_size / 8);
+	int target_false, cond_end;
+
+	/* evaluate conditional */
+	cond = x86_expression(expr->conditional);
+	target_false = emit_conditional_test(cond);
+
+	/* handle if-true part of the expression */
+	true = x86_expression(expr->cond_true);
+
+	emit_copy(new, true, expr->ctype);
+
+	cond_end = emit_conditional_end(target_false);
+
+	/* handle if-false part of the expression */
+	false = x86_expression(expr->cond_false);
+
+	emit_copy(new, false, expr->ctype);
+
+	/* end of conditional; jump target for if-true branch */
+	emit_label(cond_end, "end conditional");
+
+	return new;
+}
+
+static struct storage *emit_select_expr(struct expression *expr)
+{
+	struct storage *cond = x86_expression(expr->conditional);
+	struct storage *true = x86_expression(expr->cond_true);
+	struct storage *false = x86_expression(expr->cond_false);
+	struct storage *reg_cond, *reg_true, *reg_false;
+	struct storage *new = stack_alloc(4);
+
+	emit_comment("begin SELECT");
+	reg_cond = get_reg_value(cond, get_regclass(expr->conditional));
+	reg_true = get_reg_value(true, get_regclass(expr));
+	reg_false = get_reg_value(false, get_regclass(expr));
+
+	/*
+	 * Do the actual select: check the conditional for zero,
+	 * move false over true if zero
+	 */ 
+	insn("test", reg_cond, reg_cond, NULL);
+	insn("cmovz", reg_false, reg_true, NULL);
+
+	/* Store it back */
+	emit_move(reg_true, new, expr->ctype, NULL);
+	put_reg(reg_cond);
+	put_reg(reg_true);
+	put_reg(reg_false);
+	emit_comment("end SELECT");
+	return new;
+}
+
+static struct storage *emit_symbol_expr_init(struct symbol *sym)
+{
+	struct expression *expr = sym->initializer;
+	struct symbol_private *priv = sym->aux;
+
+	if (priv == NULL) {
+		priv = calloc(1, sizeof(*priv));
+		sym->aux = priv;
+
+		if (expr == NULL) {
+			struct storage *new = stack_alloc(4);
+			fprintf(stderr, "FIXME! no value for symbol %s.  creating pseudo %d (stack offset %d)\n",
+				show_ident(sym->ident),
+				new->pseudo, new->pseudo * 4);
+			priv->addr = new;
+		} else {
+			priv->addr = x86_expression(expr);
+		}
+	}
+
+	return priv->addr;
+}
+
+static struct storage *emit_string_expr(struct expression *expr)
+{
+	struct function *f = current_func;
+	int label = new_label();
+	struct storage *new;
+
+	push_cstring(f, expr->string, label);
+
+	new = new_storage(STOR_LABEL);
+	new->label = label;
+	new->flags = STOR_LABEL_VAL | STOR_WANTS_FREE;
+	return new;
+}
+
+static struct storage *emit_cast_expr(struct expression *expr)
+{
+	struct symbol *old_type, *new_type;
+	struct storage *op = x86_expression(expr->cast_expression);
+	int oldbits, newbits;
+	struct storage *new;
+
+	old_type = expr->cast_expression->ctype;
+	new_type = expr->cast_type;
+
+	oldbits = old_type->bit_size;
+	newbits = new_type->bit_size;
+	if (oldbits >= newbits)
+		return op;
+
+	emit_move(op, REG_EAX, old_type, "begin cast ..");
+
+	new = stack_alloc(newbits / 8);
+	emit_move(REG_EAX, new, new_type, ".... end cast");
+
+	return new;
+}
+
+static struct storage *emit_regular_preop(struct expression *expr)
+{
+	struct storage *target = x86_expression(expr->unop);
+	struct storage *val, *new = stack_alloc(4);
+	const char *opname = NULL;
+
+	switch (expr->op) {
+	case '!':
+		val = new_storage(STOR_VALUE);
+		val->flags = STOR_WANTS_FREE;
+		emit_move(val, REG_EDX, NULL, NULL);
+		emit_move(target, REG_EAX, expr->unop->ctype, NULL);
+		insn("test", REG_EAX, REG_EAX, NULL);
+		insn("setz", REG_DL, NULL, NULL);
+		emit_move(REG_EDX, new, expr->unop->ctype, NULL);
+
+		break;
+	case '~':
+		opname = "not";
+	case '-':
+		if (!opname)
+			opname = "neg";
+		emit_move(target, REG_EAX, expr->unop->ctype, NULL);
+		insn(opname, REG_EAX, NULL, NULL);
+		emit_move(REG_EAX, new, expr->unop->ctype, NULL);
+		break;
+	default:
+		assert(0);
+		break;
+	}
+
+	return new;
+}
+
+static void emit_case_statement(struct statement *stmt)
+{
+	emit_labelsym(stmt->case_label, NULL);
+	x86_statement(stmt->case_statement);
+}
+
+static void emit_switch_statement(struct statement *stmt)
+{
+	struct storage *val = x86_expression(stmt->switch_expression);
+	struct symbol *sym, *default_sym = NULL;
+	struct storage *labelsym, *label;
+	int switch_end = 0;
+
+	emit_move(val, REG_EAX, stmt->switch_expression->ctype, "begin case");
+
+	/*
+	 * This is where a _real_ back-end would go through the
+	 * cases to decide whether to use a lookup table or a
+	 * series of comparisons etc
+	 */
+	FOR_EACH_PTR(stmt->switch_case->symbol_list, sym) {
+		struct statement *case_stmt = sym->stmt;
+		struct expression *expr = case_stmt->case_expression;
+		struct expression *to = case_stmt->case_to;
+
+		/* default: */
+		if (!expr)
+			default_sym = sym;
+
+		/* case NNN: */
+		else {
+			struct storage *case_val = new_val(expr->value);
+
+			assert (expr->type == EXPR_VALUE);
+
+			insn("cmpl", case_val, REG_EAX, NULL);
+
+			if (!to) {
+				labelsym = new_labelsym(sym);
+				insn("je", labelsym, NULL, NULL);
+			} else {
+				int next_test;
+
+				label = new_storage(STOR_LABEL);
+				label->flags |= STOR_WANTS_FREE;
+				label->label = next_test = new_label();
+
+				/* FIXME: signed/unsigned */
+				insn("jl", label, NULL, NULL);
+
+				case_val = new_val(to->value);
+				insn("cmpl", case_val, REG_EAX, NULL);
+
+				/* TODO: implement and use refcounting... */
+				label = new_storage(STOR_LABEL);
+				label->flags |= STOR_WANTS_FREE;
+				label->label = next_test;
+
+				/* FIXME: signed/unsigned */
+				insn("jg", label, NULL, NULL);
+
+				labelsym = new_labelsym(sym);
+				insn("jmp", labelsym, NULL, NULL);
+
+				emit_label(next_test, NULL);
+			}
+		}
+	} END_FOR_EACH_PTR(sym);
+
+	if (default_sym) {
+		labelsym = new_labelsym(default_sym);
+		insn("jmp", labelsym, NULL, "default");
+	} else {
+		label = new_storage(STOR_LABEL);
+		label->flags |= STOR_WANTS_FREE;
+		label->label = switch_end = new_label();
+		insn("jmp", label, NULL, "goto end of switch");
+	}
+
+	x86_statement(stmt->switch_statement);
+
+	if (stmt->switch_break->used)
+		emit_labelsym(stmt->switch_break, NULL);
+
+	if (switch_end)
+		emit_label(switch_end, NULL);
+}
+
+static void x86_struct_member(struct symbol *sym)
+{
+	printf("\t%s:%d:%ld at offset %ld.%d", show_ident(sym->ident), sym->bit_size, sym->ctype.alignment, sym->offset, sym->bit_offset);
+	printf("\n");
+}
+
+static void x86_symbol(struct symbol *sym)
+{
+	struct symbol *type;
+
+	if (!sym)
+		return;
+
+	type = sym->ctype.base_type;
+	if (!type)
+		return;
+
+	/*
+	 * Show actual implementation information
+	 */
+	switch (type->type) {
+
+	case SYM_ARRAY:
+		if (sym->initializer)
+			emit_array(sym);
+		else
+			emit_array_noinit(sym);
+		break;
+
+	case SYM_BASETYPE:
+		if (sym->initializer) {
+			emit_object_pre(show_ident(sym->ident),
+					sym->ctype.modifiers,
+				        sym->ctype.alignment,
+					sym->bit_size / 8);
+			emit_scalar(sym->initializer, sym->bit_size);
+			stor_sym_init(sym);
+		} else
+			emit_scalar_noinit(sym);
+		break;
+
+	case SYM_STRUCT:
+	case SYM_UNION: {
+		struct symbol *member;
+
+		printf(" {\n");
+		FOR_EACH_PTR(type->symbol_list, member) {
+			x86_struct_member(member);
+		} END_FOR_EACH_PTR(member);
+		printf("}\n");
+		break;
+	}
+
+	case SYM_FN: {
+		struct statement *stmt = type->stmt;
+		if (stmt) {
+			emit_func_pre(sym);
+			x86_statement(stmt);
+			emit_func_post(sym);
+		}
+		break;
+	}
+
+	default:
+		break;
+	}
+
+	if (sym->initializer && (type->type != SYM_BASETYPE) &&
+	    (type->type != SYM_ARRAY)) {
+		printf(" = \n");
+		x86_expression(sym->initializer);
+	}
+}
+
+static void x86_symbol_init(struct symbol *sym);
+
+static void x86_symbol_decl(struct symbol_list *syms)
+{
+	struct symbol *sym;
+	FOR_EACH_PTR(syms, sym) {
+		x86_symbol_init(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+static void loopstk_push(int cont_lbl, int loop_bottom_lbl)
+{
+	struct function *f = current_func;
+	struct loop_stack *ls;
+
+	ls = malloc(sizeof(*ls));
+	ls->continue_lbl = cont_lbl;
+	ls->loop_bottom_lbl = loop_bottom_lbl;
+	ls->next = f->loop_stack;
+	f->loop_stack = ls;
+}
+
+static void loopstk_pop(void)
+{
+	struct function *f = current_func;
+	struct loop_stack *ls;
+
+	assert(f->loop_stack != NULL);
+	ls = f->loop_stack;
+	f->loop_stack = f->loop_stack->next;
+	free(ls);
+}
+
+static int loopstk_break(void)
+{
+	return current_func->loop_stack->loop_bottom_lbl;
+}
+
+static int loopstk_continue(void)
+{
+	return current_func->loop_stack->continue_lbl;
+}
+
+static void emit_loop(struct statement *stmt)
+{
+	struct statement  *pre_statement = stmt->iterator_pre_statement;
+	struct expression *pre_condition = stmt->iterator_pre_condition;
+	struct statement  *statement = stmt->iterator_statement;
+	struct statement  *post_statement = stmt->iterator_post_statement;
+	struct expression *post_condition = stmt->iterator_post_condition;
+	int loop_top = 0, loop_bottom, loop_continue;
+	int have_bottom = 0;
+	struct storage *val;
+
+	loop_bottom = new_label();
+	loop_continue = new_label();
+	loopstk_push(loop_continue, loop_bottom);
+
+	x86_symbol_decl(stmt->iterator_syms);
+	x86_statement(pre_statement);
+	if (!post_condition || post_condition->type != EXPR_VALUE || post_condition->value) {
+		loop_top = new_label();
+		emit_label(loop_top, "loop top");
+	}
+	if (pre_condition) {
+		if (pre_condition->type == EXPR_VALUE) {
+			if (!pre_condition->value) {
+				struct storage *lbv;
+				lbv = new_storage(STOR_LABEL);
+				lbv->label = loop_bottom;
+				lbv->flags = STOR_WANTS_FREE;
+				insn("jmp", lbv, NULL, "go to loop bottom");
+				have_bottom = 1;
+			}
+		} else {
+			struct storage *lbv = new_storage(STOR_LABEL);
+			lbv->label = loop_bottom;
+			lbv->flags = STOR_WANTS_FREE;
+			have_bottom = 1;
+
+			val = x86_expression(pre_condition);
+
+			emit_move(val, REG_EAX, NULL, "loop pre condition");
+			insn("test", REG_EAX, REG_EAX, NULL);
+			insn("jz", lbv, NULL, NULL);
+		}
+	}
+	x86_statement(statement);
+	if (stmt->iterator_continue->used)
+		emit_label(loop_continue, "'continue' iterator");
+	x86_statement(post_statement);
+	if (!post_condition) {
+		struct storage *lbv = new_storage(STOR_LABEL);
+		lbv->label = loop_top;
+		lbv->flags = STOR_WANTS_FREE;
+		insn("jmp", lbv, NULL, "go to loop top");
+	} else if (post_condition->type == EXPR_VALUE) {
+		if (post_condition->value) {
+			struct storage *lbv = new_storage(STOR_LABEL);
+			lbv->label = loop_top;
+			lbv->flags = STOR_WANTS_FREE;
+			insn("jmp", lbv, NULL, "go to loop top");
+		}
+	} else {
+		struct storage *lbv = new_storage(STOR_LABEL);
+		lbv->label = loop_top;
+		lbv->flags = STOR_WANTS_FREE;
+
+		val = x86_expression(post_condition);
+
+		emit_move(val, REG_EAX, NULL, "loop post condition");
+		insn("test", REG_EAX, REG_EAX, NULL);
+		insn("jnz", lbv, NULL, NULL);
+	}
+	if (have_bottom || stmt->iterator_break->used)
+		emit_label(loop_bottom, "loop bottom");
+
+	loopstk_pop();
+}
+
+/*
+ * Print out a statement
+ */
+static struct storage *x86_statement(struct statement *stmt)
+{
+	if (!stmt)
+		return NULL;
+	switch (stmt->type) {
+	default:
+		return NULL;
+	case STMT_RETURN:
+		return emit_return_stmt(stmt);
+	case STMT_DECLARATION:
+		x86_symbol_decl(stmt->declaration);
+		break;
+	case STMT_COMPOUND: {
+		struct statement *s;
+		struct storage *last = NULL;
+
+		FOR_EACH_PTR(stmt->stmts, s) {
+			last = x86_statement(s);
+		} END_FOR_EACH_PTR(s);
+
+		return last;
+	}
+
+	case STMT_EXPRESSION:
+		return x86_expression(stmt->expression);
+	case STMT_IF:
+		emit_if_conditional(stmt);
+		return NULL;
+
+	case STMT_CASE:
+		emit_case_statement(stmt);
+		break;
+	case STMT_SWITCH:
+		emit_switch_statement(stmt);
+		break;
+
+	case STMT_ITERATOR:
+		emit_loop(stmt);
+		break;
+
+	case STMT_NONE:
+		break;
+
+	case STMT_LABEL:
+		printf(".L%p:\n", stmt->label_identifier);
+		x86_statement(stmt->label_statement);
+		break;
+
+	case STMT_GOTO:
+		if (stmt->goto_expression) {
+			struct storage *val = x86_expression(stmt->goto_expression);
+			printf("\tgoto *v%d\n", val->pseudo);
+		} else if (!strcmp("break", show_ident(stmt->goto_label->ident))) {
+			struct storage *lbv = new_storage(STOR_LABEL);
+			lbv->label = loopstk_break();
+			lbv->flags = STOR_WANTS_FREE;
+			insn("jmp", lbv, NULL, "'break'; go to loop bottom");
+		} else if (!strcmp("continue", show_ident(stmt->goto_label->ident))) {
+			struct storage *lbv = new_storage(STOR_LABEL);
+			lbv->label = loopstk_continue();
+			lbv->flags = STOR_WANTS_FREE;
+			insn("jmp", lbv, NULL, "'continue'; go to loop top");
+		} else {
+			struct storage *labelsym = new_labelsym(stmt->goto_label);
+			insn("jmp", labelsym, NULL, NULL);
+		}
+		break;
+	case STMT_ASM:
+		printf("\tasm( .... )\n");
+		break;
+	}
+	return NULL;
+}
+
+static struct storage *x86_call_expression(struct expression *expr)
+{
+	struct function *f = current_func;
+	struct symbol *direct;
+	struct expression *arg, *fn;
+	struct storage *retval, *fncall;
+	int framesize;
+	char s[64];
+
+	if (!expr->ctype) {
+		warning(expr->pos, "\tcall with no type!");
+		return NULL;
+	}
+
+	framesize = 0;
+	FOR_EACH_PTR_REVERSE(expr->args, arg) {
+		struct storage *new = x86_expression(arg);
+		int size = arg->ctype->bit_size;
+
+		/*
+		 * FIXME: i386 SysV ABI dictates that values
+		 * smaller than 32 bits should be placed onto
+		 * the stack as 32-bit objects.  We should not
+		 * blindly do a 32-bit push on objects smaller
+		 * than 32 bits.
+		 */
+		if (size < 32)
+			size = 32;
+		insn("pushl", new, NULL,
+		     !framesize ? "begin function call" : NULL);
+
+		framesize += bits_to_bytes(size);
+	} END_FOR_EACH_PTR_REVERSE(arg);
+
+	fn = expr->fn;
+
+	/* Remove dereference, if any */
+	direct = NULL;
+	if (fn->type == EXPR_PREOP) {
+		if (fn->unop->type == EXPR_SYMBOL) {
+			struct symbol *sym = fn->unop->symbol;
+			if (sym->ctype.base_type->type == SYM_FN)
+				direct = sym;
+		}
+	}
+	if (direct) {
+		struct storage *direct_stor = new_storage(STOR_SYM);
+		direct_stor->flags |= STOR_WANTS_FREE;
+		direct_stor->sym = direct;
+		insn("call", direct_stor, NULL, NULL);
+	} else {
+		fncall = x86_expression(fn);
+		emit_move(fncall, REG_EAX, fn->ctype, NULL);
+
+		strcpy(s, "\tcall\t*%eax\n");
+		push_text_atom(f, s);
+	}
+
+	/* FIXME: pay attention to BITS_IN_POINTER */
+	if (framesize) {
+		struct storage *val = new_storage(STOR_VALUE);
+		val->value = (long long) framesize;
+		val->flags = STOR_WANTS_FREE;
+		insn("addl", val, REG_ESP, NULL);
+	}
+
+	retval = stack_alloc(4);
+	emit_move(REG_EAX, retval, NULL, "end function call");
+
+	return retval;
+}
+
+static struct storage *x86_address_gen(struct expression *expr)
+{
+	struct function *f = current_func;
+	struct storage *addr;
+	struct storage *new;
+	char s[32];
+
+	addr = x86_expression(expr->unop);
+	if (expr->unop->type == EXPR_SYMBOL)
+		return addr;
+
+	emit_move(addr, REG_EAX, NULL, "begin deref ..");
+
+	/* FIXME: operand size */
+	strcpy(s, "\tmovl\t(%eax), %ecx\n");
+	push_text_atom(f, s);
+
+	new = stack_alloc(4);
+	emit_move(REG_ECX, new, NULL, ".... end deref");
+
+	return new;
+}
+
+static struct storage *x86_assignment(struct expression *expr)
+{
+	struct expression *target = expr->left;
+	struct storage *val, *addr;
+
+	if (!expr->ctype)
+		return NULL;
+
+	val = x86_expression(expr->right);
+	addr = x86_address_gen(target);
+
+	switch (val->type) {
+	/* copy, where both operands are memory */
+	case STOR_PSEUDO:
+	case STOR_ARG:
+		emit_copy(addr, val, expr->ctype);
+		break;
+
+	/* copy, one or zero operands are memory */
+	case STOR_REG:
+	case STOR_SYM:
+	case STOR_VALUE:
+	case STOR_LABEL:
+		emit_move(val, addr, expr->left->ctype, NULL);
+		break;
+
+	case STOR_LABELSYM:
+		assert(0);
+		break;
+	}
+	return val;
+}
+
+static int x86_initialization(struct symbol *sym, struct expression *expr)
+{
+	struct storage *val, *addr;
+	int bits;
+
+	if (!expr->ctype)
+		return 0;
+
+	bits = expr->ctype->bit_size;
+	val = x86_expression(expr);
+	addr = x86_symbol_expr(sym);
+	// FIXME! The "target" expression is for bitfield store information.
+	// Leave it NULL, which works fine.
+	emit_store(NULL, addr, val, bits);
+	return 0;
+}
+
+static struct storage *x86_access(struct expression *expr)
+{
+	return x86_address_gen(expr);
+}
+
+static struct storage *x86_preop(struct expression *expr)
+{
+	/*
+	 * '*' is an lvalue access, and is fundamentally different
+	 * from an arithmetic operation. Maybe it should have an
+	 * expression type of its own..
+	 */
+	if (expr->op == '*')
+		return x86_access(expr);
+	if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
+		return emit_inc_dec(expr, 0);
+	return emit_regular_preop(expr);
+}
+
+static struct storage *x86_symbol_expr(struct symbol *sym)
+{
+	struct storage *new = stack_alloc(4);
+
+	if (sym->ctype.modifiers & (MOD_TOPLEVEL | MOD_EXTERN | MOD_STATIC)) {
+		printf("\tmovi.%d\t\tv%d,$%s\n", bits_in_pointer, new->pseudo, show_ident(sym->ident));
+		return new;
+	}
+	if (sym->ctype.modifiers & MOD_ADDRESSABLE) {
+		printf("\taddi.%d\t\tv%d,vFP,$%lld\n", bits_in_pointer, new->pseudo, sym->value);
+		return new;
+	}
+	printf("\taddi.%d\t\tv%d,vFP,$offsetof(%s:%p)\n", bits_in_pointer, new->pseudo, show_ident(sym->ident), sym);
+	return new;
+}
+
+static void x86_symbol_init(struct symbol *sym)
+{
+	struct symbol_private *priv = sym->aux;
+	struct expression *expr = sym->initializer;
+	struct storage *new;
+
+	if (expr)
+		new = x86_expression(expr);
+	else
+		new = stack_alloc(sym->bit_size / 8);
+
+	if (!priv) {
+		priv = calloc(1, sizeof(*priv));
+		sym->aux = priv;
+		/* FIXME: leak! we don't free... */
+		/* (well, we don't free symbols either) */
+	}
+
+	priv->addr = new;
+}
+
+static int type_is_signed(struct symbol *sym)
+{
+	if (sym->type == SYM_NODE)
+		sym = sym->ctype.base_type;
+	if (sym->type == SYM_PTR)
+		return 0;
+	return !(sym->ctype.modifiers & MOD_UNSIGNED);
+}
+
+static struct storage *x86_label_expr(struct expression *expr)
+{
+	struct storage *new = stack_alloc(4);
+	printf("\tmovi.%d\t\tv%d,.L%p\n", bits_in_pointer, new->pseudo, expr->label_symbol);
+	return new;
+}
+
+static struct storage *x86_statement_expr(struct expression *expr)
+{
+	return x86_statement(expr->statement);
+}
+
+static int x86_position_expr(struct expression *expr, struct symbol *base)
+{
+	struct storage *new = x86_expression(expr->init_expr);
+	struct symbol *ctype = expr->init_expr->ctype;
+
+	printf("\tinsert v%d at [%d:%d] of %s\n", new->pseudo,
+		expr->init_offset, ctype->bit_offset,
+		show_ident(base->ident));
+	return 0;
+}
+
+static void x86_initializer_expr(struct expression *expr, struct symbol *ctype)
+{
+	struct expression *entry;
+
+	FOR_EACH_PTR(expr->expr_list, entry) {
+		// Nested initializers have their positions already
+		// recursively calculated - just output them too
+		if (entry->type == EXPR_INITIALIZER) {
+			x86_initializer_expr(entry, ctype);
+			continue;
+		}
+
+		// Ignore initializer indexes and identifiers - the
+		// evaluator has taken them into account
+		if (entry->type == EXPR_IDENTIFIER || entry->type == EXPR_INDEX)
+			continue;
+		if (entry->type == EXPR_POS) {
+			x86_position_expr(entry, ctype);
+			continue;
+		}
+		x86_initialization(ctype, entry);
+	} END_FOR_EACH_PTR(entry);
+}
+
+/*
+ * Print out an expression. Return the pseudo that contains the
+ * variable.
+ */
+static struct storage *x86_expression(struct expression *expr)
+{
+	if (!expr)
+		return NULL;
+
+	if (!expr->ctype) {
+		struct position *pos = &expr->pos;
+		printf("\tno type at %s:%d:%d\n",
+			stream_name(pos->stream),
+			pos->line, pos->pos);
+		return NULL;
+	}
+
+	switch (expr->type) {
+	default:
+		return NULL;
+	case EXPR_CALL:
+		return x86_call_expression(expr);
+
+	case EXPR_ASSIGNMENT:
+		return x86_assignment(expr);
+
+	case EXPR_COMPARE:
+		return emit_compare(expr);
+	case EXPR_BINOP:
+	case EXPR_COMMA:
+	case EXPR_LOGICAL:
+		return emit_binop(expr);
+	case EXPR_PREOP:
+		return x86_preop(expr);
+	case EXPR_POSTOP:
+		return emit_postop(expr);
+	case EXPR_SYMBOL:
+		return emit_symbol_expr_init(expr->symbol);
+	case EXPR_DEREF:
+	case EXPR_SIZEOF:
+	case EXPR_ALIGNOF:
+		warning(expr->pos, "invalid expression after evaluation");
+		return NULL;
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+	case EXPR_IMPLIED_CAST:
+		return emit_cast_expr(expr);
+	case EXPR_VALUE:
+		return emit_value(expr);
+	case EXPR_STRING:
+		return emit_string_expr(expr);
+	case EXPR_INITIALIZER:
+		x86_initializer_expr(expr, expr->ctype);
+		return NULL;
+	case EXPR_SELECT:
+		return emit_select_expr(expr);
+	case EXPR_CONDITIONAL:
+		return emit_conditional_expr(expr);
+	case EXPR_STATEMENT:
+		return x86_statement_expr(expr);
+	case EXPR_LABEL:
+		return x86_label_expr(expr);
+
+	// None of these should exist as direct expressions: they are only
+	// valid as sub-expressions of initializers.
+	case EXPR_POS:
+		warning(expr->pos, "unable to show plain initializer position expression");
+		return NULL;
+	case EXPR_IDENTIFIER:
+		warning(expr->pos, "unable to show identifier expression");
+		return NULL;
+	case EXPR_INDEX:
+		warning(expr->pos, "unable to show index expression");
+		return NULL;
+	case EXPR_TYPE:
+		warning(expr->pos, "unable to show type expression");
+		return NULL;
+	case EXPR_FVALUE:
+		warning(expr->pos, "floating point support is not implemented");
+		return NULL;
+	}
+	return NULL;
+}
diff --git a/usr/src/tools/smatch/src/compile.c b/usr/src/tools/smatch/src/compile.c
new file mode 100644
index 0000000000..eeb996abdf
--- /dev/null
+++ b/usr/src/tools/smatch/src/compile.c
@@ -0,0 +1,86 @@
+/*
+ * Example trivial client program that uses the sparse library
+ * and x86 backend.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ * Copyright 2003 Jeff Garzik
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+#include "compile.h"
+
+static void clean_up_symbols(struct symbol_list *list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		expand_symbol(sym);
+		emit_one_symbol(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+int main(int argc, char **argv)
+{
+	char *file;
+	struct string_list *filelist = NULL;
+
+	bits_in_bool = 8;
+
+	clean_up_symbols(sparse_initialize(argc, argv, &filelist));
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		struct symbol_list *list;
+		const char *basename = strrchr(file, '/');
+		basename = basename ?  basename+1 : file;
+
+		list = sparse(file);
+
+		// Do type evaluation and simplification
+		emit_unit_begin(basename);
+		clean_up_symbols(list);
+		emit_unit_end();
+	} END_FOR_EACH_PTR_NOTAG(file);
+
+#if 0
+	// And show the allocation statistics
+	show_ident_alloc();
+	show_token_alloc();
+	show_symbol_alloc();
+	show_expression_alloc();
+	show_statement_alloc();
+	show_string_alloc();
+	show_bytes_alloc();
+#endif
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/compile.h b/usr/src/tools/smatch/src/compile.h
new file mode 100644
index 0000000000..177363a739
--- /dev/null
+++ b/usr/src/tools/smatch/src/compile.h
@@ -0,0 +1,10 @@
+#ifndef COMPILE_H
+#define COMPILE_H
+
+struct symbol;
+
+extern void emit_one_symbol(struct symbol *);
+extern void emit_unit_begin(const char *);
+extern void emit_unit_end(void);
+
+#endif /* COMPILE_H */
diff --git a/usr/src/tools/smatch/src/cse.c b/usr/src/tools/smatch/src/cse.c
new file mode 100644
index 0000000000..17b3da01a2
--- /dev/null
+++ b/usr/src/tools/smatch/src/cse.c
@@ -0,0 +1,397 @@
+/*
+ * CSE - walk the linearized instruction flow, and
+ * see if we can simplify it and apply CSE on it.
+ *
+ * Copyright (C) 2004 Linus Torvalds
+ */
+
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <assert.h>
+
+#include "parse.h"
+#include "expression.h"
+#include "linearize.h"
+#include "flow.h"
+
+#define INSN_HASH_SIZE 256
+static struct instruction_list *insn_hash_table[INSN_HASH_SIZE];
+
+int repeat_phase;
+
+static int phi_compare(pseudo_t phi1, pseudo_t phi2)
+{
+	const struct instruction *def1 = phi1->def;
+	const struct instruction *def2 = phi2->def;
+
+	if (def1->src1 != def2->src1)
+		return def1->src1 < def2->src1 ? -1 : 1;
+	if (def1->bb != def2->bb)
+		return def1->bb < def2->bb ? -1 : 1;
+	return 0;
+}
+
+
+static void clean_up_one_instruction(struct basic_block *bb, struct instruction *insn)
+{
+	unsigned long hash;
+
+	if (!insn->bb)
+		return;
+	assert(insn->bb == bb);
+	repeat_phase |= simplify_instruction(insn);
+	if (!insn->bb)
+		return;
+	hash = (insn->opcode << 3) + (insn->size >> 3);
+	switch (insn->opcode) {
+	case OP_SEL:
+		hash += hashval(insn->src3);
+		/* Fall through */	
+
+	/* Binary arithmetic */
+	case OP_ADD: case OP_SUB:
+	case OP_MULU: case OP_MULS:
+	case OP_DIVU: case OP_DIVS:
+	case OP_MODU: case OP_MODS:
+	case OP_SHL:
+	case OP_LSR: case OP_ASR:
+	case OP_AND: case OP_OR:
+
+	/* Binary logical */
+	case OP_XOR: case OP_AND_BOOL:
+	case OP_OR_BOOL:
+
+	/* Binary comparison */
+	case OP_SET_EQ: case OP_SET_NE:
+	case OP_SET_LE: case OP_SET_GE:
+	case OP_SET_LT: case OP_SET_GT:
+	case OP_SET_B:  case OP_SET_A:
+	case OP_SET_BE: case OP_SET_AE:
+		hash += hashval(insn->src2);
+		/* Fall through */
+	
+	/* Unary */
+	case OP_NOT: case OP_NEG:
+		hash += hashval(insn->src1);
+		break;
+
+	case OP_SETVAL:
+		hash += hashval(insn->val);
+		break;
+
+	case OP_SYMADDR:
+		hash += hashval(insn->symbol);
+		break;
+
+	case OP_CAST:
+	case OP_SCAST:
+	case OP_PTRCAST:
+		/*
+		 * This is crap! Many "orig_types" are the
+		 * same as far as casts go, we should generate
+		 * some kind of "type hash" that is identical
+		 * for identical casts
+		 */
+		hash += hashval(insn->orig_type);
+		hash += hashval(insn->src);
+		break;
+
+	/* Other */
+	case OP_PHI: {
+		pseudo_t phi;
+		FOR_EACH_PTR(insn->phi_list, phi) {
+			struct instruction *def;
+			if (phi == VOID || !phi->def)
+				continue;
+			def = phi->def;
+			hash += hashval(def->src1);
+			hash += hashval(def->bb);
+		} END_FOR_EACH_PTR(phi);
+		break;
+	}
+
+	default:
+		/*
+		 * Nothing to do, don't even bother hashing them,
+		 * we're not going to try to CSE them
+		 */
+		return;
+	}
+	hash += hash >> 16;
+	hash &= INSN_HASH_SIZE-1;
+	add_instruction(insn_hash_table + hash, insn);
+}
+
+static void clean_up_insns(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		struct instruction *insn;
+		FOR_EACH_PTR(bb->insns, insn) {
+			clean_up_one_instruction(bb, insn);
+		} END_FOR_EACH_PTR(insn);
+	} END_FOR_EACH_PTR(bb);
+}
+
+/* Compare two (sorted) phi-lists */
+static int phi_list_compare(struct pseudo_list *l1, struct pseudo_list *l2)
+{
+	pseudo_t phi1, phi2;
+
+	PREPARE_PTR_LIST(l1, phi1);
+	PREPARE_PTR_LIST(l2, phi2);
+	for (;;) {
+		int cmp;
+
+		while (phi1 && (phi1 == VOID || !phi1->def))
+			NEXT_PTR_LIST(phi1);
+		while (phi2 && (phi2 == VOID || !phi2->def))
+			NEXT_PTR_LIST(phi2);
+
+		if (!phi1)
+			return phi2 ? -1 : 0;
+		if (!phi2)
+			return phi1 ? 1 : 0;
+		cmp = phi_compare(phi1, phi2);
+		if (cmp)
+			return cmp;
+		NEXT_PTR_LIST(phi1);
+		NEXT_PTR_LIST(phi2);
+	}
+	/* Not reached, but we need to make the nesting come out right */
+	FINISH_PTR_LIST(phi2);
+	FINISH_PTR_LIST(phi1);
+}
+
+static int insn_compare(const void *_i1, const void *_i2)
+{
+	const struct instruction *i1 = _i1;
+	const struct instruction *i2 = _i2;
+
+	if (i1->opcode != i2->opcode)
+		return i1->opcode < i2->opcode ? -1 : 1;
+
+	switch (i1->opcode) {
+
+	/* commutative binop */
+	case OP_ADD:
+	case OP_MULU: case OP_MULS:
+	case OP_AND_BOOL: case OP_OR_BOOL:
+	case OP_AND: case OP_OR:
+	case OP_XOR:
+	case OP_SET_EQ: case OP_SET_NE:
+		if (i1->src1 == i2->src2 && i1->src2 == i2->src1)
+			return 0;
+		goto case_binops;
+
+	case OP_SEL:
+		if (i1->src3 != i2->src3)
+			return i1->src3 < i2->src3 ? -1 : 1;
+		/* Fall-through to binops */
+
+	/* Binary arithmetic */
+	case OP_SUB:
+	case OP_DIVU: case OP_DIVS:
+	case OP_MODU: case OP_MODS:
+	case OP_SHL:
+	case OP_LSR: case OP_ASR:
+
+	/* Binary comparison */
+	case OP_SET_LE: case OP_SET_GE:
+	case OP_SET_LT: case OP_SET_GT:
+	case OP_SET_B:  case OP_SET_A:
+	case OP_SET_BE: case OP_SET_AE:
+	case_binops:
+		if (i1->src2 != i2->src2)
+			return i1->src2 < i2->src2 ? -1 : 1;
+		/* Fall through to unops */
+
+	/* Unary */
+	case OP_NOT: case OP_NEG:
+		if (i1->src1 != i2->src1)
+			return i1->src1 < i2->src1 ? -1 : 1;
+		break;
+
+	case OP_SYMADDR:
+		if (i1->symbol != i2->symbol)
+			return i1->symbol < i2->symbol ? -1 : 1;
+		break;
+
+	case OP_SETVAL:
+		if (i1->val != i2->val)
+			return i1->val < i2->val ? -1 : 1;
+		break;
+
+	/* Other */
+	case OP_PHI:
+		return phi_list_compare(i1->phi_list, i2->phi_list);
+
+	case OP_CAST:
+	case OP_SCAST:
+	case OP_PTRCAST:
+		/*
+		 * This is crap! See the comments on hashing.
+		 */
+		if (i1->orig_type != i2->orig_type)
+			return i1->orig_type < i2->orig_type ? -1 : 1;
+		if (i1->src != i2->src)
+			return i1->src < i2->src ? -1 : 1;
+		break;
+
+	default:
+		warning(i1->pos, "bad instruction on hash chain");
+	}
+	if (i1->size != i2->size)
+		return i1->size < i2->size ? -1 : 1;
+	return 0;
+}
+
+static void sort_instruction_list(struct instruction_list **list)
+{
+	sort_list((struct ptr_list **)list , insn_compare);
+}
+
+static struct instruction * cse_one_instruction(struct instruction *insn, struct instruction *def)
+{
+	convert_instruction_target(insn, def->target);
+
+	kill_instruction(insn);
+	repeat_phase |= REPEAT_CSE;
+	return def;
+}
+
+/*
+ * Does "bb1" dominate "bb2"?
+ */
+static int bb_dominates(struct entrypoint *ep, struct basic_block *bb1, struct basic_block *bb2, unsigned long generation)
+{
+	struct basic_block *parent;
+
+	/* Nothing dominates the entrypoint.. */
+	if (bb2 == ep->entry->bb)
+		return 0;
+	FOR_EACH_PTR(bb2->parents, parent) {
+		if (parent == bb1)
+			continue;
+		if (parent->generation == generation)
+			continue;
+		parent->generation = generation;
+		if (!bb_dominates(ep, bb1, parent, generation))
+			return 0;
+	} END_FOR_EACH_PTR(parent);
+	return 1;
+}
+
+static struct basic_block *trivial_common_parent(struct basic_block *bb1, struct basic_block *bb2)
+{
+	struct basic_block *parent;
+
+	if (bb_list_size(bb1->parents) != 1)
+		return NULL;
+	parent = first_basic_block(bb1->parents);
+	if (bb_list_size(bb2->parents) != 1)
+		return NULL;
+	if (first_basic_block(bb2->parents) != parent)
+		return NULL;
+	return parent;
+}
+
+static inline void remove_instruction(struct instruction_list **list, struct instruction *insn, int count)
+{
+	delete_ptr_list_entry((struct ptr_list **)list, insn, count);
+}
+
+static void add_instruction_to_end(struct instruction *insn, struct basic_block *bb)
+{
+	struct instruction *br = delete_last_instruction(&bb->insns);
+	insn->bb = bb;
+	add_instruction(&bb->insns, insn);
+	add_instruction(&bb->insns, br);
+}
+
+static struct instruction * try_to_cse(struct entrypoint *ep, struct instruction *i1, struct instruction *i2)
+{
+	struct basic_block *b1, *b2, *common;
+
+	/*
+	 * OK, i1 and i2 are the same instruction, modulo "target".
+	 * We should now see if we can combine them.
+	 */
+	b1 = i1->bb;
+	b2 = i2->bb;
+
+	/*
+	 * Currently we only handle the uninteresting degenerate case where
+	 * the CSE is inside one basic-block.
+	 */
+	if (b1 == b2) {
+		struct instruction *insn;
+		FOR_EACH_PTR(b1->insns, insn) {
+			if (insn == i1)
+				return cse_one_instruction(i2, i1);
+			if (insn == i2)
+				return cse_one_instruction(i1, i2);
+		} END_FOR_EACH_PTR(insn);
+		warning(b1->pos, "Whaa? unable to find CSE instructions");
+		return i1;
+	}
+	if (bb_dominates(ep, b1, b2, ++bb_generation))
+		return cse_one_instruction(i2, i1);
+
+	if (bb_dominates(ep, b2, b1, ++bb_generation))
+		return cse_one_instruction(i1, i2);
+
+	/* No direct dominance - but we could try to find a common ancestor.. */
+	common = trivial_common_parent(b1, b2);
+	if (common) {
+		i1 = cse_one_instruction(i2, i1);
+		remove_instruction(&b1->insns, i1, 1);
+		add_instruction_to_end(i1, common);
+	}
+
+	return i1;
+}
+
+void cleanup_and_cse(struct entrypoint *ep)
+{
+	int i;
+
+	simplify_memops(ep);
+repeat:
+	repeat_phase = 0;
+	clean_up_insns(ep);
+	if (repeat_phase & REPEAT_CFG_CLEANUP)
+		kill_unreachable_bbs(ep);
+	for (i = 0; i < INSN_HASH_SIZE; i++) {
+		struct instruction_list **list = insn_hash_table + i;
+		if (*list) {
+			if (instruction_list_size(*list) > 1) {
+				struct instruction *insn, *last;
+
+				sort_instruction_list(list);
+
+				last = NULL;
+				FOR_EACH_PTR(*list, insn) {
+					if (!insn->bb)
+						continue;
+					if (last) {
+						if (!insn_compare(last, insn))
+							insn = try_to_cse(ep, last, insn);
+					}
+					last = insn;
+				} END_FOR_EACH_PTR(insn);
+			}
+			free_ptr_list((struct ptr_list **)list);
+		}
+	}
+
+	if (repeat_phase & REPEAT_SYMBOL_CLEANUP)
+		simplify_memops(ep);
+
+	if (repeat_phase & REPEAT_CSE)
+		goto repeat;
+}
diff --git a/usr/src/tools/smatch/src/ctags.c b/usr/src/tools/smatch/src/ctags.c
new file mode 100644
index 0000000000..9ec6b3c37e
--- /dev/null
+++ b/usr/src/tools/smatch/src/ctags.c
@@ -0,0 +1,227 @@
+/*
+ * Sparse Ctags
+ *
+ * Ctags generates tags from preprocessing results.
+ *
+ * Copyright (C) 2006 Christopher Li
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "parse.h"
+#include "scope.h"
+
+static struct symbol_list *taglist = NULL;
+
+static void examine_symbol(struct symbol *sym);
+
+#define MAX(_x,_y) ((_x) > (_y) ? (_x) : (_y))
+
+static int cmp_sym(const void *m, const void *n)
+{
+	const struct ident *a = ((const struct symbol *)m)->ident;
+	const struct ident *b = ((const struct symbol *)n)->ident;
+	int ret = strncmp(a->name, b->name, MAX(a->len, b->len));
+	if (!ret) {
+		const struct position a_pos = ((const struct symbol *)m)->pos;
+		const struct position b_pos = ((const struct symbol *)n)->pos;
+
+		ret = strcmp(stream_name(a_pos.stream),
+		             stream_name(b_pos.stream));
+		if (!ret)
+			return a_pos.line < b_pos.line;
+	}
+	return ret;
+}
+
+static void show_tag_header(FILE *fp)
+{
+	fprintf(fp, "!_TAG_FILE_FORMAT\t2\t/extended format; --format=1 will not append ;\" to lines/\n");
+	fprintf(fp, "!_TAG_FILE_SORTED\t0\t/0=unsorted, 1=sorted, 2=foldcase/\n");
+	fprintf(fp, "!_TAG_PROGRAM_AUTHOR\tChristopher Li\t/sparse@chrisli.org/\n");
+	fprintf(fp, "!_TAG_PROGRAM_NAME\tSparse Ctags\t//\n");
+	fprintf(fp, "!_TAG_PROGRAM_URL\thttp://www.kernel.org/pub/software/devel/sparse/\t/official site/\n");
+	fprintf(fp, "!_TAG_PROGRAM_VERSION\t0.01\t//\n");
+}
+
+static inline void show_symbol_tag(FILE *fp, struct symbol *sym)
+{
+	fprintf(fp, "%s\t%s\t%d;\"\t%c\tfile:\n", show_ident(sym->ident),
+	       stream_name(sym->pos.stream), sym->pos.line, (int)sym->kind);
+}
+
+static void show_tags(struct symbol_list *list)
+{
+	struct symbol *sym;
+	struct ident *ident = NULL;
+	struct position pos = {};
+	static const char *filename;
+	FILE *fp;
+
+	if (!list)
+		return;
+
+	fp = fopen("tags", "w");
+	if (!fp) {
+		perror("open tags file");
+		return;
+	}
+	show_tag_header(fp);
+	FOR_EACH_PTR(list, sym) {
+		if (ident == sym->ident && pos.line == sym->pos.line &&
+		    !strcmp(filename, stream_name(sym->pos.stream)))
+			continue;
+
+		show_symbol_tag(fp, sym);
+		ident = sym->ident;
+		pos = sym->pos;
+		filename = stream_name(sym->pos.stream);
+	} END_FOR_EACH_PTR(sym);
+	fclose(fp);
+}
+
+static inline void add_tag(struct symbol *sym)
+{
+	if (sym->ident && !sym->visited) {
+		sym->visited = 1;
+		add_symbol(&taglist, sym);
+	}
+}
+
+static inline void examine_members(struct symbol_list *list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		sym->kind = 'm';
+		examine_symbol(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+static void examine_symbol(struct symbol *sym)
+{
+	struct symbol *base = sym;
+
+	if (!sym || sym->visited)
+		return;
+	if (sym->ident && sym->ident->reserved)
+		return;
+	if (sym->type == SYM_KEYWORD || sym->type == SYM_PREPROCESSOR)
+		return;
+
+	add_tag(sym);
+	base = sym->ctype.base_type;
+
+	switch (sym->type) {
+	case SYM_NODE:
+		if (base->type == SYM_FN)
+			sym->kind = 'f';
+		examine_symbol(base);
+		break;
+	case SYM_STRUCT:
+		sym->kind = 's';
+		examine_members(sym->symbol_list);
+		break;
+	case SYM_UNION:
+		sym->kind = 'u';
+		examine_members(sym->symbol_list);
+		break;
+	case SYM_ENUM:
+		sym->kind = 'e';
+	case SYM_PTR:
+	case SYM_TYPEOF:
+	case SYM_BITFIELD:
+	case SYM_FN:
+	case SYM_ARRAY:
+		examine_symbol(sym->ctype.base_type);
+		break;
+	case SYM_BASETYPE:
+		break;
+
+	default:
+		die("unknown symbol %s namespace:%d type:%d\n", show_ident(sym->ident),
+		    sym->namespace, sym->type);
+	}
+	if (!sym->kind)
+		sym->kind = 'v';
+	return;
+}
+
+static void examine_namespace(struct symbol *sym)
+{
+	if (sym->visited)
+		return;
+	if (sym->ident && sym->ident->reserved)
+		return;
+
+	switch(sym->namespace) {
+	case NS_KEYWORD:
+	case NS_PREPROCESSOR:
+		return;
+	case NS_LABEL:
+		sym->kind = 'l';
+		break;
+	case NS_MACRO:
+	case NS_UNDEF:
+		sym->kind = 'd';
+		break;
+	case NS_TYPEDEF:
+		sym->kind = 't';
+	case NS_SYMBOL:
+	case NS_STRUCT:
+		examine_symbol(sym);
+		break;
+	default:
+		die("unknown namespace %d symbol:%s type:%d\n", sym->namespace,
+		    show_ident(sym->ident), sym->type);
+	}
+	add_tag(sym);
+}
+
+static inline void examine_symbol_list(struct symbol_list *list)
+{
+	struct symbol *sym;
+
+	if (!list)
+		return;
+	FOR_EACH_PTR(list, sym) {
+		examine_namespace(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	char *file;
+
+	examine_symbol_list(sparse_initialize(argc, argv, &filelist));
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		sparse(file);
+		examine_symbol_list(file_scope->symbols);
+	} END_FOR_EACH_PTR_NOTAG(file);
+	examine_symbol_list(global_scope->symbols);
+	sort_list((struct ptr_list **)&taglist, cmp_sym);
+	show_tags(taglist);
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/cwchash/Makefile b/usr/src/tools/smatch/src/cwchash/Makefile
new file mode 100644
index 0000000000..5a1f65cd35
--- /dev/null
+++ b/usr/src/tools/smatch/src/cwchash/Makefile
@@ -0,0 +1,26 @@
+
+tester: hashtable.o tester.o hashtable_itr.o
+	gcc -g -Wall -O -o tester hashtable.o hashtable_itr.o tester.o -lm
+
+all: tester old_tester
+
+tester.o:	tester.c
+	gcc -g -Wall -O -c tester.c -o tester.o
+
+old_tester: hashtable_powers.o tester.o hashtable_itr.o
+	gcc -g -Wall -O -o old_tester hashtable_powers.o hashtable_itr.o tester.o
+
+hashtable_powers.o:	hashtable_powers.c
+	gcc -g -Wall -O -c hashtable_powers.c -o hashtable_powers.o
+
+hashtable.o:	hashtable.c
+	gcc -g -Wall -O -c hashtable.c -o hashtable.o
+
+hashtable_itr.o: hashtable_itr.c
+	gcc -g -Wall -O -c hashtable_itr.c -o hashtable_itr.o
+
+tidy:
+	rm *.o
+
+clean: tidy
+	rm -f tester old_tester
diff --git a/usr/src/tools/smatch/src/cwchash/hashtable.c b/usr/src/tools/smatch/src/cwchash/hashtable.c
new file mode 100644
index 0000000000..763357edce
--- /dev/null
+++ b/usr/src/tools/smatch/src/cwchash/hashtable.c
@@ -0,0 +1,274 @@
+/* Copyright (C) 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#include "hashtable.h"
+#include "hashtable_private.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+/*
+Credit for primes table: Aaron Krowne
+ http://br.endernet.org/~akrowne/
+ http://planetmath.org/encyclopedia/GoodHashTablePrimes.html
+*/
+static const unsigned int primes[] = {
+53, 97, 193, 389,
+769, 1543, 3079, 6151,
+12289, 24593, 49157, 98317,
+196613, 393241, 786433, 1572869,
+3145739, 6291469, 12582917, 25165843,
+50331653, 100663319, 201326611, 402653189,
+805306457, 1610612741
+};
+const unsigned int prime_table_length = sizeof(primes)/sizeof(primes[0]);
+const float max_load_factor = 0.65;
+
+/*****************************************************************************/
+struct hashtable *
+create_hashtable(unsigned int minsize,
+                 unsigned int (*hashf) (void*),
+                 int (*eqf) (void*,void*))
+{
+    struct hashtable *h;
+    unsigned int pindex, size = primes[0];
+    /* Check requested hashtable isn't too large */
+    if (minsize > (1u << 30)) return NULL;
+    /* Enforce size as prime */
+    for (pindex=0; pindex < prime_table_length; pindex++) {
+        if (primes[pindex] > minsize) { size = primes[pindex]; break; }
+    }
+    h = (struct hashtable *)malloc(sizeof(struct hashtable));
+    if (NULL == h) return NULL; /*oom*/
+    h->table = (struct entry **)malloc(sizeof(struct entry*) * size);
+    if (NULL == h->table) { free(h); return NULL; } /*oom*/
+    memset(h->table, 0, size * sizeof(struct entry *));
+    h->tablelength  = size;
+    h->primeindex   = pindex;
+    h->entrycount   = 0;
+    h->hashfn       = hashf;
+    h->eqfn         = eqf;
+    h->loadlimit    = (unsigned int) ceil(size * max_load_factor);
+    return h;
+}
+
+/*****************************************************************************/
+unsigned int
+hash(struct hashtable *h, void *k)
+{
+    /* Aim to protect against poor hash functions by adding logic here
+     * - logic taken from java 1.4 hashtable source */
+    unsigned int i = h->hashfn(k);
+    i += ~(i << 9);
+    i ^=  ((i >> 14) | (i << 18)); /* >>> */
+    i +=  (i << 4);
+    i ^=  ((i >> 10) | (i << 22)); /* >>> */
+    return i;
+}
+
+/*****************************************************************************/
+static int
+hashtable_expand(struct hashtable *h)
+{
+    /* Double the size of the table to accomodate more entries */
+    struct entry **newtable;
+    struct entry *e;
+    struct entry **pE;
+    unsigned int newsize, i, index;
+    /* Check we're not hitting max capacity */
+    if (h->primeindex == (prime_table_length - 1)) return 0;
+    newsize = primes[++(h->primeindex)];
+
+    newtable = (struct entry **)malloc(sizeof(struct entry*) * newsize);
+    if (NULL != newtable)
+    {
+        memset(newtable, 0, newsize * sizeof(struct entry *));
+        /* This algorithm is not 'stable'. ie. it reverses the list
+         * when it transfers entries between the tables */
+        for (i = 0; i < h->tablelength; i++) {
+            while (NULL != (e = h->table[i])) {
+                h->table[i] = e->next;
+                index = indexFor(newsize,e->h);
+                e->next = newtable[index];
+                newtable[index] = e;
+            }
+        }
+        free(h->table);
+        h->table = newtable;
+    }
+    /* Plan B: realloc instead */
+    else 
+    {
+        newtable = (struct entry **)
+                   realloc(h->table, newsize * sizeof(struct entry *));
+        if (NULL == newtable) { (h->primeindex)--; return 0; }
+        h->table = newtable;
+        memset(newtable[h->tablelength], 0, newsize - h->tablelength);
+        for (i = 0; i < h->tablelength; i++) {
+            for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) {
+                index = indexFor(newsize,e->h);
+                if (index == i)
+                {
+                    pE = &(e->next);
+                }
+                else
+                {
+                    *pE = e->next;
+                    e->next = newtable[index];
+                    newtable[index] = e;
+                }
+            }
+        }
+    }
+    h->tablelength = newsize;
+    h->loadlimit   = (unsigned int) ceil(newsize * max_load_factor);
+    return -1;
+}
+
+/*****************************************************************************/
+unsigned int
+hashtable_count(struct hashtable *h)
+{
+    return h->entrycount;
+}
+
+/*****************************************************************************/
+int
+hashtable_insert(struct hashtable *h, void *k, void *v)
+{
+    /* This method allows duplicate keys - but they shouldn't be used */
+    unsigned int index;
+    struct entry *e;
+    if (++(h->entrycount) > h->loadlimit)
+    {
+        /* Ignore the return value. If expand fails, we should
+         * still try cramming just this value into the existing table
+         * -- we may not have memory for a larger table, but one more
+         * element may be ok. Next time we insert, we'll try expanding again.*/
+        hashtable_expand(h);
+    }
+    e = (struct entry *)malloc(sizeof(struct entry));
+    if (NULL == e) { --(h->entrycount); return 0; } /*oom*/
+    e->h = hash(h,k);
+    index = indexFor(h->tablelength,e->h);
+    e->k = k;
+    e->v = v;
+    e->next = h->table[index];
+    h->table[index] = e;
+    return -1;
+}
+
+/*****************************************************************************/
+void * /* returns value associated with key */
+hashtable_search(struct hashtable *h, void *k)
+{
+    struct entry *e;
+    unsigned int hashvalue, index;
+    hashvalue = hash(h,k);
+    index = indexFor(h->tablelength,hashvalue);
+    e = h->table[index];
+    while (NULL != e)
+    {
+        /* Check hash value to short circuit heavier comparison */
+        if ((hashvalue == e->h) && (h->eqfn(k, e->k))) return e->v;
+        e = e->next;
+    }
+    return NULL;
+}
+
+/*****************************************************************************/
+void * /* returns value associated with key */
+hashtable_remove(struct hashtable *h, void *k)
+{
+    /* TODO: consider compacting the table when the load factor drops enough,
+     *       or provide a 'compact' method. */
+
+    struct entry *e;
+    struct entry **pE;
+    void *v;
+    unsigned int hashvalue, index;
+
+    hashvalue = hash(h,k);
+    index = indexFor(h->tablelength,hash(h,k));
+    pE = &(h->table[index]);
+    e = *pE;
+    while (NULL != e)
+    {
+        /* Check hash value to short circuit heavier comparison */
+        if ((hashvalue == e->h) && (h->eqfn(k, e->k)))
+        {
+            *pE = e->next;
+            h->entrycount--;
+            v = e->v;
+            freekey(e->k);
+            free(e);
+            return v;
+        }
+        pE = &(e->next);
+        e = e->next;
+    }
+    return NULL;
+}
+
+/*****************************************************************************/
+/* destroy */
+void
+hashtable_destroy(struct hashtable *h, int free_values)
+{
+    unsigned int i;
+    struct entry *e, *f;
+    struct entry **table = h->table;
+    if (free_values)
+    {
+        for (i = 0; i < h->tablelength; i++)
+        {
+            e = table[i];
+            while (NULL != e)
+            { f = e; e = e->next; freekey(f->k); free(f->v); free(f); }
+        }
+    }
+    else
+    {
+        for (i = 0; i < h->tablelength; i++)
+        {
+            e = table[i];
+            while (NULL != e)
+            { f = e; e = e->next; freekey(f->k); free(f); }
+        }
+    }
+    free(h->table);
+    free(h);
+}
+
+/*
+ * Copyright (c) 2002, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * 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.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER
+ * 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.
+*/
diff --git a/usr/src/tools/smatch/src/cwchash/hashtable.h b/usr/src/tools/smatch/src/cwchash/hashtable.h
new file mode 100644
index 0000000000..b90781abd4
--- /dev/null
+++ b/usr/src/tools/smatch/src/cwchash/hashtable.h
@@ -0,0 +1,199 @@
+/* Copyright (C) 2002 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#ifndef __HASHTABLE_CWC22_H__
+#define __HASHTABLE_CWC22_H__
+
+struct hashtable;
+
+/* Example of use:
+ *
+ *      struct hashtable  *h;
+ *      struct some_key   *k;
+ *      struct some_value *v;
+ *
+ *      static unsigned int         hash_from_key_fn( void *k );
+ *      static int                  keys_equal_fn ( void *key1, void *key2 );
+ *
+ *      h = create_hashtable(16, hash_from_key_fn, keys_equal_fn);
+ *      k = (struct some_key *)     malloc(sizeof(struct some_key));
+ *      v = (struct some_value *)   malloc(sizeof(struct some_value));
+ *
+ *      (initialise k and v to suitable values)
+ * 
+ *      if (! hashtable_insert(h,k,v) )
+ *      {     exit(-1);               }
+ *
+ *      if (NULL == (found = hashtable_search(h,k) ))
+ *      {    printf("not found!");                  }
+ *
+ *      if (NULL == (found = hashtable_remove(h,k) ))
+ *      {    printf("Not found\n");                 }
+ *
+ */
+
+/* Macros may be used to define type-safe(r) hashtable access functions, with
+ * methods specialized to take known key and value types as parameters.
+ * 
+ * Example:
+ *
+ * Insert this at the start of your file:
+ *
+ * DEFINE_HASHTABLE_INSERT(insert_some, struct some_key, struct some_value);
+ * DEFINE_HASHTABLE_SEARCH(search_some, struct some_key, struct some_value);
+ * DEFINE_HASHTABLE_REMOVE(remove_some, struct some_key, struct some_value);
+ *
+ * This defines the functions 'insert_some', 'search_some' and 'remove_some'.
+ * These operate just like hashtable_insert etc., with the same parameters,
+ * but their function signatures have 'struct some_key *' rather than
+ * 'void *', and hence can generate compile time errors if your program is
+ * supplying incorrect data as a key (and similarly for value).
+ *
+ * Note that the hash and key equality functions passed to create_hashtable
+ * still take 'void *' parameters instead of 'some key *'. This shouldn't be
+ * a difficult issue as they're only defined and passed once, and the other
+ * functions will ensure that only valid keys are supplied to them.
+ *
+ * The cost for this checking is increased code size and runtime overhead
+ * - if performance is important, it may be worth switching back to the
+ * unsafe methods once your program has been debugged with the safe methods.
+ * This just requires switching to some simple alternative defines - eg:
+ * #define insert_some hashtable_insert
+ *
+ */
+
+/*****************************************************************************
+ * create_hashtable
+   
+ * @name                    create_hashtable
+ * @param   minsize         minimum initial size of hashtable
+ * @param   hashfunction    function for hashing keys
+ * @param   key_eq_fn       function for determining key equality
+ * @return                  newly created hashtable or NULL on failure
+ */
+
+struct hashtable *
+create_hashtable(unsigned int minsize,
+                 unsigned int (*hashfunction) (void*),
+                 int (*key_eq_fn) (void*,void*));
+
+/*****************************************************************************
+ * hashtable_insert
+   
+ * @name        hashtable_insert
+ * @param   h   the hashtable to insert into
+ * @param   k   the key - hashtable claims ownership and will free on removal
+ * @param   v   the value - does not claim ownership
+ * @return      non-zero for successful insertion
+ *
+ * This function will cause the table to expand if the insertion would take
+ * the ratio of entries to table size over the maximum load factor.
+ *
+ * This function does not check for repeated insertions with a duplicate key.
+ * The value returned when using a duplicate key is undefined -- when
+ * the hashtable changes size, the order of retrieval of duplicate key
+ * entries is reversed.
+ * If in doubt, remove before insert.
+ */
+
+int 
+hashtable_insert(struct hashtable *h, void *k, void *v);
+
+#define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \
+int fnname (struct hashtable *h, keytype *k, valuetype *v) \
+{ \
+    return hashtable_insert(h,k,v); \
+}
+
+/*****************************************************************************
+ * hashtable_search
+   
+ * @name        hashtable_search
+ * @param   h   the hashtable to search
+ * @param   k   the key to search for  - does not claim ownership
+ * @return      the value associated with the key, or NULL if none found
+ */
+
+void *
+hashtable_search(struct hashtable *h, void *k);
+
+#define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \
+valuetype * fnname (struct hashtable *h, keytype *k) \
+{ \
+    return (valuetype *) (hashtable_search(h,k)); \
+}
+
+/*****************************************************************************
+ * hashtable_remove
+   
+ * @name        hashtable_remove
+ * @param   h   the hashtable to remove the item from
+ * @param   k   the key to search for  - does not claim ownership
+ * @return      the value associated with the key, or NULL if none found
+ */
+
+void * /* returns value */
+hashtable_remove(struct hashtable *h, void *k);
+
+#define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \
+valuetype * fnname (struct hashtable *h, keytype *k) \
+{ \
+    return (valuetype *) (hashtable_remove(h,k)); \
+}
+
+
+/*****************************************************************************
+ * hashtable_count
+   
+ * @name        hashtable_count
+ * @param   h   the hashtable
+ * @return      the number of items stored in the hashtable
+ */
+unsigned int
+hashtable_count(struct hashtable *h);
+
+
+/*****************************************************************************
+ * hashtable_destroy
+   
+ * @name        hashtable_destroy
+ * @param   h   the hashtable
+ * @param       free_values     whether to call 'free' on the remaining values
+ */
+
+void
+hashtable_destroy(struct hashtable *h, int free_values);
+
+#endif /* __HASHTABLE_CWC22_H__ */
+
+/*
+ * Copyright (c) 2002, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * 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.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER
+ * 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.
+*/
diff --git a/usr/src/tools/smatch/src/cwchash/hashtable_itr.c b/usr/src/tools/smatch/src/cwchash/hashtable_itr.c
new file mode 100644
index 0000000000..5dced841f3
--- /dev/null
+++ b/usr/src/tools/smatch/src/cwchash/hashtable_itr.c
@@ -0,0 +1,188 @@
+/* Copyright (C) 2002, 2004 Christopher Clark  <firstname.lastname@cl.cam.ac.uk> */
+
+#include "hashtable.h"
+#include "hashtable_private.h"
+#include "hashtable_itr.h"
+#include <stdlib.h> /* defines NULL */
+
+/*****************************************************************************/
+/* hashtable_iterator    - iterator constructor */
+
+struct hashtable_itr *
+hashtable_iterator(struct hashtable *h)
+{
+    unsigned int i, tablelength;
+    struct hashtable_itr *itr = (struct hashtable_itr *)
+        malloc(sizeof(struct hashtable_itr));
+    if (NULL == itr) return NULL;
+    itr->h = h;
+    itr->e = NULL;
+    itr->parent = NULL;
+    tablelength = h->tablelength;
+    itr->index = tablelength;
+    if (0 == h->entrycount) return itr;
+
+    for (i = 0; i < tablelength; i++)
+    {
+        if (NULL != h->table[i])
+        {
+            itr->e = h->table[i];
+            itr->index = i;
+            break;
+        }
+    }
+    return itr;
+}
+
+/*****************************************************************************/
+/* key      - return the key of the (key,value) pair at the current position */
+/* value    - return the value of the (key,value) pair at the current position */
+
+void *
+hashtable_iterator_key(struct hashtable_itr *i)
+{ return i->e->k; }
+
+void *
+hashtable_iterator_value(struct hashtable_itr *i)
+{ return i->e->v; }
+
+/*****************************************************************************/
+/* advance - advance the iterator to the next element
+ *           returns zero if advanced to end of table */
+
+int
+hashtable_iterator_advance(struct hashtable_itr *itr)
+{
+    unsigned int j,tablelength;
+    struct entry **table;
+    struct entry *next;
+    if (NULL == itr->e) return 0; /* stupidity check */
+
+    next = itr->e->next;
+    if (NULL != next)
+    {
+        itr->parent = itr->e;
+        itr->e = next;
+        return -1;
+    }
+    tablelength = itr->h->tablelength;
+    itr->parent = NULL;
+    if (tablelength <= (j = ++(itr->index)))
+    {
+        itr->e = NULL;
+        return 0;
+    }
+    table = itr->h->table;
+    while (NULL == (next = table[j]))
+    {
+        if (++j >= tablelength)
+        {
+            itr->index = tablelength;
+            itr->e = NULL;
+            return 0;
+        }
+    }
+    itr->index = j;
+    itr->e = next;
+    return -1;
+}
+
+/*****************************************************************************/
+/* remove - remove the entry at the current iterator position
+ *          and advance the iterator, if there is a successive
+ *          element.
+ *          If you want the value, read it before you remove:
+ *          beware memory leaks if you don't.
+ *          Returns zero if end of iteration. */
+
+int
+hashtable_iterator_remove(struct hashtable_itr *itr)
+{
+    struct entry *remember_e, *remember_parent;
+    int ret;
+
+    /* Do the removal */
+    if (NULL == (itr->parent))
+    {
+        /* element is head of a chain */
+        itr->h->table[itr->index] = itr->e->next;
+    } else {
+        /* element is mid-chain */
+        itr->parent->next = itr->e->next;
+    }
+    /* itr->e is now outside the hashtable */
+    remember_e = itr->e;
+    itr->h->entrycount--;
+    freekey(remember_e->k);
+
+    /* Advance the iterator, correcting the parent */
+    remember_parent = itr->parent;
+    ret = hashtable_iterator_advance(itr);
+    if (itr->parent == remember_e) { itr->parent = remember_parent; }
+    free(remember_e);
+    return ret;
+}
+
+/*****************************************************************************/
+int /* returns zero if not found */
+hashtable_iterator_search(struct hashtable_itr *itr,
+                          struct hashtable *h, void *k)
+{
+    struct entry *e, *parent;
+    unsigned int hashvalue, index;
+
+    hashvalue = hash(h,k);
+    index = indexFor(h->tablelength,hashvalue);
+
+    e = h->table[index];
+    parent = NULL;
+    while (NULL != e)
+    {
+        /* Check hash value to short circuit heavier comparison */
+        if ((hashvalue == e->h) && (h->eqfn(k, e->k)))
+        {
+            itr->index = index;
+            itr->e = e;
+            itr->parent = parent;
+            itr->h = h;
+            return -1;
+        }
+        parent = e;
+        e = e->next;
+    }
+    return 0;
+}
+
+
+/*
+ * Copyright (c) 2002, 2004, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * 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.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER
+ * 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.
+*/
diff --git a/usr/src/tools/smatch/src/cwchash/hashtable_itr.h b/usr/src/tools/smatch/src/cwchash/hashtable_itr.h
new file mode 100644
index 0000000000..eea699a72c
--- /dev/null
+++ b/usr/src/tools/smatch/src/cwchash/hashtable_itr.h
@@ -0,0 +1,112 @@
+/* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#ifndef __HASHTABLE_ITR_CWC22__
+#define __HASHTABLE_ITR_CWC22__
+#include "hashtable.h"
+#include "hashtable_private.h" /* needed to enable inlining */
+
+/*****************************************************************************/
+/* This struct is only concrete here to allow the inlining of two of the
+ * accessor functions. */
+struct hashtable_itr
+{
+    struct hashtable *h;
+    struct entry *e;
+    struct entry *parent;
+    unsigned int index;
+};
+
+
+/*****************************************************************************/
+/* hashtable_iterator
+ */
+
+struct hashtable_itr *
+hashtable_iterator(struct hashtable *h);
+
+/*****************************************************************************/
+/* hashtable_iterator_key
+ * - return the value of the (key,value) pair at the current position */
+
+extern inline void *
+hashtable_iterator_key(struct hashtable_itr *i)
+{
+    return i->e->k;
+}
+
+/*****************************************************************************/
+/* value - return the value of the (key,value) pair at the current position */
+
+extern inline void *
+hashtable_iterator_value(struct hashtable_itr *i)
+{
+    return i->e->v;
+}
+
+/*****************************************************************************/
+/* advance - advance the iterator to the next element
+ *           returns zero if advanced to end of table */
+
+int
+hashtable_iterator_advance(struct hashtable_itr *itr);
+
+/*****************************************************************************/
+/* remove - remove current element and advance the iterator to the next element
+ *          NB: if you need the value to free it, read it before
+ *          removing. ie: beware memory leaks!
+ *          returns zero if advanced to end of table */
+
+int
+hashtable_iterator_remove(struct hashtable_itr *itr);
+
+/*****************************************************************************/
+/* search - overwrite the supplied iterator, to point to the entry
+ *          matching the supplied key.
+            h points to the hashtable to be searched.
+ *          returns zero if not found. */
+int
+hashtable_iterator_search(struct hashtable_itr *itr,
+                          struct hashtable *h, void *k);
+
+#define DEFINE_HASHTABLE_ITERATOR_SEARCH(fnname, keytype) \
+int fnname (struct hashtable_itr *i, struct hashtable *h, keytype *k) \
+{ \
+    return (hashtable_iterator_search(i,h,k)); \
+}
+
+
+
+#endif /* __HASHTABLE_ITR_CWC22__*/
+
+/*
+ * Copyright (c) 2002, 2004, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * 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.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER
+ * 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.
+*/
diff --git a/usr/src/tools/smatch/src/cwchash/hashtable_private.h b/usr/src/tools/smatch/src/cwchash/hashtable_private.h
new file mode 100644
index 0000000000..3e95f60057
--- /dev/null
+++ b/usr/src/tools/smatch/src/cwchash/hashtable_private.h
@@ -0,0 +1,85 @@
+/* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#ifndef __HASHTABLE_PRIVATE_CWC22_H__
+#define __HASHTABLE_PRIVATE_CWC22_H__
+
+#include "hashtable.h"
+
+/*****************************************************************************/
+struct entry
+{
+    void *k, *v;
+    unsigned int h;
+    struct entry *next;
+};
+
+struct hashtable {
+    unsigned int tablelength;
+    struct entry **table;
+    unsigned int entrycount;
+    unsigned int loadlimit;
+    unsigned int primeindex;
+    unsigned int (*hashfn) (void *k);
+    int (*eqfn) (void *k1, void *k2);
+};
+
+/*****************************************************************************/
+unsigned int
+hash(struct hashtable *h, void *k);
+
+/*****************************************************************************/
+/* indexFor */
+static inline unsigned int
+indexFor(unsigned int tablelength, unsigned int hashvalue) {
+    return (hashvalue % tablelength);
+};
+
+/* Only works if tablelength == 2^N */
+/*static inline unsigned int
+indexFor(unsigned int tablelength, unsigned int hashvalue)
+{
+    return (hashvalue & (tablelength - 1u));
+}
+*/
+
+/*****************************************************************************/
+#define freekey(X) free(X)
+/*define freekey(X) ; */
+
+
+/*****************************************************************************/
+
+#endif /* __HASHTABLE_PRIVATE_CWC22_H__*/
+
+/*
+ * Copyright (c) 2002, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * 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.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER
+ * 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.
+*/
diff --git a/usr/src/tools/smatch/src/cwchash/hashtable_utility.c b/usr/src/tools/smatch/src/cwchash/hashtable_utility.c
new file mode 100644
index 0000000000..c317670977
--- /dev/null
+++ b/usr/src/tools/smatch/src/cwchash/hashtable_utility.c
@@ -0,0 +1,71 @@
+/* Copyright (C) 2002 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#include "hashtable.h"
+#include "hashtable_private.h"
+#include "hashtable_utility.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/*****************************************************************************/
+/* hashtable_change
+ *
+ * function to change the value associated with a key, where there already
+ * exists a value bound to the key in the hashtable.
+ * Source due to Holger Schemel.
+ * 
+ *  */
+int
+hashtable_change(struct hashtable *h, void *k, void *v)
+{
+    struct entry *e;
+    unsigned int hashvalue, index;
+    hashvalue = hash(h,k);
+    index = indexFor(h->tablelength,hashvalue);
+    e = h->table[index];
+    while (NULL != e)
+    {
+        /* Check hash value to short circuit heavier comparison */
+        if ((hashvalue == e->h) && (h->eqfn(k, e->k)))
+        {
+            free(e->v);
+            e->v = v;
+            return -1;
+        }
+        e = e->next;
+    }
+    return 0;
+}
+
+/*
+ * Copyright (c) 2002, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * 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.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER
+ * 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.
+*/
diff --git a/usr/src/tools/smatch/src/cwchash/hashtable_utility.h b/usr/src/tools/smatch/src/cwchash/hashtable_utility.h
new file mode 100644
index 0000000000..56a0ffd1aa
--- /dev/null
+++ b/usr/src/tools/smatch/src/cwchash/hashtable_utility.h
@@ -0,0 +1,55 @@
+/* Copyright (C) 2002 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#ifndef __HASHTABLE_CWC22_UTILITY_H__
+#define __HASHTABLE_CWC22_UTILITY_H__
+
+/*****************************************************************************
+ * hashtable_change
+ *
+ * function to change the value associated with a key, where there already
+ * exists a value bound to the key in the hashtable.
+ * Source due to Holger Schemel.
+ *
+ * @name        hashtable_change
+ * @param   h   the hashtable
+ * @param       key
+ * @param       value
+ *
+ */
+int
+hashtable_change(struct hashtable *h, void *k, void *v);
+
+#endif /* __HASHTABLE_CWC22_H__ */
+
+/*
+ * Copyright (c) 2002, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * 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.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER
+ * 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.
+*/
diff --git a/usr/src/tools/smatch/src/cwchash/tester.c b/usr/src/tools/smatch/src/cwchash/tester.c
new file mode 100644
index 0000000000..4678ffa85e
--- /dev/null
+++ b/usr/src/tools/smatch/src/cwchash/tester.c
@@ -0,0 +1,270 @@
+/* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#include "hashtable.h"
+#include "hashtable_itr.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h> /* for memcmp */
+
+static const int ITEM_COUNT = 4000;
+
+typedef unsigned int uint32_t;
+typedef unsigned short uint16_t;
+
+/*****************************************************************************/
+struct key
+{
+    uint32_t one_ip; uint32_t two_ip; uint16_t one_port; uint16_t two_port;
+};
+
+struct value
+{
+    char *id;
+};
+
+DEFINE_HASHTABLE_INSERT(insert_some, struct key, struct value);
+DEFINE_HASHTABLE_SEARCH(search_some, struct key, struct value);
+DEFINE_HASHTABLE_REMOVE(remove_some, struct key, struct value);
+DEFINE_HASHTABLE_ITERATOR_SEARCH(search_itr_some, struct key);
+
+
+/*****************************************************************************/
+static unsigned int
+hashfromkey(void *ky)
+{
+    struct key *k = (struct key *)ky;
+    return (((k->one_ip << 17) | (k->one_ip >> 15)) ^ k->two_ip) +
+            (k->one_port * 17) + (k->two_port * 13 * 29);
+}
+
+static int
+equalkeys(void *k1, void *k2)
+{
+    return (0 == memcmp(k1,k2,sizeof(struct key)));
+}
+
+/*****************************************************************************/
+int
+main(int argc, char **argv)
+{
+    struct key *k, *kk;
+    struct value *v, *found;
+    struct hashtable *h;
+    struct hashtable_itr *itr;
+    int i;
+
+    h = create_hashtable(16, hashfromkey, equalkeys);
+    if (NULL == h) exit(-1); /*oom*/
+
+
+/*****************************************************************************/
+/* Insertion */
+    for (i = 0; i < ITEM_COUNT; i++)
+    {
+        k = (struct key *)malloc(sizeof(struct key));
+        if (NULL == k) {
+            printf("ran out of memory allocating a key\n");
+            return 1;
+        }
+        k->one_ip = 0xcfccee40 + i;
+        k->two_ip = 0xcf0cee67 - (5 * i);
+        k->one_port = 22 + (7 * i);
+        k->two_port = 5522 - (3 * i);
+        
+        v = (struct value *)malloc(sizeof(struct value));
+        v->id = "a value";
+        
+        if (!insert_some(h,k,v)) exit(-1); /*oom*/
+    }
+    printf("After insertion, hashtable contains %u items.\n",
+            hashtable_count(h));
+
+/*****************************************************************************/
+/* Hashtable search */
+    k = (struct key *)malloc(sizeof(struct key));
+    if (NULL == k) {
+        printf("ran out of memory allocating a key\n");
+        return 1;
+    }
+    
+    for (i = 0; i < ITEM_COUNT; i++)
+    {
+        k->one_ip = 0xcfccee40 + i;
+        k->two_ip = 0xcf0cee67 - (5 * i);
+        k->one_port = 22 + (7 * i);
+        k->two_port = 5522 - (3 * i);
+        
+        if (NULL == (found = search_some(h,k))) {
+            printf("BUG: key not found\n");
+        }
+    }
+
+/*****************************************************************************/
+/* Hashtable iteration */
+    /* Iterator constructor only returns a valid iterator if
+     * the hashtable is not empty */
+    itr = hashtable_iterator(h);
+    i = 0;
+    if (hashtable_count(h) > 0)
+    {
+        do {
+            kk = hashtable_iterator_key(itr);
+            v = hashtable_iterator_value(itr);
+            /* here (kk,v) are a valid (key, value) pair */
+            /* We could call 'hashtable_remove(h,kk)' - and this operation
+             * 'free's kk. However, the iterator is then broken.
+             * This is why hashtable_iterator_remove exists - see below.
+             */
+            i++;
+
+        } while (hashtable_iterator_advance(itr));
+    }
+    printf("Iterated through %u entries.\n", i);
+
+/*****************************************************************************/
+/* Hashtable iterator search */
+
+    /* Try the search some method */
+    for (i = 0; i < ITEM_COUNT; i++)
+    {
+        k->one_ip = 0xcfccee40 + i;
+        k->two_ip = 0xcf0cee67 - (5 * i);
+        k->one_port = 22 + (7 * i);
+        k->two_port = 5522 - (3 * i);
+        
+        if (0 == search_itr_some(itr,h,k)) {
+            printf("BUG: key not found searching with iterator");
+        }
+    }
+
+/*****************************************************************************/
+/* Hashtable removal */
+
+    for (i = 0; i < ITEM_COUNT; i++)
+    {
+        k->one_ip = 0xcfccee40 + i;
+        k->two_ip = 0xcf0cee67 - (5 * i);
+        k->one_port = 22 + (7 * i);
+        k->two_port = 5522 - (3 * i);
+        
+        if (NULL == (found = remove_some(h,k))) {
+            printf("BUG: key not found for removal\n");
+        }
+    }
+    printf("After removal, hashtable contains %u items.\n",
+            hashtable_count(h));
+
+/*****************************************************************************/
+/* Hashtable destroy and create */
+
+    hashtable_destroy(h, 1);
+    h = NULL;
+    free(k);
+
+    h = create_hashtable(160, hashfromkey, equalkeys);
+    if (NULL == h) {
+        printf("out of memory allocating second hashtable\n");
+        return 1;
+    }
+
+/*****************************************************************************/
+/* Hashtable insertion */
+
+    for (i = 0; i < ITEM_COUNT; i++)
+    {
+        k = (struct key *)malloc(sizeof(struct key));
+        k->one_ip = 0xcfccee40 + i;
+        k->two_ip = 0xcf0cee67 - (5 * i);
+        k->one_port = 22 + (7 * i);
+        k->two_port = 5522 - (3 * i);
+        
+        v = (struct value *)malloc(sizeof(struct value));
+        v->id = "a value";
+        
+        if (!insert_some(h,k,v))
+        {
+            printf("out of memory inserting into second hashtable\n");
+            return 1;
+        }
+    }
+    printf("After insertion, hashtable contains %u items.\n",
+            hashtable_count(h));
+
+/*****************************************************************************/
+/* Hashtable iterator search and iterator remove */
+
+    k = (struct key *)malloc(sizeof(struct key));
+    if (NULL == k) {
+        printf("ran out of memory allocating a key\n");
+        return 1;
+    }
+    
+    for (i = ITEM_COUNT - 1; i >= 0; i = i - 7)
+    {
+        k->one_ip = 0xcfccee40 + i;
+        k->two_ip = 0xcf0cee67 - (5 * i);
+        k->one_port = 22 + (7 * i);
+        k->two_port = 5522 - (3 * i);
+        
+        if (0 == search_itr_some(itr, h, k)) {
+            printf("BUG: key %u not found for search preremoval using iterator\n", i);
+            return 1;
+        }
+        if (0 == hashtable_iterator_remove(itr)) {
+            printf("BUG: key not found for removal using iterator\n");
+            return 1;
+        }
+    }
+    free(itr);
+
+/*****************************************************************************/
+/* Hashtable iterator remove and advance */
+
+    for (itr = hashtable_iterator(h);
+         hashtable_iterator_remove(itr) != 0; ) {
+        ;
+    }
+    free(itr);
+    printf("After removal, hashtable contains %u items.\n",
+            hashtable_count(h));
+
+/*****************************************************************************/
+/* Hashtable destroy */
+
+    hashtable_destroy(h, 1);
+    free(k);
+    return 0;
+}
+
+/*
+ * Copyright (c) 2002, 2004, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * 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.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER
+ * 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.
+*/
diff --git a/usr/src/tools/smatch/src/dissect.c b/usr/src/tools/smatch/src/dissect.c
new file mode 100644
index 0000000000..5f067eb4c5
--- /dev/null
+++ b/usr/src/tools/smatch/src/dissect.c
@@ -0,0 +1,613 @@
+/*
+ * sparse/dissect.c
+ *
+ * Started by Oleg Nesterov <oleg@redhat.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "dissect.h"
+
+#define	U_VOID	 0x00
+#define	U_SELF	((1 << U_SHIFT) - 1)
+#define	U_MASK	(U_R_VAL | U_W_VAL | U_R_AOF)
+
+#define	DO_LIST(l__, p__, expr__)		\
+	do {					\
+		typeof(l__->list[0]) p__;	\
+		FOR_EACH_PTR(l__, p__)		\
+			expr__;			\
+		END_FOR_EACH_PTR(p__);		\
+	} while (0)
+
+#define	DO_2_LIST(l1__,l2__, p1__,p2__, expr__)	\
+	do {					\
+		typeof(l1__->list[0]) p1__;	\
+		typeof(l2__->list[0]) p2__;	\
+		PREPARE_PTR_LIST(l1__, p1__);	\
+		FOR_EACH_PTR(l2__, p2__)	\
+			expr__;			\
+			NEXT_PTR_LIST(p1__);	\
+		END_FOR_EACH_PTR(p2__);		\
+		FINISH_PTR_LIST(p1__);		\
+	} while (0)
+
+
+typedef unsigned usage_t;
+
+static struct reporter *reporter;
+static struct symbol *return_type;
+
+static void do_sym_list(struct symbol_list *list);
+
+static struct symbol
+	*base_type(struct symbol *sym),
+	*do_initializer(struct symbol *type, struct expression *expr),
+	*do_expression(usage_t mode, struct expression *expr),
+	*do_statement(usage_t mode, struct statement *stmt);
+
+static inline int is_ptr(struct symbol *type)
+{
+	return type->type == SYM_PTR || type->type == SYM_ARRAY;
+}
+
+static inline usage_t u_rval(usage_t mode)
+{
+	return mode & (U_R_VAL | (U_MASK << U_SHIFT))
+		? U_R_VAL : 0;
+}
+
+static inline usage_t u_addr(usage_t mode)
+{
+	return mode = mode & U_MASK
+		? U_R_AOF | (mode & U_W_AOF) : 0;
+}
+
+static usage_t u_lval(struct symbol *type)
+{
+	int wptr = is_ptr(type) && !(type->ctype.modifiers & MOD_CONST);
+	return wptr || type == &bad_ctype
+		? U_W_AOF | U_R_VAL : U_R_VAL;
+}
+
+static usage_t fix_mode(struct symbol *type, usage_t mode)
+{
+	mode &= (U_SELF | (U_SELF << U_SHIFT));
+
+	switch (type->type) {
+		case SYM_BASETYPE:
+			if (!type->ctype.base_type)
+				break;
+		case SYM_ENUM:
+		case SYM_BITFIELD:
+			if (mode & U_MASK)
+				mode &= U_SELF;
+		default:
+
+		break; case SYM_FN:
+			if (mode & U_R_VAL)
+				mode |= U_R_AOF;
+			mode &= ~(U_R_VAL | U_W_AOF);
+
+		break; case SYM_ARRAY:
+			if (mode & (U_MASK << U_SHIFT))
+				mode >>= U_SHIFT;
+			else if (mode != U_W_VAL)
+				mode = u_addr(mode);
+	}
+
+	if (!(mode & U_R_AOF))
+		mode &= ~U_W_AOF;
+
+	return mode;
+}
+
+static inline struct symbol *no_member(struct ident *name)
+{
+	static struct symbol sym = {
+		.type = SYM_BAD,
+	};
+
+	sym.ctype.base_type = &bad_ctype;
+	sym.ident = name;
+
+	return &sym;
+}
+
+static struct symbol *report_member(usage_t mode, struct position *pos,
+					struct symbol *type, struct symbol *mem)
+{
+	struct symbol *ret = mem->ctype.base_type;
+
+	if (reporter->r_member)
+		reporter->r_member(fix_mode(ret, mode), pos, type, mem);
+
+	return ret;
+}
+
+static void report_implicit(usage_t mode, struct position *pos, struct symbol *type)
+{
+	if (type->type != SYM_STRUCT && type->type != SYM_UNION)
+		return;
+
+	if (!reporter->r_member)
+		return;
+
+	if (type->ident != NULL)
+		reporter->r_member(mode, pos, type, NULL);
+
+	DO_LIST(type->symbol_list, mem,
+		report_implicit(mode, pos, base_type(mem)));
+}
+
+static inline struct symbol *expr_symbol(struct expression *expr)
+{
+	struct symbol *sym = expr->symbol;
+
+	if (!sym) {
+		sym = lookup_symbol(expr->symbol_name, NS_SYMBOL);
+
+		if (!sym) {
+			sym = alloc_symbol(expr->pos, SYM_BAD);
+			bind_symbol(sym, expr->symbol_name, NS_SYMBOL);
+			sym->ctype.modifiers = MOD_EXTERN;
+		}
+	}
+
+	if (!sym->ctype.base_type)
+		sym->ctype.base_type = &bad_ctype;
+
+	return sym;
+}
+
+static struct symbol *report_symbol(usage_t mode, struct expression *expr)
+{
+	struct symbol *sym = expr_symbol(expr);
+	struct symbol *ret = base_type(sym);
+
+	if (0 && ret->type == SYM_ENUM)
+		return report_member(mode, &expr->pos, ret, expr->symbol);
+
+	if (reporter->r_symbol)
+		reporter->r_symbol(fix_mode(ret, mode), &expr->pos, sym);
+
+	return ret;
+}
+
+static inline struct ident *mk_name(struct ident *root, struct ident *node)
+{
+	char name[256];
+
+	snprintf(name, sizeof(name), "%.*s:%.*s",
+			root ? root->len : 0, root ? root->name : "",
+			node ? node->len : 0, node ? node->name : "");
+
+	return built_in_ident(name);
+}
+
+static void examine_sym_node(struct symbol *node, struct ident *root)
+{
+	struct symbol *base;
+	struct ident *name;
+
+	if (node->examined)
+		return;
+
+	node->examined = 1;
+	name = node->ident;
+
+	while ((base = node->ctype.base_type) != NULL)
+		switch (base->type) {
+		case SYM_TYPEOF:
+			node->ctype.base_type =
+				do_expression(U_VOID, base->initializer);
+			break;
+
+		case SYM_ARRAY:
+			do_expression(U_R_VAL, base->array_size);
+		case SYM_PTR: case SYM_FN:
+			node = base;
+			break;
+
+		case SYM_STRUCT: case SYM_UNION: //case SYM_ENUM:
+			if (base->evaluated)
+				return;
+			if (!base->symbol_list)
+				return;
+			base->evaluated = 1;
+
+			if (!base->ident && name)
+				base->ident = mk_name(root, name);
+			if (base->ident && reporter->r_symdef)
+				reporter->r_symdef(base);
+			DO_LIST(base->symbol_list, mem,
+				examine_sym_node(mem, base->ident ?: root));
+		default:
+			return;
+		}
+}
+
+static struct symbol *base_type(struct symbol *sym)
+{
+	if (!sym)
+		return &bad_ctype;
+
+	if (sym->type == SYM_NODE)
+		examine_sym_node(sym, NULL);
+
+	return sym->ctype.base_type	// builtin_fn_type
+		?: &bad_ctype;
+}
+
+static struct symbol *__lookup_member(struct symbol *type, struct ident *name, int *p_addr)
+{
+	struct symbol *node;
+	int addr = 0;
+
+	FOR_EACH_PTR(type->symbol_list, node)
+		if (!name) {
+			if (addr == *p_addr)
+				return node;
+		}
+		else if (node->ident == NULL) {
+			node = __lookup_member(node->ctype.base_type, name, NULL);
+			if (node)
+				goto found;
+		}
+		else if (node->ident == name) {
+found:
+			if (p_addr)
+				*p_addr = addr;
+			return node;
+		}
+		addr++;
+	END_FOR_EACH_PTR(node);
+
+	return NULL;
+}
+
+static struct symbol *lookup_member(struct symbol *type, struct ident *name, int *addr)
+{
+	return __lookup_member(type, name, addr)
+		?: no_member(name);
+}
+
+static struct expression *peek_preop(struct expression *expr, int op)
+{
+	do {
+		if (expr->type != EXPR_PREOP)
+			break;
+		if (expr->op == op)
+			return expr->unop;
+		if (expr->op == '(')
+			expr = expr->unop;
+		else
+			break;
+	} while (expr);
+
+	return NULL;
+}
+
+static struct symbol *do_expression(usage_t mode, struct expression *expr)
+{
+	struct symbol *ret = &int_ctype;
+
+again:
+	if (expr) switch (expr->type) {
+	default:
+		warning(expr->pos, "bad expr->type: %d", expr->type);
+
+	case EXPR_TYPE:		// [struct T]; Why ???
+	case EXPR_VALUE:
+	case EXPR_FVALUE:
+
+	break; case EXPR_LABEL:
+		ret = &label_ctype;
+
+	break; case EXPR_STRING:
+		ret = &string_ctype;
+
+	break; case EXPR_STATEMENT:
+		ret = do_statement(mode, expr->statement);
+
+	break; case EXPR_SIZEOF: case EXPR_ALIGNOF: case EXPR_PTRSIZEOF:
+		do_expression(U_VOID, expr->cast_expression);
+
+	break; case EXPR_COMMA:
+		do_expression(U_VOID, expr->left);
+		ret = do_expression(mode, expr->right);
+
+	break; case EXPR_CAST: case EXPR_FORCE_CAST: //case EXPR_IMPLIED_CAST:
+		ret = base_type(expr->cast_type);
+		do_initializer(ret, expr->cast_expression);
+
+	break; case EXPR_COMPARE: case EXPR_LOGICAL:
+		mode = u_rval(mode);
+		do_expression(mode, expr->left);
+		do_expression(mode, expr->right);
+
+	break; case EXPR_CONDITIONAL: //case EXPR_SELECT:
+		do_expression(expr->cond_true
+					? U_R_VAL : U_R_VAL | mode,
+				expr->conditional);
+		ret = do_expression(mode, expr->cond_true);
+		ret = do_expression(mode, expr->cond_false);
+
+	break; case EXPR_CALL:
+		ret = do_expression(U_R_PTR, expr->fn);
+		if (is_ptr(ret))
+			ret = ret->ctype.base_type;
+		DO_2_LIST(ret->arguments, expr->args, arg, val,
+			do_expression(u_lval(base_type(arg)), val));
+		ret = ret->type == SYM_FN ? base_type(ret)
+			: &bad_ctype;
+
+	break; case EXPR_ASSIGNMENT:
+		mode |= U_W_VAL | U_R_VAL;
+		if (expr->op == '=')
+			mode &= ~U_R_VAL;
+		ret = do_expression(mode, expr->left);
+		report_implicit(mode, &expr->pos, ret);
+		mode = expr->op == '='
+			? u_lval(ret) : U_R_VAL;
+		do_expression(mode, expr->right);
+
+	break; case EXPR_BINOP: {
+		struct symbol *l, *r;
+		mode |= u_rval(mode);
+		l = do_expression(mode, expr->left);
+		r = do_expression(mode, expr->right);
+		if (expr->op != '+' && expr->op != '-')
+			;
+		else if (!is_ptr_type(r))
+			ret = l;
+		else if (!is_ptr_type(l))
+			ret = r;
+	}
+
+	break; case EXPR_PREOP: case EXPR_POSTOP: {
+		struct expression *unop = expr->unop;
+
+		switch (expr->op) {
+		case SPECIAL_INCREMENT:
+		case SPECIAL_DECREMENT:
+			mode |= U_W_VAL | U_R_VAL;
+		default:
+			mode |= u_rval(mode);
+		case '(':
+			ret = do_expression(mode, unop);
+
+		break; case '&':
+			if ((expr = peek_preop(unop, '*')))
+				goto again;
+			ret = alloc_symbol(unop->pos, SYM_PTR);
+			ret->ctype.base_type =
+				do_expression(u_addr(mode), unop);
+
+		break; case '*':
+			if ((expr = peek_preop(unop, '&')))
+				goto again;
+			if (mode & (U_MASK << U_SHIFT))
+				mode |= U_R_VAL;
+			mode <<= U_SHIFT;
+			if (mode & (U_R_AOF << U_SHIFT))
+				mode |= U_R_VAL;
+			if (mode & (U_W_VAL << U_SHIFT))
+				mode |= U_W_AOF;
+			ret = do_expression(mode, unop);
+			ret = is_ptr(ret) ? base_type(ret)
+				: &bad_ctype;
+		}
+	}
+
+	break; case EXPR_DEREF: {
+		struct symbol *p_type;
+		usage_t p_mode;
+
+		p_mode = mode & U_SELF;
+		if (!(mode & U_MASK) && (mode & (U_MASK << U_SHIFT)))
+			p_mode = U_R_VAL;
+		p_type = do_expression(p_mode, expr->deref);
+
+		ret = report_member(mode, &expr->pos, p_type,
+			lookup_member(p_type, expr->member, NULL));
+	}
+
+	break; case EXPR_OFFSETOF: {
+		struct symbol *in = base_type(expr->in);
+
+		do {
+			if (expr->op == '.') {
+				in = report_member(U_VOID, &expr->pos, in,
+					lookup_member(in, expr->ident, NULL));
+			} else {
+				do_expression(U_R_VAL, expr->index);
+				in = in->ctype.base_type;
+			}
+		} while ((expr = expr->down));
+	}
+
+	break; case EXPR_SYMBOL:
+		ret = report_symbol(mode, expr);
+	}
+
+	return ret;
+}
+
+static void do_asm_xputs(usage_t mode, struct expression_list *xputs)
+{
+	int nr = 0;
+
+	DO_LIST(xputs, expr,
+		if (++nr % 3 == 0)
+			do_expression(U_W_AOF | mode, expr));
+}
+
+static struct symbol *do_statement(usage_t mode, struct statement *stmt)
+{
+	struct symbol *ret = &void_ctype;
+
+	if (stmt) switch (stmt->type) {
+	default:
+		warning(stmt->pos, "bad stmt->type: %d", stmt->type);
+
+	case STMT_NONE:
+	case STMT_RANGE:
+	case STMT_CONTEXT:
+
+	break; case STMT_DECLARATION:
+		do_sym_list(stmt->declaration);
+
+	break; case STMT_EXPRESSION:
+		ret = do_expression(mode, stmt->expression);
+
+	break; case STMT_RETURN:
+		do_expression(u_lval(return_type), stmt->expression);
+
+	break; case STMT_ASM:
+		do_expression(U_R_VAL, stmt->asm_string);
+		do_asm_xputs(U_W_VAL, stmt->asm_outputs);
+		do_asm_xputs(U_R_VAL, stmt->asm_inputs);
+
+	break; case STMT_COMPOUND: {
+		int count;
+
+		count = statement_list_size(stmt->stmts);
+		DO_LIST(stmt->stmts, st,
+			ret = do_statement(--count ? U_VOID : mode, st));
+	}
+
+	break; case STMT_ITERATOR:
+		do_sym_list(stmt->iterator_syms);
+		do_statement(U_VOID, stmt->iterator_pre_statement);
+		do_expression(U_R_VAL, stmt->iterator_pre_condition);
+		do_statement(U_VOID, stmt->iterator_post_statement);
+		do_statement(U_VOID, stmt->iterator_statement);
+		do_expression(U_R_VAL, stmt->iterator_post_condition);
+
+	break; case STMT_IF:
+		do_expression(U_R_VAL, stmt->if_conditional);
+		do_statement(U_VOID, stmt->if_true);
+		do_statement(U_VOID, stmt->if_false);
+
+	break; case STMT_SWITCH:
+		do_expression(U_R_VAL, stmt->switch_expression);
+		do_statement(U_VOID, stmt->switch_statement);
+
+	break; case STMT_CASE:
+		do_expression(U_R_VAL, stmt->case_expression);
+		do_expression(U_R_VAL, stmt->case_to);
+		do_statement(U_VOID, stmt->case_statement);
+
+	break; case STMT_GOTO:
+		do_expression(U_R_PTR, stmt->goto_expression);
+
+	break; case STMT_LABEL:
+		do_statement(mode, stmt->label_statement);
+
+	}
+
+	return ret;
+}
+
+static struct symbol *do_initializer(struct symbol *type, struct expression *expr)
+{
+	struct symbol *m_type;
+	struct expression *m_expr;
+	int m_addr;
+
+	if (expr) switch (expr->type) {
+	default:
+		do_expression(u_lval(type), expr);
+
+	break; case EXPR_INDEX:
+		do_initializer(base_type(type), expr->idx_expression);
+
+	break; case EXPR_INITIALIZER:
+		m_addr = 0;
+		FOR_EACH_PTR(expr->expr_list, m_expr) {
+			if (type->type == SYM_ARRAY) {
+				m_type = base_type(type);
+				if (m_expr->type == EXPR_INDEX)
+					m_expr = m_expr->idx_expression;
+			} else {
+				int *m_atop = &m_addr;
+
+				m_type = type;
+				while (m_expr->type == EXPR_IDENTIFIER) {
+					m_type = report_member(U_W_VAL, &m_expr->pos, m_type,
+							lookup_member(m_type, m_expr->expr_ident, m_atop));
+					m_expr = m_expr->ident_expression;
+					m_atop = NULL;
+				}
+
+				if (m_atop) {
+					m_type = report_member(U_W_VAL, &m_expr->pos, m_type,
+							lookup_member(m_type, NULL, m_atop));
+				}
+
+				if (m_expr->type != EXPR_INITIALIZER)
+					report_implicit(U_W_VAL, &m_expr->pos, m_type);
+			}
+			do_initializer(m_type, m_expr);
+			m_addr++;
+		} END_FOR_EACH_PTR(m_expr);
+	}
+
+	return type;
+}
+
+static inline struct symbol *do_symbol(struct symbol *sym)
+{
+	struct symbol *type;
+
+	type = base_type(sym);
+
+	if (reporter->r_symdef)
+		reporter->r_symdef(sym);
+
+	switch (type->type) {
+	default:
+		if (!sym->initializer)
+			break;
+		if (reporter->r_symbol)
+			reporter->r_symbol(U_W_VAL, &sym->pos, sym);
+		do_initializer(type, sym->initializer);
+
+	break; case SYM_FN:
+		do_sym_list(type->arguments);
+		return_type = base_type(type);
+		do_statement(U_VOID, sym->ctype.modifiers & MOD_INLINE
+					? type->inline_stmt
+					: type->stmt);
+	}
+
+	return type;
+}
+
+static void do_sym_list(struct symbol_list *list)
+{
+	DO_LIST(list, sym, do_symbol(sym));
+}
+
+void dissect(struct symbol_list *list, struct reporter *rep)
+{
+	reporter = rep;
+	do_sym_list(list);
+}
diff --git a/usr/src/tools/smatch/src/dissect.h b/usr/src/tools/smatch/src/dissect.h
new file mode 100644
index 0000000000..664736ce21
--- /dev/null
+++ b/usr/src/tools/smatch/src/dissect.h
@@ -0,0 +1,29 @@
+#ifndef	DISSECT_H
+#define	DISSECT_H
+
+#include <stdio.h>
+#include "parse.h"
+#include "expression.h"
+
+#define	U_SHIFT		8
+
+#define	U_R_AOF		0x01
+#define	U_W_AOF		0x02
+
+#define	U_R_VAL		0x04
+#define	U_W_VAL		0x08
+
+#define	U_R_PTR		(U_R_VAL << U_SHIFT)
+#define	U_W_PTR		(U_W_VAL << U_SHIFT)
+
+struct reporter
+{
+	void (*r_symdef)(struct symbol *);
+
+	void (*r_symbol)(unsigned, struct position *, struct symbol *);
+	void (*r_member)(unsigned, struct position *, struct symbol *, struct symbol *);
+};
+
+extern void dissect(struct symbol_list *, struct reporter *);
+
+#endif
diff --git a/usr/src/tools/smatch/src/evaluate.c b/usr/src/tools/smatch/src/evaluate.c
new file mode 100644
index 0000000000..8f07d08cf5
--- /dev/null
+++ b/usr/src/tools/smatch/src/evaluate.c
@@ -0,0 +1,3666 @@
+/*
+ * sparse/evaluate.c
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Evaluate constant expressions.
+ */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "parse.h"
+#include "token.h"
+#include "symbol.h"
+#include "target.h"
+#include "expression.h"
+
+struct symbol *current_fn;
+
+static struct symbol *degenerate(struct expression *expr);
+static struct symbol *evaluate_symbol(struct symbol *sym);
+
+static struct symbol *evaluate_symbol_expression(struct expression *expr)
+{
+	struct expression *addr;
+	struct symbol *sym = expr->symbol;
+	struct symbol *base_type;
+
+	if (!sym) {
+		expression_error(expr, "undefined identifier '%s'", show_ident(expr->symbol_name));
+		return NULL;
+	}
+
+	examine_symbol_type(sym);
+
+	base_type = get_base_type(sym);
+	if (!base_type) {
+		expression_error(expr, "identifier '%s' has no type", show_ident(expr->symbol_name));
+		return NULL;
+	}
+
+	addr = alloc_expression(expr->pos, EXPR_SYMBOL);
+	addr->symbol = sym;
+	addr->symbol_name = expr->symbol_name;
+	addr->ctype = &lazy_ptr_ctype;	/* Lazy evaluation: we need to do a proper job if somebody does &sym */
+	addr->flags = expr->flags;
+	expr->type = EXPR_PREOP;
+	expr->op = '*';
+	expr->unop = addr;
+	expr->flags = CEF_NONE;
+
+	/* The type of a symbol is the symbol itself! */
+	expr->ctype = sym;
+	return sym;
+}
+
+static struct symbol *evaluate_string(struct expression *expr)
+{
+	struct symbol *sym = alloc_symbol(expr->pos, SYM_NODE);
+	struct symbol *array = alloc_symbol(expr->pos, SYM_ARRAY);
+	struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL);
+	struct expression *initstr = alloc_expression(expr->pos, EXPR_STRING);
+	unsigned int length = expr->string->length;
+
+	sym->array_size = alloc_const_expression(expr->pos, length);
+	sym->bit_size = bytes_to_bits(length);
+	sym->ctype.alignment = 1;
+	sym->string = 1;
+	sym->ctype.modifiers = MOD_STATIC;
+	sym->ctype.base_type = array;
+	sym->initializer = initstr;
+
+	initstr->ctype = sym;
+	initstr->string = expr->string;
+
+	array->array_size = sym->array_size;
+	array->bit_size = bytes_to_bits(length);
+	array->ctype.alignment = 1;
+	array->ctype.modifiers = MOD_STATIC;
+	array->ctype.base_type = &char_ctype;
+	
+	addr->symbol = sym;
+	addr->ctype = &lazy_ptr_ctype;
+	addr->flags = CEF_ADDR;
+
+	expr->type = EXPR_PREOP;
+	expr->op = '*';
+	expr->unop = addr;  
+	expr->ctype = sym;
+	return sym;
+}
+
+/* type has come from classify_type and is an integer type */
+static inline struct symbol *integer_promotion(struct symbol *type)
+{
+	unsigned long mod =  type->ctype.modifiers;
+	int width = type->bit_size;
+
+	/*
+	 * Bitfields always promote to the base type,
+	 * even if the bitfield might be bigger than
+	 * an "int".
+	 */
+	if (type->type == SYM_BITFIELD) {
+		type = type->ctype.base_type;
+	}
+	mod = type->ctype.modifiers;
+	if (width < bits_in_int)
+		return &int_ctype;
+
+	/* If char/short has as many bits as int, it still gets "promoted" */
+	if (mod & (MOD_CHAR | MOD_SHORT)) {
+		if (mod & MOD_UNSIGNED)
+			return &uint_ctype;
+		return &int_ctype;
+	}
+	return type;
+}
+
+/*
+ * integer part of usual arithmetic conversions:
+ *	integer promotions are applied
+ *	if left and right are identical, we are done
+ *	if signedness is the same, convert one with lower rank
+ *	unless unsigned argument has rank lower than signed one, convert the
+ *	signed one.
+ *	if signed argument is bigger than unsigned one, convert the unsigned.
+ *	otherwise, convert signed.
+ *
+ * Leaving aside the integer promotions, that is equivalent to
+ *	if identical, don't convert
+ *	if left is bigger than right, convert right
+ *	if right is bigger than left, convert right
+ *	otherwise, if signedness is the same, convert one with lower rank
+ *	otherwise convert the signed one.
+ */
+static struct symbol *bigger_int_type(struct symbol *left, struct symbol *right)
+{
+	unsigned long lmod, rmod;
+
+	left = integer_promotion(left);
+	right = integer_promotion(right);
+
+	if (left == right)
+		goto left;
+
+	if (left->bit_size > right->bit_size)
+		goto left;
+
+	if (right->bit_size > left->bit_size)
+		goto right;
+
+	lmod = left->ctype.modifiers;
+	rmod = right->ctype.modifiers;
+	if ((lmod ^ rmod) & MOD_UNSIGNED) {
+		if (lmod & MOD_UNSIGNED)
+			goto left;
+	} else if ((lmod & ~rmod) & (MOD_LONG_ALL))
+		goto left;
+right:
+	left = right;
+left:
+	return left;
+}
+
+static int same_cast_type(struct symbol *orig, struct symbol *new)
+{
+	return orig->bit_size == new->bit_size &&
+	       orig->bit_offset == new->bit_offset;
+}
+
+static struct symbol *base_type(struct symbol *node, unsigned long *modp, unsigned long *asp)
+{
+	unsigned long mod, as;
+
+	mod = 0; as = 0;
+	while (node) {
+		mod |= node->ctype.modifiers;
+		as |= node->ctype.as;
+		if (node->type == SYM_NODE) {
+			node = node->ctype.base_type;
+			continue;
+		}
+		break;
+	}
+	*modp = mod & ~MOD_IGNORE;
+	*asp = as;
+	return node;
+}
+
+static int is_same_type(struct expression *expr, struct symbol *new)
+{
+	struct symbol *old = expr->ctype;
+	unsigned long oldmod, newmod, oldas, newas;
+
+	old = base_type(old, &oldmod, &oldas);
+	new = base_type(new, &newmod, &newas);
+
+	/* Same base type, same address space? */
+	if (old == new && oldas == newas) {
+		unsigned long difmod;
+
+		/* Check the modifier bits. */
+		difmod = (oldmod ^ newmod) & ~MOD_NOCAST;
+
+		/* Exact same type? */
+		if (!difmod)
+			return 1;
+
+		/*
+		 * Not the same type, but differs only in "const".
+		 * Don't warn about MOD_NOCAST.
+		 */
+		if (difmod == MOD_CONST)
+			return 0;
+	}
+	if ((oldmod | newmod) & MOD_NOCAST) {
+		const char *tofrom = "to/from";
+		if (!(newmod & MOD_NOCAST))
+			tofrom = "from";
+		if (!(oldmod & MOD_NOCAST))
+			tofrom = "to";
+		warning(expr->pos, "implicit cast %s nocast type", tofrom);
+	}
+	return 0;
+}
+
+static void
+warn_for_different_enum_types (struct position pos,
+			       struct symbol *typea,
+			       struct symbol *typeb)
+{
+	if (!Wenum_mismatch)
+		return;
+	if (typea->type == SYM_NODE)
+		typea = typea->ctype.base_type;
+	if (typeb->type == SYM_NODE)
+		typeb = typeb->ctype.base_type;
+
+	if (typea == typeb)
+		return;
+
+	if (typea->type == SYM_ENUM && typeb->type == SYM_ENUM) {
+		warning(pos, "mixing different enum types");
+		info(pos, "    %s versus", show_typename(typea));
+		info(pos, "    %s", show_typename(typeb));
+	}
+}
+
+static int cast_flags(struct expression *expr, struct expression *target);
+static struct symbol *cast_to_bool(struct expression *expr);
+
+/*
+ * This gets called for implicit casts in assignments and
+ * integer promotion. We often want to try to move the
+ * cast down, because the ops involved may have been
+ * implicitly cast up, and we can get rid of the casts
+ * early.
+ */
+static struct expression * cast_to(struct expression *old, struct symbol *type)
+{
+	struct expression *expr;
+
+	warn_for_different_enum_types (old->pos, old->ctype, type);
+
+	if (old->ctype != &null_ctype && is_same_type(old, type))
+		return old;
+
+	/*
+	 * See if we can simplify the op. Move the cast down.
+	 */
+	switch (old->type) {
+	case EXPR_PREOP:
+		if (old->ctype->bit_size < type->bit_size)
+			break;
+		if (old->op == '~') {
+			old->ctype = type;
+			old->unop = cast_to(old->unop, type);
+			return old;
+		}
+		break;
+
+	case EXPR_IMPLIED_CAST:
+		warn_for_different_enum_types(old->pos, old->ctype, type);
+
+		if (old->ctype->bit_size >= type->bit_size) {
+			struct expression *orig = old->cast_expression;
+			if (same_cast_type(orig->ctype, type))
+				return orig;
+			if (old->ctype->bit_offset == type->bit_offset) {
+				old->ctype = type;
+				old->cast_type = type;
+				return old;
+			}
+		}
+		break;
+
+	default:
+		/* nothing */;
+	}
+
+	expr = alloc_expression(old->pos, EXPR_IMPLIED_CAST);
+	expr->ctype = type;
+	expr->cast_type = type;
+	expr->cast_expression = old;
+	expr->flags = cast_flags(expr, old);
+
+	if (is_bool_type(type))
+		cast_to_bool(expr);
+
+	return expr;
+}
+
+enum {
+	TYPE_NUM = 1,
+	TYPE_BITFIELD = 2,
+	TYPE_RESTRICT = 4,
+	TYPE_FLOAT = 8,
+	TYPE_PTR = 16,
+	TYPE_COMPOUND = 32,
+	TYPE_FOULED = 64,
+	TYPE_FN = 128,
+};
+
+static inline int classify_type(struct symbol *type, struct symbol **base)
+{
+	static int type_class[SYM_BAD + 1] = {
+		[SYM_PTR] = TYPE_PTR,
+		[SYM_FN] = TYPE_PTR | TYPE_FN,
+		[SYM_ARRAY] = TYPE_PTR | TYPE_COMPOUND,
+		[SYM_STRUCT] = TYPE_COMPOUND,
+		[SYM_UNION] = TYPE_COMPOUND,
+		[SYM_BITFIELD] = TYPE_NUM | TYPE_BITFIELD,
+		[SYM_RESTRICT] = TYPE_NUM | TYPE_RESTRICT,
+		[SYM_FOULED] = TYPE_NUM | TYPE_RESTRICT | TYPE_FOULED,
+	};
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	if (type->type == SYM_TYPEOF) {
+		type = evaluate_expression(type->initializer);
+		if (!type)
+			type = &bad_ctype;
+		else if (type->type == SYM_NODE)
+			type = type->ctype.base_type;
+	}
+	if (type->type == SYM_ENUM)
+		type = type->ctype.base_type;
+	*base = type;
+	if (type->type == SYM_BASETYPE) {
+		if (type->ctype.base_type == &int_type)
+			return TYPE_NUM;
+		if (type->ctype.base_type == &fp_type)
+			return TYPE_NUM | TYPE_FLOAT;
+	}
+	return type_class[type->type];
+}
+
+#define is_int(class) ((class & (TYPE_NUM | TYPE_FLOAT)) == TYPE_NUM)
+
+static inline int is_string_type(struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	return type->type == SYM_ARRAY && is_byte_type(type->ctype.base_type);
+}
+
+static struct symbol *bad_expr_type(struct expression *expr)
+{
+	sparse_error(expr->pos, "incompatible types for operation (%s)", show_special(expr->op));
+	switch (expr->type) {
+	case EXPR_BINOP:
+	case EXPR_COMPARE:
+		info(expr->pos, "   left side has type %s", show_typename(expr->left->ctype));
+		info(expr->pos, "   right side has type %s", show_typename(expr->right->ctype));
+		break;
+	case EXPR_PREOP:
+	case EXPR_POSTOP:
+		info(expr->pos, "   argument has type %s", show_typename(expr->unop->ctype));
+		break;
+	default:
+		break;
+	}
+
+	expr->flags = CEF_NONE;
+	return expr->ctype = &bad_ctype;
+}
+
+static int restricted_value(struct expression *v, struct symbol *type)
+{
+	if (v->type != EXPR_VALUE)
+		return 1;
+	if (v->value != 0)
+		return 1;
+	return 0;
+}
+
+static int restricted_binop(int op, struct symbol *type)
+{
+	switch (op) {
+		case '&':
+		case '=':
+		case SPECIAL_AND_ASSIGN:
+		case SPECIAL_OR_ASSIGN:
+		case SPECIAL_XOR_ASSIGN:
+			return 1;	/* unfoul */
+		case '|':
+		case '^':
+		case '?':
+			return 2;	/* keep fouled */
+		case SPECIAL_EQUAL:
+		case SPECIAL_NOTEQUAL:
+			return 3;	/* warn if fouled */
+		default:
+			return 0;	/* warn */
+	}
+}
+
+static int restricted_unop(int op, struct symbol **type)
+{
+	if (op == '~') {
+		if ((*type)->bit_size < bits_in_int)
+			*type = befoul(*type);
+		return 0;
+	} if (op == '+')
+		return 0;
+	return 1;
+}
+
+/* type should be SYM_FOULED */
+static inline struct symbol *unfoul(struct symbol *type)
+{
+	return type->ctype.base_type;
+}
+
+static struct symbol *restricted_binop_type(int op,
+					struct expression *left,
+					struct expression *right,
+					int lclass, int rclass,
+					struct symbol *ltype,
+					struct symbol *rtype)
+{
+	struct symbol *ctype = NULL;
+	if (lclass & TYPE_RESTRICT) {
+		if (rclass & TYPE_RESTRICT) {
+			if (ltype == rtype) {
+				ctype = ltype;
+			} else if (lclass & TYPE_FOULED) {
+				if (unfoul(ltype) == rtype)
+					ctype = ltype;
+			} else if (rclass & TYPE_FOULED) {
+				if (unfoul(rtype) == ltype)
+					ctype = rtype;
+			}
+		} else {
+			if (!restricted_value(right, ltype))
+				ctype = ltype;
+		}
+	} else if (!restricted_value(left, rtype))
+		ctype = rtype;
+
+	if (ctype) {
+		switch (restricted_binop(op, ctype)) {
+		case 1:
+			if ((lclass ^ rclass) & TYPE_FOULED)
+				ctype = unfoul(ctype);
+			break;
+		case 3:
+			if (!(lclass & rclass & TYPE_FOULED))
+				break;
+		case 0:
+			ctype = NULL;
+		default:
+			break;
+		}
+	}
+
+	return ctype;
+}
+
+static inline void unrestrict(struct expression *expr,
+			      int class, struct symbol **ctype)
+{
+	if (class & TYPE_RESTRICT) {
+		if (class & TYPE_FOULED)
+			*ctype = unfoul(*ctype);
+		warning(expr->pos, "%s degrades to integer",
+			show_typename(*ctype));
+		*ctype = (*ctype)->ctype.base_type; /* get to arithmetic type */
+	}
+}
+
+static struct symbol *usual_conversions(int op,
+					struct expression *left,
+					struct expression *right,
+					int lclass, int rclass,
+					struct symbol *ltype,
+					struct symbol *rtype)
+{
+	struct symbol *ctype;
+
+	warn_for_different_enum_types(right->pos, left->ctype, right->ctype);
+
+	if ((lclass | rclass) & TYPE_RESTRICT)
+		goto Restr;
+
+Normal:
+	if (!(lclass & TYPE_FLOAT)) {
+		if (!(rclass & TYPE_FLOAT))
+			return bigger_int_type(ltype, rtype);
+		else
+			return rtype;
+	} else if (rclass & TYPE_FLOAT) {
+		unsigned long lmod = ltype->ctype.modifiers;
+		unsigned long rmod = rtype->ctype.modifiers;
+		if (rmod & ~lmod & (MOD_LONG_ALL))
+			return rtype;
+		else
+			return ltype;
+	} else
+		return ltype;
+
+Restr:
+	ctype = restricted_binop_type(op, left, right,
+				      lclass, rclass, ltype, rtype);
+	if (ctype)
+		return ctype;
+
+	unrestrict(left, lclass, &ltype);
+	unrestrict(right, rclass, &rtype);
+
+	goto Normal;
+}
+
+static inline int lvalue_expression(struct expression *expr)
+{
+	return expr->type == EXPR_PREOP && expr->op == '*';
+}
+
+static struct symbol *evaluate_ptr_add(struct expression *expr, struct symbol *itype)
+{
+	struct expression *index = expr->right;
+	struct symbol *ctype, *base;
+	int multiply;
+
+	classify_type(degenerate(expr->left), &ctype);
+	base = examine_pointer_target(ctype);
+
+	/*
+	 * An address constant +/- an integer constant expression
+	 * yields an address constant again [6.6(7)].
+	 */
+	if ((expr->left->flags & CEF_ADDR) && (expr->right->flags & CEF_ICE))
+		expr->flags = CEF_ADDR;
+
+	if (!base) {
+		expression_error(expr, "missing type information");
+		return NULL;
+	}
+	if (is_function(base)) {
+		expression_error(expr, "arithmetics on pointers to functions");
+		return NULL;
+	}
+
+	/* Get the size of whatever the pointer points to */
+	multiply = is_void_type(base) ? 1 : bits_to_bytes(base->bit_size);
+
+	if (ctype == &null_ctype)
+		ctype = &ptr_ctype;
+	expr->ctype = ctype;
+
+	if (multiply == 1 && itype->bit_size >= bits_in_pointer)
+		return ctype;
+
+	if (index->type == EXPR_VALUE) {
+		struct expression *val = alloc_expression(expr->pos, EXPR_VALUE);
+		unsigned long long v = index->value, mask;
+		mask = 1ULL << (itype->bit_size - 1);
+		if (v & mask)
+			v |= -mask;
+		else
+			v &= mask - 1;
+		v *= multiply;
+		mask = 1ULL << (bits_in_pointer - 1);
+		v &= mask | (mask - 1);
+		val->value = v;
+		val->ctype = ssize_t_ctype;
+		expr->right = val;
+		return ctype;
+	}
+
+	if (itype->bit_size < bits_in_pointer)
+		index = cast_to(index, ssize_t_ctype);
+
+	if (multiply > 1) {
+		struct expression *val = alloc_expression(expr->pos, EXPR_VALUE);
+		struct expression *mul = alloc_expression(expr->pos, EXPR_BINOP);
+
+		val->ctype = ssize_t_ctype;
+		val->value = multiply;
+
+		mul->op = '*';
+		mul->ctype = ssize_t_ctype;
+		mul->left = index;
+		mul->right = val;
+		index = mul;
+	}
+
+	expr->right = index;
+	return ctype;
+}
+
+static void examine_fn_arguments(struct symbol *fn);
+
+#define MOD_IGN (MOD_VOLATILE | MOD_CONST | MOD_PURE)
+
+const char *type_difference(struct ctype *c1, struct ctype *c2,
+	unsigned long mod1, unsigned long mod2)
+{
+	unsigned long as1 = c1->as, as2 = c2->as;
+	struct symbol *t1 = c1->base_type;
+	struct symbol *t2 = c2->base_type;
+	int move1 = 1, move2 = 1;
+	mod1 |= c1->modifiers;
+	mod2 |= c2->modifiers;
+	for (;;) {
+		unsigned long diff;
+		int type;
+		struct symbol *base1 = t1->ctype.base_type;
+		struct symbol *base2 = t2->ctype.base_type;
+
+		/*
+		 * FIXME! Collect alignment and context too here!
+		 */
+		if (move1) {
+			if (t1 && t1->type != SYM_PTR) {
+				mod1 |= t1->ctype.modifiers;
+				as1 |= t1->ctype.as;
+			}
+			move1 = 0;
+		}
+
+		if (move2) {
+			if (t2 && t2->type != SYM_PTR) {
+				mod2 |= t2->ctype.modifiers;
+				as2 |= t2->ctype.as;
+			}
+			move2 = 0;
+		}
+
+		if (t1 == t2)
+			break;
+		if (!t1 || !t2)
+			return "different types";
+
+		if (t1->type == SYM_NODE || t1->type == SYM_ENUM) {
+			t1 = base1;
+			move1 = 1;
+			if (!t1)
+				return "bad types";
+			continue;
+		}
+
+		if (t2->type == SYM_NODE || t2->type == SYM_ENUM) {
+			t2 = base2;
+			move2 = 1;
+			if (!t2)
+				return "bad types";
+			continue;
+		}
+
+		move1 = move2 = 1;
+		type = t1->type;
+		if (type != t2->type)
+			return "different base types";
+
+		switch (type) {
+		default:
+			sparse_error(t1->pos,
+				     "internal error: bad type in derived(%d)",
+				     type);
+			return "bad types";
+		case SYM_RESTRICT:
+			return "different base types";
+		case SYM_UNION:
+		case SYM_STRUCT:
+			/* allow definition of incomplete structs and unions */
+			if (t1->ident == t2->ident)
+			  return NULL;
+			return "different base types";
+		case SYM_ARRAY:
+			/* XXX: we ought to compare sizes */
+			break;
+		case SYM_PTR:
+			if (as1 != as2)
+				return "different address spaces";
+			/* MOD_SPECIFIER is due to idiocy in parse.c */
+			if ((mod1 ^ mod2) & ~MOD_IGNORE & ~MOD_SPECIFIER)
+				return "different modifiers";
+			/* we could be lazier here */
+			base1 = examine_pointer_target(t1);
+			base2 = examine_pointer_target(t2);
+			mod1 = t1->ctype.modifiers;
+			as1 = t1->ctype.as;
+			mod2 = t2->ctype.modifiers;
+			as2 = t2->ctype.as;
+			break;
+		case SYM_FN: {
+			struct symbol *arg1, *arg2;
+			int i;
+
+			if (as1 != as2)
+				return "different address spaces";
+			if ((mod1 ^ mod2) & ~MOD_IGNORE & ~MOD_SIGNEDNESS)
+				return "different modifiers";
+			mod1 = t1->ctype.modifiers;
+			as1 = t1->ctype.as;
+			mod2 = t2->ctype.modifiers;
+			as2 = t2->ctype.as;
+
+			if (t1->variadic != t2->variadic)
+				return "incompatible variadic arguments";
+			examine_fn_arguments(t1);
+			examine_fn_arguments(t2);
+			PREPARE_PTR_LIST(t1->arguments, arg1);
+			PREPARE_PTR_LIST(t2->arguments, arg2);
+			i = 1;
+			for (;;) {
+				const char *diffstr;
+				if (!arg1 && !arg2)
+					break;
+				if (!arg1 || !arg2)
+					return "different argument counts";
+				diffstr = type_difference(&arg1->ctype,
+							  &arg2->ctype,
+							  MOD_IGN, MOD_IGN);
+				if (diffstr) {
+					static char argdiff[80];
+					sprintf(argdiff, "incompatible argument %d (%s)", i, diffstr);
+					return argdiff;
+				}
+				NEXT_PTR_LIST(arg1);
+				NEXT_PTR_LIST(arg2);
+				i++;
+			}
+			FINISH_PTR_LIST(arg2);
+			FINISH_PTR_LIST(arg1);
+			break;
+		}
+		case SYM_BASETYPE:
+			if (as1 != as2)
+				return "different address spaces";
+			if (base1 != base2)
+				return "different base types";
+			diff = (mod1 ^ mod2) & ~MOD_IGNORE;
+			if (!diff)
+				return NULL;
+			if (diff & MOD_SIZE)
+				return "different type sizes";
+			else if (diff & ~MOD_SIGNEDNESS)
+				return "different modifiers";
+			else
+				return "different signedness";
+		}
+		t1 = base1;
+		t2 = base2;
+	}
+	if (as1 != as2)
+		return "different address spaces";
+	if ((mod1 ^ mod2) & ~MOD_IGNORE & ~MOD_SIGNEDNESS)
+		return "different modifiers";
+	return NULL;
+}
+
+static void bad_null(struct expression *expr)
+{
+	if (Wnon_pointer_null)
+		warning(expr->pos, "Using plain integer as NULL pointer");
+}
+
+static unsigned long target_qualifiers(struct symbol *type)
+{
+	unsigned long mod = type->ctype.modifiers & MOD_IGN;
+	if (type->ctype.base_type && type->ctype.base_type->type == SYM_ARRAY)
+		mod = 0;
+	return mod;
+}
+
+static struct symbol *evaluate_ptr_sub(struct expression *expr)
+{
+	const char *typediff;
+	struct symbol *ltype, *rtype;
+	struct expression *l = expr->left;
+	struct expression *r = expr->right;
+	struct symbol *lbase;
+
+	classify_type(degenerate(l), &ltype);
+	classify_type(degenerate(r), &rtype);
+
+	lbase = examine_pointer_target(ltype);
+	examine_pointer_target(rtype);
+	typediff = type_difference(&ltype->ctype, &rtype->ctype,
+				   target_qualifiers(rtype),
+				   target_qualifiers(ltype));
+	if (typediff)
+		expression_error(expr, "subtraction of different types can't work (%s)", typediff);
+
+	if (is_function(lbase)) {
+		expression_error(expr, "subtraction of functions? Share your drugs");
+		return NULL;
+	}
+
+	expr->ctype = ssize_t_ctype;
+	if (lbase->bit_size > bits_in_char) {
+		struct expression *sub = alloc_expression(expr->pos, EXPR_BINOP);
+		struct expression *div = expr;
+		struct expression *val = alloc_expression(expr->pos, EXPR_VALUE);
+		unsigned long value = bits_to_bytes(lbase->bit_size);
+
+		val->ctype = size_t_ctype;
+		val->value = value;
+
+		if (value & (value-1)) {
+			if (Wptr_subtraction_blows)
+				warning(expr->pos, "potentially expensive pointer subtraction");
+		}
+
+		sub->op = '-';
+		sub->ctype = ssize_t_ctype;
+		sub->left = l;
+		sub->right = r;
+
+		div->op = '/';
+		div->left = sub;
+		div->right = val;
+	}
+		
+	return ssize_t_ctype;
+}
+
+#define is_safe_type(type) ((type)->ctype.modifiers & MOD_SAFE)
+
+static struct symbol *evaluate_conditional(struct expression *expr, int iterator)
+{
+	struct symbol *ctype;
+
+	if (!expr)
+		return NULL;
+
+	if (!iterator && expr->type == EXPR_ASSIGNMENT && expr->op == '=')
+		warning(expr->pos, "assignment expression in conditional");
+
+	ctype = evaluate_expression(expr);
+	if (ctype) {
+		if (is_safe_type(ctype))
+			warning(expr->pos, "testing a 'safe expression'");
+		if (is_func_type(ctype)) {
+			if (Waddress)
+				warning(expr->pos, "the address of %s will always evaluate as true", "a function");
+		} else if (is_array_type(ctype)) {
+			if (Waddress)
+				warning(expr->pos, "the address of %s will always evaluate as true", "an array");
+		} else if (!is_scalar_type(ctype)) {
+			sparse_error(expr->pos, "incorrect type in conditional");
+			info(expr->pos, "   got %s", show_typename(ctype));
+			ctype = NULL;
+		}
+	}
+	ctype = degenerate(expr);
+
+	return ctype;
+}
+
+static struct symbol *evaluate_logical(struct expression *expr)
+{
+	if (!evaluate_conditional(expr->left, 0))
+		return NULL;
+	if (!evaluate_conditional(expr->right, 0))
+		return NULL;
+
+	/* the result is int [6.5.13(3), 6.5.14(3)] */
+	expr->ctype = &int_ctype;
+	expr->flags = expr->left->flags & expr->right->flags;
+	expr->flags &= ~(CEF_CONST_MASK | CEF_ADDR);
+	return &int_ctype;
+}
+
+static struct symbol *evaluate_binop(struct expression *expr)
+{
+	struct symbol *ltype, *rtype, *ctype;
+	int lclass = classify_type(expr->left->ctype, &ltype);
+	int rclass = classify_type(expr->right->ctype, &rtype);
+	int op = expr->op;
+
+	/* number op number */
+	if (lclass & rclass & TYPE_NUM) {
+		expr->flags = expr->left->flags & expr->right->flags;
+		expr->flags &= ~CEF_CONST_MASK;
+
+		if ((lclass | rclass) & TYPE_FLOAT) {
+			switch (op) {
+			case '+': case '-': case '*': case '/':
+				break;
+			default:
+				return bad_expr_type(expr);
+			}
+		}
+
+		if (op == SPECIAL_LEFTSHIFT || op == SPECIAL_RIGHTSHIFT) {
+			// shifts do integer promotions, but that's it.
+			unrestrict(expr->left, lclass, &ltype);
+			unrestrict(expr->right, rclass, &rtype);
+			ctype = ltype = integer_promotion(ltype);
+			rtype = integer_promotion(rtype);
+		} else {
+			// The rest do usual conversions
+			const unsigned left_not  = expr->left->type == EXPR_PREOP
+			                           && expr->left->op == '!';
+			const unsigned right_not = expr->right->type == EXPR_PREOP
+			                           && expr->right->op == '!';
+			if ((op == '&' || op == '|') && (left_not || right_not))
+				warning(expr->pos, "dubious: %sx %c %sy",
+				        left_not ? "!" : "",
+					op,
+					right_not ? "!" : "");
+
+			ltype = usual_conversions(op, expr->left, expr->right,
+						  lclass, rclass, ltype, rtype);
+			ctype = rtype = ltype;
+		}
+
+		expr->left = cast_to(expr->left, ltype);
+		expr->right = cast_to(expr->right, rtype);
+		expr->ctype = ctype;
+		return ctype;
+	}
+
+	/* pointer (+|-) integer */
+	if (lclass & TYPE_PTR && is_int(rclass) && (op == '+' || op == '-')) {
+		unrestrict(expr->right, rclass, &rtype);
+		return evaluate_ptr_add(expr, rtype);
+	}
+
+	/* integer + pointer */
+	if (rclass & TYPE_PTR && is_int(lclass) && op == '+') {
+		struct expression *index = expr->left;
+		unrestrict(index, lclass, &ltype);
+		expr->left = expr->right;
+		expr->right = index;
+		return evaluate_ptr_add(expr, ltype);
+	}
+
+	/* pointer - pointer */
+	if (lclass & rclass & TYPE_PTR && expr->op == '-')
+		return evaluate_ptr_sub(expr);
+
+	return bad_expr_type(expr);
+}
+
+static struct symbol *evaluate_comma(struct expression *expr)
+{
+	expr->ctype = degenerate(expr->right);
+	if (expr->ctype == &null_ctype)
+		expr->ctype = &ptr_ctype;
+	expr->flags &= expr->left->flags & expr->right->flags;
+	return expr->ctype;
+}
+
+static int modify_for_unsigned(int op)
+{
+	if (op == '<')
+		op = SPECIAL_UNSIGNED_LT;
+	else if (op == '>')
+		op = SPECIAL_UNSIGNED_GT;
+	else if (op == SPECIAL_LTE)
+		op = SPECIAL_UNSIGNED_LTE;
+	else if (op == SPECIAL_GTE)
+		op = SPECIAL_UNSIGNED_GTE;
+	return op;
+}
+
+static inline int is_null_pointer_constant(struct expression *e)
+{
+	if (e->ctype == &null_ctype)
+		return 1;
+	if (!(e->flags & CEF_ICE))
+		return 0;
+	return is_zero_constant(e) ? 2 : 0;
+}
+
+static struct symbol *evaluate_compare(struct expression *expr)
+{
+	struct expression *left = expr->left, *right = expr->right;
+	struct symbol *ltype, *rtype, *lbase, *rbase;
+	int lclass = classify_type(degenerate(left), &ltype);
+	int rclass = classify_type(degenerate(right), &rtype);
+	struct symbol *ctype;
+	const char *typediff;
+
+	/* Type types? */
+	if (is_type_type(ltype) && is_type_type(rtype)) {
+		/*
+		 * __builtin_types_compatible_p() yields an integer
+		 * constant expression
+		 */
+		expr->flags = CEF_SET_ICE;
+		goto OK;
+	}
+
+	if (is_safe_type(left->ctype) || is_safe_type(right->ctype))
+		warning(expr->pos, "testing a 'safe expression'");
+
+	expr->flags = left->flags & right->flags & ~CEF_CONST_MASK & ~CEF_ADDR;
+
+	/* number on number */
+	if (lclass & rclass & TYPE_NUM) {
+		ctype = usual_conversions(expr->op, expr->left, expr->right,
+					  lclass, rclass, ltype, rtype);
+		expr->left = cast_to(expr->left, ctype);
+		expr->right = cast_to(expr->right, ctype);
+		if (ctype->ctype.modifiers & MOD_UNSIGNED)
+			expr->op = modify_for_unsigned(expr->op);
+		goto OK;
+	}
+
+	/* at least one must be a pointer */
+	if (!((lclass | rclass) & TYPE_PTR))
+		return bad_expr_type(expr);
+
+	/* equality comparisons can be with null pointer constants */
+	if (expr->op == SPECIAL_EQUAL || expr->op == SPECIAL_NOTEQUAL) {
+		int is_null1 = is_null_pointer_constant(left);
+		int is_null2 = is_null_pointer_constant(right);
+		if (is_null1 == 2)
+			bad_null(left);
+		if (is_null2 == 2)
+			bad_null(right);
+		if (is_null1 && is_null2) {
+			int positive = expr->op == SPECIAL_EQUAL;
+			expr->type = EXPR_VALUE;
+			expr->value = positive;
+			goto OK;
+		}
+		if (is_null1 && (rclass & TYPE_PTR)) {
+			left = cast_to(left, rtype);
+			goto OK;
+		}
+		if (is_null2 && (lclass & TYPE_PTR)) {
+			right = cast_to(right, ltype);
+			goto OK;
+		}
+	}
+	/* both should be pointers */
+	if (!(lclass & rclass & TYPE_PTR))
+		return bad_expr_type(expr);
+	expr->op = modify_for_unsigned(expr->op);
+
+	lbase = examine_pointer_target(ltype);
+	rbase = examine_pointer_target(rtype);
+
+	/* they also have special treatment for pointers to void */
+	if (expr->op == SPECIAL_EQUAL || expr->op == SPECIAL_NOTEQUAL) {
+		if (ltype->ctype.as == rtype->ctype.as) {
+			if (lbase == &void_ctype) {
+				right = cast_to(right, ltype);
+				goto OK;
+			}
+			if (rbase == &void_ctype) {
+				left = cast_to(left, rtype);
+				goto OK;
+			}
+		}
+	}
+
+	typediff = type_difference(&ltype->ctype, &rtype->ctype,
+				   target_qualifiers(rtype),
+				   target_qualifiers(ltype));
+	if (!typediff)
+		goto OK;
+
+	expression_error(expr, "incompatible types in comparison expression (%s)", typediff);
+	return NULL;
+
+OK:
+	/* the result is int [6.5.8(6), 6.5.9(3)]*/
+	expr->ctype = &int_ctype;
+	return &int_ctype;
+}
+
+/*
+ * NOTE! The degenerate case of "x ? : y", where we don't
+ * have a true case, this will possibly promote "x" to the
+ * same type as "y", and thus _change_ the conditional
+ * test in the expression. But since promotion is "safe"
+ * for testing, that's OK.
+ */
+static struct symbol *evaluate_conditional_expression(struct expression *expr)
+{
+	struct expression **true;
+	struct symbol *ctype, *ltype, *rtype, *lbase, *rbase;
+	int lclass, rclass;
+	const char * typediff;
+	int qual;
+
+	if (!evaluate_conditional(expr->conditional, 0))
+		return NULL;
+	if (!evaluate_expression(expr->cond_false))
+		return NULL;
+
+	ctype = degenerate(expr->conditional);
+	rtype = degenerate(expr->cond_false);
+
+	true = &expr->conditional;
+	ltype = ctype;
+	if (expr->cond_true) {
+		if (!evaluate_expression(expr->cond_true))
+			return NULL;
+		ltype = degenerate(expr->cond_true);
+		true = &expr->cond_true;
+	}
+
+	expr->flags = (expr->conditional->flags & (*true)->flags &
+			expr->cond_false->flags & ~CEF_CONST_MASK);
+	/*
+	 * A conditional operator yields a particular constant
+	 * expression type only if all of its three subexpressions are
+	 * of that type [6.6(6), 6.6(8)].
+	 * As an extension, relax this restriction by allowing any
+	 * constant expression type for the condition expression.
+	 *
+	 * A conditional operator never yields an address constant
+	 * [6.6(9)].
+	 * However, as an extension, if the condition is any constant
+	 * expression, and the true and false expressions are both
+	 * address constants, mark the result as an address constant.
+	 */
+	if (expr->conditional->flags & (CEF_ACE | CEF_ADDR))
+		expr->flags = (*true)->flags & expr->cond_false->flags & ~CEF_CONST_MASK;
+
+	lclass = classify_type(ltype, &ltype);
+	rclass = classify_type(rtype, &rtype);
+	if (lclass & rclass & TYPE_NUM) {
+		ctype = usual_conversions('?', *true, expr->cond_false,
+					  lclass, rclass, ltype, rtype);
+		*true = cast_to(*true, ctype);
+		expr->cond_false = cast_to(expr->cond_false, ctype);
+		goto out;
+	}
+
+	if ((lclass | rclass) & TYPE_PTR) {
+		int is_null1 = is_null_pointer_constant(*true);
+		int is_null2 = is_null_pointer_constant(expr->cond_false);
+
+		if (is_null1 && is_null2) {
+			*true = cast_to(*true, &ptr_ctype);
+			expr->cond_false = cast_to(expr->cond_false, &ptr_ctype);
+			ctype = &ptr_ctype;
+			goto out;
+		}
+		if (is_null1 && (rclass & TYPE_PTR)) {
+			if (is_null1 == 2)
+				bad_null(*true);
+			*true = cast_to(*true, rtype);
+			ctype = rtype;
+			goto out;
+		}
+		if (is_null2 && (lclass & TYPE_PTR)) {
+			if (is_null2 == 2)
+				bad_null(expr->cond_false);
+			expr->cond_false = cast_to(expr->cond_false, ltype);
+			ctype = ltype;
+			goto out;
+		}
+		if (!(lclass & rclass & TYPE_PTR)) {
+			typediff = "different types";
+			goto Err;
+		}
+		/* OK, it's pointer on pointer */
+		if (ltype->ctype.as != rtype->ctype.as) {
+			typediff = "different address spaces";
+			goto Err;
+		}
+
+		/* need to be lazier here */
+		lbase = examine_pointer_target(ltype);
+		rbase = examine_pointer_target(rtype);
+		qual = target_qualifiers(ltype) | target_qualifiers(rtype);
+
+		if (lbase == &void_ctype) {
+			/* XXX: pointers to function should warn here */
+			ctype = ltype;
+			goto Qual;
+
+		}
+		if (rbase == &void_ctype) {
+			/* XXX: pointers to function should warn here */
+			ctype = rtype;
+			goto Qual;
+		}
+		/* XXX: that should be pointer to composite */
+		ctype = ltype;
+		typediff = type_difference(&ltype->ctype, &rtype->ctype,
+					   qual, qual);
+		if (!typediff)
+			goto Qual;
+		goto Err;
+	}
+
+	/* void on void, struct on same struct, union on same union */
+	if (ltype == rtype) {
+		ctype = ltype;
+		goto out;
+	}
+	typediff = "different base types";
+
+Err:
+	expression_error(expr, "incompatible types in conditional expression (%s)", typediff);
+	/*
+	 * if the condition is constant, the type is in fact known
+	 * so use it, as gcc & clang do.
+	 */
+	switch (expr_truth_value(expr->conditional)) {
+	case 1:	expr->ctype = ltype;
+		break;
+	case 0: expr->ctype = rtype;
+		break;
+	default:
+		break;
+	}
+	return NULL;
+
+out:
+	expr->ctype = ctype;
+	return ctype;
+
+Qual:
+	if (qual & ~ctype->ctype.modifiers) {
+		struct symbol *sym = alloc_symbol(ctype->pos, SYM_PTR);
+		*sym = *ctype;
+		sym->ctype.modifiers |= qual;
+		ctype = sym;
+	}
+	*true = cast_to(*true, ctype);
+	expr->cond_false = cast_to(expr->cond_false, ctype);
+	goto out;
+}
+
+/* FP assignments can not do modulo or bit operations */
+static int compatible_float_op(int op)
+{
+	return	op == SPECIAL_ADD_ASSIGN ||
+		op == SPECIAL_SUB_ASSIGN ||
+		op == SPECIAL_MUL_ASSIGN ||
+		op == SPECIAL_DIV_ASSIGN;
+}
+
+static int evaluate_assign_op(struct expression *expr)
+{
+	struct symbol *target = expr->left->ctype;
+	struct symbol *source = expr->right->ctype;
+	struct symbol *t, *s;
+	int tclass = classify_type(target, &t);
+	int sclass = classify_type(source, &s);
+	int op = expr->op;
+
+	if (tclass & sclass & TYPE_NUM) {
+		if (tclass & TYPE_FLOAT && !compatible_float_op(op)) {
+			expression_error(expr, "invalid assignment");
+			return 0;
+		}
+		if (tclass & TYPE_RESTRICT) {
+			if (!restricted_binop(op, t)) {
+				warning(expr->pos, "bad assignment (%s) to %s",
+					show_special(op), show_typename(t));
+				expr->right = cast_to(expr->right, target);
+				return 0;
+			}
+			/* allowed assignments unfoul */
+			if (sclass & TYPE_FOULED && unfoul(s) == t)
+				goto Cast;
+			if (!restricted_value(expr->right, t))
+				return 1;
+		} else if (!(sclass & TYPE_RESTRICT))
+			goto usual;
+		/* source and target would better be identical restricted */
+		if (t == s)
+			return 1;
+		warning(expr->pos, "invalid assignment: %s", show_special(op));
+		info(expr->pos, "   left side has type %s", show_typename(t));
+		info(expr->pos, "   right side has type %s", show_typename(s));
+		expr->right = cast_to(expr->right, target);
+		return 0;
+	}
+	if (tclass == TYPE_PTR && is_int(sclass)) {
+		if (op == SPECIAL_ADD_ASSIGN || op == SPECIAL_SUB_ASSIGN) {
+			unrestrict(expr->right, sclass, &s);
+			evaluate_ptr_add(expr, s);
+			return 1;
+		}
+		expression_error(expr, "invalid pointer assignment");
+		return 0;
+	}
+
+	expression_error(expr, "invalid assignment");
+	return 0;
+
+usual:
+	target = usual_conversions(op, expr->left, expr->right,
+				tclass, sclass, target, source);
+Cast:
+	expr->right = cast_to(expr->right, target);
+	return 1;
+}
+
+static int whitelist_pointers(struct symbol *t1, struct symbol *t2)
+{
+	if (t1 == t2)
+		return 0;	/* yes, 0 - we don't want a cast_to here */
+	if (t1 == &void_ctype)
+		return 1;
+	if (t2 == &void_ctype)
+		return 1;
+	if (classify_type(t1, &t1) != TYPE_NUM)
+		return 0;
+	if (classify_type(t2, &t2) != TYPE_NUM)
+		return 0;
+	if (t1 == t2)
+		return 1;
+	if (t1->ctype.modifiers & t2->ctype.modifiers & MOD_CHAR)
+		return 1;
+	if ((t1->ctype.modifiers ^ t2->ctype.modifiers) & MOD_SIZE)
+		return 0;
+	return !Wtypesign;
+}
+
+static int check_assignment_types(struct symbol *target, struct expression **rp,
+	const char **typediff)
+{
+	struct symbol *source = degenerate(*rp);
+	struct symbol *t, *s;
+	int tclass = classify_type(target, &t);
+	int sclass = classify_type(source, &s);
+
+	if (tclass & sclass & TYPE_NUM) {
+		if (tclass & TYPE_RESTRICT) {
+			/* allowed assignments unfoul */
+			if (sclass & TYPE_FOULED && unfoul(s) == t)
+				goto Cast;
+			if (!restricted_value(*rp, target))
+				return 1;
+			if (s == t)
+				return 1;
+		} else if (!(sclass & TYPE_RESTRICT))
+			goto Cast;
+                if (t == &bool_ctype) {
+                        if (is_fouled_type(s))
+                                warning((*rp)->pos, "%s degrades to integer",
+                                        show_typename(s->ctype.base_type));
+                        goto Cast;
+                }
+		*typediff = "different base types";
+		return 0;
+	}
+
+	if (tclass == TYPE_PTR) {
+		unsigned long mod1, mod2;
+		struct symbol *b1, *b2;
+		// NULL pointer is always OK
+		int is_null = is_null_pointer_constant(*rp);
+		if (is_null) {
+			if (is_null == 2)
+				bad_null(*rp);
+			goto Cast;
+		}
+		if (!(sclass & TYPE_PTR)) {
+			*typediff = "different base types";
+			return 0;
+		}
+		b1 = examine_pointer_target(t);
+		b2 = examine_pointer_target(s);
+		mod1 = target_qualifiers(t);
+		mod2 = target_qualifiers(s);
+		if (whitelist_pointers(b1, b2)) {
+			/*
+			 * assignments to/from void * are OK, provided that
+			 * we do not remove qualifiers from pointed to [C]
+			 * or mix address spaces [sparse].
+			 */
+			if (t->ctype.as != s->ctype.as) {
+				*typediff = "different address spaces";
+				return 0;
+			}
+			/*
+			 * If this is a function pointer assignment, it is
+			 * actually fine to assign a pointer to const data to
+			 * it, as a function pointer points to const data
+			 * implicitly, i.e., dereferencing it does not produce
+			 * an lvalue.
+			 */
+			if (b1->type == SYM_FN)
+				mod1 |= MOD_CONST;
+			if (mod2 & ~mod1) {
+				*typediff = "different modifiers";
+				return 0;
+			}
+			goto Cast;
+		}
+		/* It's OK if the target is more volatile or const than the source */
+		*typediff = type_difference(&t->ctype, &s->ctype, 0, mod1);
+		if (*typediff)
+			return 0;
+		return 1;
+	}
+
+	if ((tclass & TYPE_COMPOUND) && s == t)
+		return 1;
+
+	if (tclass & TYPE_NUM) {
+		/* XXX: need to turn into comparison with NULL */
+		if (t == &bool_ctype && (sclass & TYPE_PTR))
+			goto Cast;
+		*typediff = "different base types";
+		return 0;
+	}
+	*typediff = "invalid types";
+	return 0;
+
+Cast:
+	*rp = cast_to(*rp, target);
+	return 1;
+}
+
+static int compatible_assignment_types(struct expression *expr, struct symbol *target,
+	struct expression **rp, const char *where)
+{
+	const char *typediff;
+	struct symbol *source = degenerate(*rp);
+
+	if (!check_assignment_types(target, rp, &typediff)) {
+		warning(expr->pos, "incorrect type in %s (%s)", where, typediff);
+		info(expr->pos, "   expected %s", show_typename(target));
+		info(expr->pos, "   got %s", show_typename(source));
+		*rp = cast_to(*rp, target);
+		return 0;
+	}
+
+	return 1;
+}
+
+static int compatible_transparent_union(struct symbol *target,
+	struct expression **rp)
+{
+	struct symbol *t, *member;
+	classify_type(target, &t);
+	if (t->type != SYM_UNION || !t->transparent_union)
+		return 0;
+
+	FOR_EACH_PTR(t->symbol_list, member) {
+		const char *typediff;
+		if (check_assignment_types(member, rp, &typediff))
+			return 1;
+	} END_FOR_EACH_PTR(member);
+
+	return 0;
+}
+
+static int compatible_argument_type(struct expression *expr, struct symbol *target,
+	struct expression **rp, const char *where)
+{
+	if (compatible_transparent_union(target, rp))
+		return 1;
+
+	return compatible_assignment_types(expr, target, rp, where);
+}
+
+static void mark_assigned(struct expression *expr)
+{
+	struct symbol *sym;
+
+	if (!expr)
+		return;
+	switch (expr->type) {
+	case EXPR_SYMBOL:
+		sym = expr->symbol;
+		if (!sym)
+			return;
+		if (sym->type != SYM_NODE)
+			return;
+		sym->ctype.modifiers |= MOD_ASSIGNED;
+		return;
+
+	case EXPR_BINOP:
+		mark_assigned(expr->left);
+		mark_assigned(expr->right);
+		return;
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+		mark_assigned(expr->cast_expression);
+		return;
+	case EXPR_SLICE:
+		mark_assigned(expr->base);
+		return;
+	default:
+		/* Hmm? */
+		return;
+	}
+}
+
+static void evaluate_assign_to(struct expression *left, struct symbol *type)
+{
+	if (type->ctype.modifiers & MOD_CONST)
+		expression_error(left, "assignment to const expression");
+
+	/* We know left is an lvalue, so it's a "preop-*" */
+	mark_assigned(left->unop);
+}
+
+static struct symbol *evaluate_assignment(struct expression *expr)
+{
+	struct expression *left = expr->left;
+	struct expression *where = expr;
+	struct symbol *ltype;
+
+	if (!lvalue_expression(left)) {
+		expression_error(expr, "not an lvalue");
+		return NULL;
+	}
+
+	ltype = left->ctype;
+
+	if (expr->op != '=') {
+		if (!evaluate_assign_op(expr))
+			return NULL;
+	} else {
+		if (!compatible_assignment_types(where, ltype, &expr->right, "assignment"))
+			return NULL;
+	}
+
+	evaluate_assign_to(left, ltype);
+
+	expr->ctype = ltype;
+	return ltype;
+}
+
+static void examine_fn_arguments(struct symbol *fn)
+{
+	struct symbol *s;
+
+	FOR_EACH_PTR(fn->arguments, s) {
+		struct symbol *arg = evaluate_symbol(s);
+		/* Array/function arguments silently degenerate into pointers */
+		if (arg) {
+			struct symbol *ptr;
+			switch(arg->type) {
+			case SYM_ARRAY:
+			case SYM_FN:
+				ptr = alloc_symbol(s->pos, SYM_PTR);
+				if (arg->type == SYM_ARRAY)
+					ptr->ctype = arg->ctype;
+				else
+					ptr->ctype.base_type = arg;
+				ptr->ctype.as |= s->ctype.as;
+				ptr->ctype.modifiers |= s->ctype.modifiers & MOD_PTRINHERIT;
+
+				s->ctype.base_type = ptr;
+				s->ctype.as = 0;
+				s->ctype.modifiers &= ~MOD_PTRINHERIT;
+				s->bit_size = 0;
+				s->examined = 0;
+				examine_symbol_type(s);
+				break;
+			default:
+				/* nothing */
+				break;
+			}
+		}
+	} END_FOR_EACH_PTR(s);
+}
+
+static struct symbol *convert_to_as_mod(struct symbol *sym, int as, int mod)
+{
+	/* Take the modifiers of the pointer, and apply them to the member */
+	mod |= sym->ctype.modifiers;
+	if (sym->ctype.as != as || sym->ctype.modifiers != mod) {
+		struct symbol *newsym = alloc_symbol(sym->pos, SYM_NODE);
+		*newsym = *sym;
+		newsym->ctype.as = as;
+		newsym->ctype.modifiers = mod;
+		sym = newsym;
+	}
+	return sym;
+}
+
+static struct symbol *create_pointer(struct expression *expr, struct symbol *sym, int degenerate)
+{
+	struct symbol *node = alloc_symbol(expr->pos, SYM_NODE);
+	struct symbol *ptr = alloc_symbol(expr->pos, SYM_PTR);
+
+	node->ctype.base_type = ptr;
+	ptr->bit_size = bits_in_pointer;
+	ptr->ctype.alignment = pointer_alignment;
+
+	node->bit_size = bits_in_pointer;
+	node->ctype.alignment = pointer_alignment;
+
+	access_symbol(sym);
+	if (sym->ctype.modifiers & MOD_REGISTER) {
+		warning(expr->pos, "taking address of 'register' variable '%s'", show_ident(sym->ident));
+		sym->ctype.modifiers &= ~MOD_REGISTER;
+	}
+	if (sym->type == SYM_NODE) {
+		ptr->ctype.as |= sym->ctype.as;
+		ptr->ctype.modifiers |= sym->ctype.modifiers & MOD_PTRINHERIT;
+		sym = sym->ctype.base_type;
+	}
+	if (degenerate && sym->type == SYM_ARRAY) {
+		ptr->ctype.as |= sym->ctype.as;
+		ptr->ctype.modifiers |= sym->ctype.modifiers & MOD_PTRINHERIT;
+		sym = sym->ctype.base_type;
+	}
+	ptr->ctype.base_type = sym;
+
+	return node;
+}
+
+/* Arrays degenerate into pointers on pointer arithmetic */
+static struct symbol *degenerate(struct expression *expr)
+{
+	struct symbol *ctype, *base;
+
+	if (!expr)
+		return NULL;
+	ctype = expr->ctype;
+	if (!ctype)
+		return NULL;
+	base = examine_symbol_type(ctype);
+	if (ctype->type == SYM_NODE)
+		base = ctype->ctype.base_type;
+	/*
+	 * Arrays degenerate into pointers to the entries, while
+	 * functions degenerate into pointers to themselves.
+	 * If array was part of non-lvalue compound, we create a copy
+	 * of that compound first and then act as if we were dealing with
+	 * the corresponding field in there.
+	 */
+	switch (base->type) {
+	case SYM_ARRAY:
+		if (expr->type == EXPR_SLICE) {
+			struct symbol *a = alloc_symbol(expr->pos, SYM_NODE);
+			struct expression *e0, *e1, *e2, *e3, *e4;
+
+			a->ctype.base_type = expr->base->ctype;
+			a->bit_size = expr->base->ctype->bit_size;
+			a->array_size = expr->base->ctype->array_size;
+
+			e0 = alloc_expression(expr->pos, EXPR_SYMBOL);
+			e0->symbol = a;
+			e0->ctype = &lazy_ptr_ctype;
+
+			e1 = alloc_expression(expr->pos, EXPR_PREOP);
+			e1->unop = e0;
+			e1->op = '*';
+			e1->ctype = expr->base->ctype;	/* XXX */
+
+			e2 = alloc_expression(expr->pos, EXPR_ASSIGNMENT);
+			e2->left = e1;
+			e2->right = expr->base;
+			e2->op = '=';
+			e2->ctype = expr->base->ctype;
+
+			if (expr->r_bitpos) {
+				e3 = alloc_expression(expr->pos, EXPR_BINOP);
+				e3->op = '+';
+				e3->left = e0;
+				e3->right = alloc_const_expression(expr->pos,
+							bits_to_bytes(expr->r_bitpos));
+				e3->ctype = &lazy_ptr_ctype;
+			} else {
+				e3 = e0;
+			}
+
+			e4 = alloc_expression(expr->pos, EXPR_COMMA);
+			e4->left = e2;
+			e4->right = e3;
+			e4->ctype = &lazy_ptr_ctype;
+
+			expr->unop = e4;
+			expr->type = EXPR_PREOP;
+			expr->op = '*';
+		}
+	case SYM_FN:
+		if (expr->op != '*' || expr->type != EXPR_PREOP) {
+			expression_error(expr, "strange non-value function or array");
+			return &bad_ctype;
+		}
+		*expr = *expr->unop;
+		ctype = create_pointer(expr, ctype, 1);
+		expr->ctype = ctype;
+	default:
+		/* nothing */;
+	}
+	return ctype;
+}
+
+static struct symbol *evaluate_addressof(struct expression *expr)
+{
+	struct expression *op = expr->unop;
+	struct symbol *ctype;
+
+	if (op->op != '*' || op->type != EXPR_PREOP) {
+		expression_error(expr, "not addressable");
+		return NULL;
+	}
+	ctype = op->ctype;
+	*expr = *op->unop;
+
+	if (expr->type == EXPR_SYMBOL) {
+		struct symbol *sym = expr->symbol;
+		sym->ctype.modifiers |= MOD_ADDRESSABLE;
+	}
+
+	/*
+	 * symbol expression evaluation is lazy about the type
+	 * of the sub-expression, so we may have to generate
+	 * the type here if so..
+	 */
+	if (expr->ctype == &lazy_ptr_ctype) {
+		ctype = create_pointer(expr, ctype, 0);
+		expr->ctype = ctype;
+	}
+	return expr->ctype;
+}
+
+
+static struct symbol *evaluate_dereference(struct expression *expr)
+{
+	struct expression *op = expr->unop;
+	struct symbol *ctype = op->ctype, *node, *target;
+
+	/* Simplify: *&(expr) => (expr) */
+	if (op->type == EXPR_PREOP && op->op == '&') {
+		*expr = *op->unop;
+		expr->flags = CEF_NONE;
+		return expr->ctype;
+	}
+
+	examine_symbol_type(ctype);
+
+	/* Dereferencing a node drops all the node information. */
+	if (ctype->type == SYM_NODE)
+		ctype = ctype->ctype.base_type;
+
+	node = alloc_symbol(expr->pos, SYM_NODE);
+	target = ctype->ctype.base_type;
+
+	switch (ctype->type) {
+	default:
+		expression_error(expr, "cannot dereference this type");
+		return NULL;
+	case SYM_PTR:
+		node->ctype.modifiers = target->ctype.modifiers & MOD_SPECIFIER;
+		merge_type(node, ctype);
+		break;
+
+	case SYM_ARRAY:
+		if (!lvalue_expression(op)) {
+			expression_error(op, "non-lvalue array??");
+			return NULL;
+		}
+
+		/* Do the implied "addressof" on the array */
+		*op = *op->unop;
+
+		/*
+		 * When an array is dereferenced, we need to pick
+		 * up the attributes of the original node too..
+		 */
+		merge_type(node, op->ctype);
+		merge_type(node, ctype);
+		break;
+	}
+
+	node->bit_size = target->bit_size;
+	node->array_size = target->array_size;
+
+	expr->ctype = node;
+	return node;
+}
+
+/*
+ * Unary post-ops: x++ and x--
+ */
+static struct symbol *evaluate_postop(struct expression *expr)
+{
+	struct expression *op = expr->unop;
+	struct symbol *ctype = op->ctype;
+	int class = classify_type(ctype, &ctype);
+	int multiply = 0;
+
+	if (!class || class & TYPE_COMPOUND) {
+		expression_error(expr, "need scalar for ++/--");
+		return NULL;
+	}
+	if (!lvalue_expression(expr->unop)) {
+		expression_error(expr, "need lvalue expression for ++/--");
+		return NULL;
+	}
+
+	if ((class & TYPE_RESTRICT) && restricted_unop(expr->op, &ctype))
+		unrestrict(expr, class, &ctype);
+
+	if (class & TYPE_NUM) {
+		multiply = 1;
+	} else if (class == TYPE_PTR) {
+		struct symbol *target = examine_pointer_target(ctype);
+		if (!is_function(target))
+			multiply = bits_to_bytes(target->bit_size);
+	}
+
+	if (multiply) {
+		evaluate_assign_to(op, op->ctype);
+		expr->op_value = multiply;
+		expr->ctype = ctype;
+		return ctype;
+	}
+
+	expression_error(expr, "bad argument type for ++/--");
+	return NULL;
+}
+
+static struct symbol *evaluate_sign(struct expression *expr)
+{
+	struct symbol *ctype = expr->unop->ctype;
+	int class = classify_type(ctype, &ctype);
+	unsigned char flags = expr->unop->flags & ~CEF_CONST_MASK;
+
+	/* should be an arithmetic type */
+	if (!(class & TYPE_NUM))
+		return bad_expr_type(expr);
+	if (class & TYPE_RESTRICT)
+		goto Restr;
+Normal:
+	if (!(class & TYPE_FLOAT)) {
+		ctype = integer_promotion(ctype);
+		expr->unop = cast_to(expr->unop, ctype);
+	} else if (expr->op != '~') {
+		/* no conversions needed */
+	} else {
+		return bad_expr_type(expr);
+	}
+	if (expr->op == '+')
+		*expr = *expr->unop;
+	expr->flags = flags;
+	expr->ctype = ctype;
+	return ctype;
+Restr:
+	if (restricted_unop(expr->op, &ctype))
+		unrestrict(expr, class, &ctype);
+	goto Normal;
+}
+
+static struct symbol *evaluate_preop(struct expression *expr)
+{
+	struct symbol *ctype = expr->unop->ctype;
+
+	switch (expr->op) {
+	case '(':
+		*expr = *expr->unop;
+		return ctype;
+
+	case '+':
+	case '-':
+	case '~':
+		return evaluate_sign(expr);
+
+	case '*':
+		return evaluate_dereference(expr);
+
+	case '&':
+		return evaluate_addressof(expr);
+
+	case SPECIAL_INCREMENT:
+	case SPECIAL_DECREMENT:
+		/*
+		 * From a type evaluation standpoint the preops are
+		 * the same as the postops
+		 */
+		return evaluate_postop(expr);
+
+	case '!':
+		expr->flags = expr->unop->flags & ~CEF_CONST_MASK;
+		/*
+		 * A logical negation never yields an address constant
+		 * [6.6(9)].
+		 */
+		expr->flags &= ~CEF_ADDR;
+
+		if (is_safe_type(ctype))
+			warning(expr->pos, "testing a 'safe expression'");
+		if (is_float_type(ctype)) {
+			struct expression *arg = expr->unop;
+			expr->type = EXPR_COMPARE;
+			expr->op = SPECIAL_EQUAL;
+			expr->left = arg;
+			expr->right = alloc_expression(expr->pos, EXPR_FVALUE);
+			expr->right->ctype = ctype;
+			expr->right->fvalue = 0;
+		} else if (is_fouled_type(ctype)) {
+			warning(expr->pos, "%s degrades to integer",
+				show_typename(ctype->ctype.base_type));
+		}
+		/* the result is int [6.5.3.3(5)]*/
+		ctype = &int_ctype;
+		break;
+
+	default:
+		break;
+	}
+	expr->ctype = ctype;
+	return ctype;
+}
+
+static struct symbol *find_identifier(struct ident *ident, struct symbol_list *_list, int *offset)
+{
+	struct ptr_list *head = (struct ptr_list *)_list;
+	struct ptr_list *list = head;
+
+	if (!head)
+		return NULL;
+	do {
+		int i;
+		for (i = 0; i < list->nr; i++) {
+			struct symbol *sym = (struct symbol *) list->list[i];
+			if (sym->ident) {
+				if (sym->ident != ident)
+					continue;
+				*offset = sym->offset;
+				return sym;
+			} else {
+				struct symbol *ctype = sym->ctype.base_type;
+				struct symbol *sub;
+				if (!ctype)
+					continue;
+				if (ctype->type != SYM_UNION && ctype->type != SYM_STRUCT)
+					continue;
+				sub = find_identifier(ident, ctype->symbol_list, offset);
+				if (!sub)
+					continue;
+				*offset += sym->offset;
+				return sub;
+			}	
+		}
+	} while ((list = list->next) != head);
+	return NULL;
+}
+
+static struct expression *evaluate_offset(struct expression *expr, unsigned long offset)
+{
+	struct expression *add;
+
+	/*
+	 * Create a new add-expression
+	 *
+	 * NOTE! Even if we just add zero, we need a new node
+	 * for the member pointer, since it has a different
+	 * type than the original pointer. We could make that
+	 * be just a cast, but the fact is, a node is a node,
+	 * so we might as well just do the "add zero" here.
+	 */
+	add = alloc_expression(expr->pos, EXPR_BINOP);
+	add->op = '+';
+	add->left = expr;
+	add->right = alloc_expression(expr->pos, EXPR_VALUE);
+	add->right->ctype = &int_ctype;
+	add->right->value = offset;
+
+	/*
+	 * The ctype of the pointer will be lazily evaluated if
+	 * we ever take the address of this member dereference..
+	 */
+	add->ctype = &lazy_ptr_ctype;
+	/*
+	 * The resulting address of a member access through an address
+	 * constant is an address constant again [6.6(9)].
+	 */
+	add->flags = expr->flags;
+
+	return add;
+}
+
+/* structure/union dereference */
+static struct symbol *evaluate_member_dereference(struct expression *expr)
+{
+	int offset;
+	struct symbol *ctype, *member;
+	struct expression *deref = expr->deref, *add;
+	struct ident *ident = expr->member;
+	unsigned int mod;
+	int address_space;
+
+	if (!evaluate_expression(deref))
+		return NULL;
+	if (!ident) {
+		expression_error(expr, "bad member name");
+		return NULL;
+	}
+
+	ctype = deref->ctype;
+	examine_symbol_type(ctype);
+	address_space = ctype->ctype.as;
+	mod = ctype->ctype.modifiers;
+	if (ctype->type == SYM_NODE) {
+		ctype = ctype->ctype.base_type;
+		address_space |= ctype->ctype.as;
+		mod |= ctype->ctype.modifiers;
+	}
+	if (!ctype || (ctype->type != SYM_STRUCT && ctype->type != SYM_UNION)) {
+		expression_error(expr, "expected structure or union");
+		return NULL;
+	}
+	offset = 0;
+	member = find_identifier(ident, ctype->symbol_list, &offset);
+	if (!member) {
+		const char *type = ctype->type == SYM_STRUCT ? "struct" : "union";
+		const char *name = "<unnamed>";
+		int namelen = 9;
+		if (ctype->ident) {
+			name = ctype->ident->name;
+			namelen = ctype->ident->len;
+		}
+		if (ctype->symbol_list)
+			expression_error(expr, "no member '%s' in %s %.*s",
+				show_ident(ident), type, namelen, name);
+		else
+			expression_error(expr, "using member '%s' in "
+				"incomplete %s %.*s", show_ident(ident),
+				type, namelen, name);
+		return NULL;
+	}
+
+	/*
+	 * The member needs to take on the address space and modifiers of
+	 * the "parent" type.
+	 */
+	member = convert_to_as_mod(member, address_space, mod);
+	ctype = get_base_type(member);
+
+	if (!lvalue_expression(deref)) {
+		if (deref->type != EXPR_SLICE) {
+			expr->base = deref;
+			expr->r_bitpos = 0;
+		} else {
+			expr->base = deref->base;
+			expr->r_bitpos = deref->r_bitpos;
+		}
+		expr->r_bitpos += bytes_to_bits(offset);
+		expr->type = EXPR_SLICE;
+		expr->r_nrbits = member->bit_size;
+		expr->r_bitpos += member->bit_offset;
+		expr->ctype = member;
+		return member;
+	}
+
+	deref = deref->unop;
+	expr->deref = deref;
+
+	add = evaluate_offset(deref, offset);
+	expr->type = EXPR_PREOP;
+	expr->op = '*';
+	expr->unop = add;
+
+	expr->ctype = member;
+	return member;
+}
+
+static int is_promoted(struct expression *expr)
+{
+	while (1) {
+		switch (expr->type) {
+		case EXPR_BINOP:
+		case EXPR_SELECT:
+		case EXPR_CONDITIONAL:
+			return 1;
+		case EXPR_COMMA:
+			expr = expr->right;
+			continue;
+		case EXPR_PREOP:
+			switch (expr->op) {
+			case '(':
+				expr = expr->unop;
+				continue;
+			case '+':
+			case '-':
+			case '~':
+				return 1;
+			default:
+				return 0;
+			}
+		default:
+			return 0;
+		}
+	}
+}
+
+
+static struct symbol *evaluate_cast(struct expression *);
+
+static struct symbol *evaluate_type_information(struct expression *expr)
+{
+	struct symbol *sym = expr->cast_type;
+	if (!sym) {
+		sym = evaluate_expression(expr->cast_expression);
+		if (!sym)
+			return NULL;
+		/*
+		 * Expressions of restricted types will possibly get
+		 * promoted - check that here
+		 */
+		if (is_restricted_type(sym)) {
+			if (sym->bit_size < bits_in_int && is_promoted(expr))
+				sym = &int_ctype;
+		} else if (is_fouled_type(sym)) {
+			sym = &int_ctype;
+		}
+	}
+	examine_symbol_type(sym);
+	if (is_bitfield_type(sym)) {
+		expression_error(expr, "trying to examine bitfield type");
+		return NULL;
+	}
+	return sym;
+}
+
+static struct symbol *evaluate_sizeof(struct expression *expr)
+{
+	struct symbol *type;
+	int size;
+
+	type = evaluate_type_information(expr);
+	if (!type)
+		return NULL;
+
+	size = type->bit_size;
+
+	if (size < 0 && is_void_type(type)) {
+		if (Wpointer_arith)
+			warning(expr->pos, "expression using sizeof(void)");
+		size = bits_in_char;
+	}
+
+	if (size == 1 && is_bool_type(type)) {
+		if (Wsizeof_bool)
+			warning(expr->pos, "expression using sizeof bool");
+		size = bits_in_char;
+	}
+
+	if (is_function(type->ctype.base_type)) {
+		if (Wpointer_arith)
+			warning(expr->pos, "expression using sizeof on a function");
+		size = bits_in_char;
+	}
+
+	if ((size < 0) || (size & (bits_in_char - 1)))
+		expression_error(expr, "cannot size expression");
+
+	expr->type = EXPR_VALUE;
+	expr->value = bits_to_bytes(size);
+	expr->taint = 0;
+	expr->ctype = size_t_ctype;
+	return size_t_ctype;
+}
+
+static struct symbol *evaluate_ptrsizeof(struct expression *expr)
+{
+	struct symbol *type;
+	int size;
+
+	type = evaluate_type_information(expr);
+	if (!type)
+		return NULL;
+
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	if (!type)
+		return NULL;
+	switch (type->type) {
+	case SYM_ARRAY:
+		break;
+	case SYM_PTR:
+		type = get_base_type(type);
+		if (type)
+			break;
+	default:
+		expression_error(expr, "expected pointer expression");
+		return NULL;
+	}
+	size = type->bit_size;
+	if (size & (bits_in_char-1))
+		size = 0;
+	expr->type = EXPR_VALUE;
+	expr->value = bits_to_bytes(size);
+	expr->taint = 0;
+	expr->ctype = size_t_ctype;
+	return size_t_ctype;
+}
+
+static struct symbol *evaluate_alignof(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = evaluate_type_information(expr);
+	if (!type)
+		return NULL;
+
+	expr->type = EXPR_VALUE;
+	expr->value = type->ctype.alignment;
+	expr->taint = 0;
+	expr->ctype = size_t_ctype;
+	return size_t_ctype;
+}
+
+static int evaluate_arguments(struct symbol *fn, struct expression_list *head)
+{
+	struct expression *expr;
+	struct symbol_list *argument_types = fn->arguments;
+	struct symbol *argtype;
+	int i = 1;
+
+	PREPARE_PTR_LIST(argument_types, argtype);
+	FOR_EACH_PTR (head, expr) {
+		struct expression **p = THIS_ADDRESS(expr);
+		struct symbol *ctype, *target;
+		ctype = evaluate_expression(expr);
+
+		if (!ctype)
+			return 0;
+
+		target = argtype;
+		if (!target) {
+			struct symbol *type;
+			int class = classify_type(ctype, &type);
+			if (is_int(class)) {
+				*p = cast_to(expr, integer_promotion(type));
+			} else if (class & TYPE_FLOAT) {
+				unsigned long mod = type->ctype.modifiers;
+				if (!(mod & (MOD_LONG_ALL)))
+					*p = cast_to(expr, &double_ctype);
+			} else if (class & TYPE_PTR) {
+				if (expr->ctype == &null_ctype)
+					*p = cast_to(expr, &ptr_ctype);
+				else
+					degenerate(expr);
+			}
+		} else if (!target->forced_arg){
+			static char where[30];
+			examine_symbol_type(target);
+			sprintf(where, "argument %d", i);
+			compatible_argument_type(expr, target, p, where);
+		}
+
+		i++;
+		NEXT_PTR_LIST(argtype);
+	} END_FOR_EACH_PTR(expr);
+	FINISH_PTR_LIST(argtype);
+	return 1;
+}
+
+static void convert_index(struct expression *e)
+{
+	struct expression *child = e->idx_expression;
+	unsigned from = e->idx_from;
+	unsigned to = e->idx_to + 1;
+	e->type = EXPR_POS;
+	e->init_offset = from * bits_to_bytes(e->ctype->bit_size);
+	e->init_nr = to - from;
+	e->init_expr = child;
+}
+
+static void convert_ident(struct expression *e)
+{
+	struct expression *child = e->ident_expression;
+	int offset = e->offset;
+
+	e->type = EXPR_POS;
+	e->init_offset = offset;
+	e->init_nr = 1;
+	e->init_expr = child;
+}
+
+static void convert_designators(struct expression *e)
+{
+	while (e) {
+		if (e->type == EXPR_INDEX)
+			convert_index(e);
+		else if (e->type == EXPR_IDENTIFIER)
+			convert_ident(e);
+		else
+			break;
+		e = e->init_expr;
+	}
+}
+
+static void excess(struct expression *e, const char *s)
+{
+	warning(e->pos, "excessive elements in %s initializer", s);
+}
+
+/*
+ * implicit designator for the first element
+ */
+static struct expression *first_subobject(struct symbol *ctype, int class,
+					  struct expression **v)
+{
+	struct expression *e = *v, *new;
+
+	if (ctype->type == SYM_NODE)
+		ctype = ctype->ctype.base_type;
+
+	if (class & TYPE_PTR) { /* array */
+		if (!ctype->bit_size)
+			return NULL;
+		new = alloc_expression(e->pos, EXPR_INDEX);
+		new->idx_expression = e;
+		new->ctype = ctype->ctype.base_type;
+	} else  {
+		struct symbol *field, *p;
+		PREPARE_PTR_LIST(ctype->symbol_list, p);
+		while (p && !p->ident && is_bitfield_type(p))
+			NEXT_PTR_LIST(p);
+		field = p;
+		FINISH_PTR_LIST(p);
+		if (!field)
+			return NULL;
+		new = alloc_expression(e->pos, EXPR_IDENTIFIER);
+		new->ident_expression = e;
+		new->field = new->ctype = field;
+		new->offset = field->offset;
+	}
+	*v = new;
+	return new;
+}
+
+/*
+ * sanity-check explicit designators; return the innermost one or NULL
+ * in case of error.  Assign types.
+ */
+static struct expression *check_designators(struct expression *e,
+					    struct symbol *ctype)
+{
+	struct expression *last = NULL;
+	const char *err;
+	while (1) {
+		if (ctype->type == SYM_NODE)
+			ctype = ctype->ctype.base_type;
+		if (e->type == EXPR_INDEX) {
+			struct symbol *type;
+			if (ctype->type != SYM_ARRAY) {
+				err = "array index in non-array";
+				break;
+			}
+			type = ctype->ctype.base_type;
+			if (ctype->bit_size >= 0 && type->bit_size >= 0) {
+				unsigned offset = array_element_offset(type->bit_size, e->idx_to);
+				if (offset >= ctype->bit_size) {
+					err = "index out of bounds in";
+					break;
+				}
+			}
+			e->ctype = ctype = type;
+			ctype = type;
+			last = e;
+			if (!e->idx_expression) {
+				err = "invalid";
+				break;
+			}
+			e = e->idx_expression;
+		} else if (e->type == EXPR_IDENTIFIER) {
+			int offset = 0;
+			if (ctype->type != SYM_STRUCT && ctype->type != SYM_UNION) {
+				err = "field name not in struct or union";
+				break;
+			}
+			ctype = find_identifier(e->expr_ident, ctype->symbol_list, &offset);
+			if (!ctype) {
+				err = "unknown field name in";
+				break;
+			}
+			e->offset = offset;
+			e->field = e->ctype = ctype;
+			last = e;
+			if (!e->ident_expression) {
+				err = "invalid";
+				break;
+			}
+			e = e->ident_expression;
+		} else if (e->type == EXPR_POS) {
+			err = "internal front-end error: EXPR_POS in";
+			break;
+		} else
+			return last;
+	}
+	expression_error(e, "%s initializer", err);
+	return NULL;
+}
+
+/*
+ * choose the next subobject to initialize.
+ *
+ * Get designators for next element, switch old ones to EXPR_POS.
+ * Return the resulting expression or NULL if we'd run out of subobjects.
+ * The innermost designator is returned in *v.  Designators in old
+ * are assumed to be already sanity-checked.
+ */
+static struct expression *next_designators(struct expression *old,
+			     struct symbol *ctype,
+			     struct expression *e, struct expression **v)
+{
+	struct expression *new = NULL;
+
+	if (!old)
+		return NULL;
+	if (old->type == EXPR_INDEX) {
+		struct expression *copy;
+		unsigned n;
+
+		copy = next_designators(old->idx_expression,
+					old->ctype, e, v);
+		if (!copy) {
+			n = old->idx_to + 1;
+			if (array_element_offset(old->ctype->bit_size, n) == ctype->bit_size) {
+				convert_index(old);
+				return NULL;
+			}
+			copy = e;
+			*v = new = alloc_expression(e->pos, EXPR_INDEX);
+		} else {
+			n = old->idx_to;
+			new = alloc_expression(e->pos, EXPR_INDEX);
+		}
+
+		new->idx_from = new->idx_to = n;
+		new->idx_expression = copy;
+		new->ctype = old->ctype;
+		convert_index(old);
+	} else if (old->type == EXPR_IDENTIFIER) {
+		struct expression *copy;
+		struct symbol *field;
+		int offset = 0;
+
+		copy = next_designators(old->ident_expression,
+					old->ctype, e, v);
+		if (!copy) {
+			field = old->field->next_subobject;
+			if (!field) {
+				convert_ident(old);
+				return NULL;
+			}
+			copy = e;
+			*v = new = alloc_expression(e->pos, EXPR_IDENTIFIER);
+			/*
+			 * We can't necessarily trust "field->offset",
+			 * because the field might be in an anonymous
+			 * union, and the field offset is then the offset
+			 * within that union.
+			 *
+			 * The "old->offset - old->field->offset"
+			 * would be the offset of such an anonymous
+			 * union.
+			 */
+			offset = old->offset - old->field->offset;
+		} else {
+			field = old->field;
+			new = alloc_expression(e->pos, EXPR_IDENTIFIER);
+		}
+
+		new->field = field;
+		new->expr_ident = field->ident;
+		new->ident_expression = copy;
+		new->ctype = field;
+		new->offset = field->offset + offset;
+		convert_ident(old);
+	}
+	return new;
+}
+
+static int handle_initializer(struct expression **ep, int nested,
+		int class, struct symbol *ctype, unsigned long mods);
+
+/*
+ * deal with traversing subobjects [6.7.8(17,18,20)]
+ */
+static void handle_list_initializer(struct expression *expr,
+		int class, struct symbol *ctype, unsigned long mods)
+{
+	struct expression *e, *last = NULL, *top = NULL, *next;
+	int jumped = 0;
+
+	FOR_EACH_PTR(expr->expr_list, e) {
+		struct expression **v;
+		struct symbol *type;
+		int lclass;
+
+		if (e->type != EXPR_INDEX && e->type != EXPR_IDENTIFIER) {
+			struct symbol *struct_sym;
+			if (!top) {
+				top = e;
+				last = first_subobject(ctype, class, &top);
+			} else {
+				last = next_designators(last, ctype, e, &top);
+			}
+			if (!last) {
+				excess(e, class & TYPE_PTR ? "array" :
+							"struct or union");
+				DELETE_CURRENT_PTR(e);
+				continue;
+			}
+			struct_sym = ctype->type == SYM_NODE ? ctype->ctype.base_type : ctype;
+			if (Wdesignated_init && struct_sym->designated_init)
+				warning(e->pos, "%s%.*s%spositional init of field in %s %s, declared with attribute designated_init",
+					ctype->ident ? "in initializer for " : "",
+					ctype->ident ? ctype->ident->len : 0,
+					ctype->ident ? ctype->ident->name : "",
+					ctype->ident ? ": " : "",
+					get_type_name(struct_sym->type),
+					show_ident(struct_sym->ident));
+			if (jumped) {
+				warning(e->pos, "advancing past deep designator");
+				jumped = 0;
+			}
+			REPLACE_CURRENT_PTR(e, last);
+		} else {
+			next = check_designators(e, ctype);
+			if (!next) {
+				DELETE_CURRENT_PTR(e);
+				continue;
+			}
+			top = next;
+			/* deeper than one designator? */
+			jumped = top != e;
+			convert_designators(last);
+			last = e;
+		}
+
+found:
+		lclass = classify_type(top->ctype, &type);
+		if (top->type == EXPR_INDEX)
+			v = &top->idx_expression;
+		else
+			v = &top->ident_expression;
+
+		mods |= ctype->ctype.modifiers & MOD_STORAGE;
+		if (handle_initializer(v, 1, lclass, top->ctype, mods))
+			continue;
+
+		if (!(lclass & TYPE_COMPOUND)) {
+			warning(e->pos, "bogus scalar initializer");
+			DELETE_CURRENT_PTR(e);
+			continue;
+		}
+
+		next = first_subobject(type, lclass, v);
+		if (next) {
+			warning(e->pos, "missing braces around initializer");
+			top = next;
+			goto found;
+		}
+
+		DELETE_CURRENT_PTR(e);
+		excess(e, lclass & TYPE_PTR ? "array" : "struct or union");
+
+	} END_FOR_EACH_PTR(e);
+
+	convert_designators(last);
+	expr->ctype = ctype;
+}
+
+static int is_string_literal(struct expression **v)
+{
+	struct expression *e = *v;
+	while (e && e->type == EXPR_PREOP && e->op == '(')
+		e = e->unop;
+	if (!e || e->type != EXPR_STRING)
+		return 0;
+	if (e != *v && Wparen_string)
+		warning(e->pos,
+			"array initialized from parenthesized string constant");
+	*v = e;
+	return 1;
+}
+
+/*
+ * We want a normal expression, possibly in one layer of braces.  Warn
+ * if the latter happens inside a list (it's legal, but likely to be
+ * an effect of screwup).  In case of anything not legal, we are definitely
+ * having an effect of screwup, so just fail and let the caller warn.
+ */
+static struct expression *handle_scalar(struct expression *e, int nested)
+{
+	struct expression *v = NULL, *p;
+	int count = 0;
+
+	/* normal case */
+	if (e->type != EXPR_INITIALIZER)
+		return e;
+
+	FOR_EACH_PTR(e->expr_list, p) {
+		if (!v)
+			v = p;
+		count++;
+	} END_FOR_EACH_PTR(p);
+	if (count != 1)
+		return NULL;
+	switch(v->type) {
+	case EXPR_INITIALIZER:
+	case EXPR_INDEX:
+	case EXPR_IDENTIFIER:
+		return NULL;
+	default:
+		break;
+	}
+	if (nested)
+		warning(e->pos, "braces around scalar initializer");
+	return v;
+}
+
+/*
+ * deal with the cases that don't care about subobjects:
+ * scalar <- assignment expression, possibly in braces [6.7.8(11)]
+ * character array <- string literal, possibly in braces [6.7.8(14)]
+ * struct or union <- assignment expression of compatible type [6.7.8(13)]
+ * compound type <- initializer list in braces [6.7.8(16)]
+ * The last one punts to handle_list_initializer() which, in turn will call
+ * us for individual elements of the list.
+ *
+ * We do not handle 6.7.8(15) (wide char array <- wide string literal) for
+ * the lack of support of wide char stuff in general.
+ *
+ * One note: we need to take care not to evaluate a string literal until
+ * we know that we *will* handle it right here.  Otherwise we would screw
+ * the cases like struct { struct {char s[10]; ...} ...} initialized with
+ * { "string", ...} - we need to preserve that string literal recognizable
+ * until we dig into the inner struct.
+ */
+static int handle_initializer(struct expression **ep, int nested,
+		int class, struct symbol *ctype, unsigned long mods)
+{
+	int is_string = is_string_type(ctype);
+	struct expression *e = *ep, *p;
+	struct symbol *type;
+
+	if (!e)
+		return 0;
+
+	/* scalar */
+	if (!(class & TYPE_COMPOUND)) {
+		e = handle_scalar(e, nested);
+		if (!e)
+			return 0;
+		*ep = e;
+		if (!evaluate_expression(e))
+			return 1;
+		compatible_assignment_types(e, ctype, ep, "initializer");
+		/*
+		 * Initializers for static storage duration objects
+		 * shall be constant expressions or a string literal [6.7.8(4)].
+		 */
+		mods |= ctype->ctype.modifiers;
+		mods &= (MOD_TOPLEVEL | MOD_STATIC);
+		if (mods && !(e->flags & (CEF_ACE | CEF_ADDR)))
+			if (Wconstexpr_not_const)
+				warning(e->pos, "non-constant initializer for static object");
+
+		return 1;
+	}
+
+	/*
+	 * sublist; either a string, or we dig in; the latter will deal with
+	 * pathologies, so we don't need anything fancy here.
+	 */
+	if (e->type == EXPR_INITIALIZER) {
+		if (is_string) {
+			struct expression *v = NULL;
+			int count = 0;
+
+			FOR_EACH_PTR(e->expr_list, p) {
+				if (!v)
+					v = p;
+				count++;
+			} END_FOR_EACH_PTR(p);
+			if (count == 1 && is_string_literal(&v)) {
+				*ep = e = v;
+				goto String;
+			}
+		}
+		handle_list_initializer(e, class, ctype, mods);
+		return 1;
+	}
+
+	/* string */
+	if (is_string_literal(&e)) {
+		/* either we are doing array of char, or we'll have to dig in */
+		if (is_string) {
+			*ep = e;
+			goto String;
+		}
+		return 0;
+	}
+	/* struct or union can be initialized by compatible */
+	if (class != TYPE_COMPOUND)
+		return 0;
+	type = evaluate_expression(e);
+	if (!type)
+		return 0;
+	if (ctype->type == SYM_NODE)
+		ctype = ctype->ctype.base_type;
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	if (ctype == type)
+		return 1;
+	return 0;
+
+String:
+	p = alloc_expression(e->pos, EXPR_STRING);
+	*p = *e;
+	type = evaluate_expression(p);
+	if (ctype->bit_size != -1) {
+		if (ctype->bit_size + bits_in_char < type->bit_size)
+			warning(e->pos,
+				"too long initializer-string for array of char");
+		else if (Winit_cstring && ctype->bit_size + bits_in_char == type->bit_size) {
+			warning(e->pos,
+				"too long initializer-string for array of char(no space for nul char)");
+		}
+	}
+	*ep = p;
+	return 1;
+}
+
+static void evaluate_initializer(struct symbol *ctype, struct expression **ep)
+{
+	struct symbol *type;
+	int class = classify_type(ctype, &type);
+	if (!handle_initializer(ep, 0, class, ctype, 0))
+		expression_error(*ep, "invalid initializer");
+}
+
+static struct symbol *cast_to_bool(struct expression *expr)
+{
+	struct expression *old = expr->cast_expression;
+	struct expression *zero;
+	struct symbol *otype;
+	int oclass = classify_type(degenerate(old), &otype);
+	struct symbol *ctype;
+
+	if (oclass & TYPE_COMPOUND)
+		return NULL;
+
+	zero = alloc_const_expression(expr->pos, 0);
+	expr->op = SPECIAL_NOTEQUAL;
+	ctype = usual_conversions(expr->op, old, zero,
+			oclass, TYPE_NUM, otype, zero->ctype);
+	expr->type = EXPR_COMPARE;
+	expr->left = cast_to(old, ctype);
+	expr->right = cast_to(zero, ctype);
+
+	return expr->ctype;
+}
+
+static int cast_flags(struct expression *expr, struct expression *old)
+{
+	struct symbol *t;
+	int class;
+	int flags = CEF_NONE;
+
+	class = classify_type(expr->ctype, &t);
+	if (class & TYPE_NUM) {
+		flags = old->flags & ~CEF_CONST_MASK;
+		/*
+		 * Casts to numeric types never result in address
+		 * constants [6.6(9)].
+		 */
+		flags &= ~CEF_ADDR;
+
+		/*
+		 * As an extension, treat address constants cast to
+		 * integer type as an arithmetic constant.
+		 */
+		if (old->flags & CEF_ADDR)
+			flags = CEF_ACE;
+
+		/*
+		 * Cast to float type -> not an integer constant
+		 * expression [6.6(6)].
+		 */
+		if (class & TYPE_FLOAT)
+			flags &= ~CEF_CLR_ICE;
+		/*
+		 * Casts of float literals to integer type results in
+		 * a constant integer expression [6.6(6)].
+		 */
+		else if (old->flags & CEF_FLOAT)
+			flags = CEF_SET_ICE;
+	} else if (class & TYPE_PTR) {
+		/*
+		 * Casts of integer literals to pointer type yield
+		 * address constants [6.6(9)].
+		 *
+		 * As an extension, treat address constants cast to a
+		 * different pointer type as address constants again.
+		 *
+		 * As another extension, treat integer constant
+		 * expressions (in contrast to literals) cast to
+		 * pointer type as address constants.
+		 */
+		if (old->flags & (CEF_ICE | CEF_ADDR))
+			flags = CEF_ADDR;
+	}
+
+	return flags;
+}
+
+static struct symbol *evaluate_cast(struct expression *expr)
+{
+	struct expression *target = expr->cast_expression;
+	struct symbol *ctype;
+	struct symbol *t1, *t2;
+	int class1, class2;
+	int as1 = 0, as2 = 0;
+
+	if (!target)
+		return NULL;
+
+	/*
+	 * Special case: a cast can be followed by an
+	 * initializer, in which case we need to pass
+	 * the type value down to that initializer rather
+	 * than trying to evaluate it as an expression
+	 *
+	 * A more complex case is when the initializer is
+	 * dereferenced as part of a post-fix expression.
+	 * We need to produce an expression that can be dereferenced.
+	 */
+	if (target->type == EXPR_INITIALIZER) {
+		struct symbol *sym = expr->cast_type;
+		struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL);
+
+		sym->initializer = target;
+		evaluate_symbol(sym);
+
+		addr->ctype = &lazy_ptr_ctype;	/* Lazy eval */
+		addr->symbol = sym;
+		if (sym->ctype.modifiers & MOD_TOPLEVEL)
+			addr->flags |= CEF_ADDR;
+
+		expr->type = EXPR_PREOP;
+		expr->op = '*';
+		expr->unop = addr;
+		expr->ctype = sym;
+
+		return sym;
+	}
+
+	ctype = examine_symbol_type(expr->cast_type);
+	expr->ctype = ctype;
+	expr->cast_type = ctype;
+
+	evaluate_expression(target);
+	degenerate(target);
+
+	class1 = classify_type(ctype, &t1);
+
+	expr->flags = cast_flags(expr, target);
+
+	/*
+	 * You can always throw a value away by casting to
+	 * "void" - that's an implicit "force". Note that
+	 * the same is _not_ true of "void *".
+	 */
+	if (t1 == &void_ctype)
+		goto out;
+
+	if (class1 & (TYPE_COMPOUND | TYPE_FN))
+		warning(expr->pos, "cast to non-scalar");
+
+	t2 = target->ctype;
+	if (!t2) {
+		expression_error(expr, "cast from unknown type");
+		goto out;
+	}
+	class2 = classify_type(t2, &t2);
+
+	if (class2 & TYPE_COMPOUND)
+		warning(expr->pos, "cast from non-scalar");
+
+	if (expr->type == EXPR_FORCE_CAST)
+		goto out;
+
+	/* allowed cast unfouls */
+	if (class2 & TYPE_FOULED)
+		t2 = unfoul(t2);
+
+	if (t1 != t2) {
+		if ((class1 & TYPE_RESTRICT) && restricted_value(target, t1))
+			warning(expr->pos, "cast to %s",
+				show_typename(t1));
+		if (class2 & TYPE_RESTRICT) {
+			if (t1 == &bool_ctype) {
+				if (class2 & TYPE_FOULED)
+					warning(expr->pos, "%s degrades to integer",
+						show_typename(t2));
+			} else {
+				warning(expr->pos, "cast from %s",
+					show_typename(t2));
+			}
+		}
+	}
+
+	if (t1 == &ulong_ctype)
+		as1 = -1;
+	else if (class1 == TYPE_PTR) {
+		examine_pointer_target(t1);
+		as1 = t1->ctype.as;
+	}
+
+	if (t2 == &ulong_ctype)
+		as2 = -1;
+	else if (class2 == TYPE_PTR) {
+		examine_pointer_target(t2);
+		as2 = t2->ctype.as;
+	}
+
+	if (!as1 && as2 > 0)
+		warning(expr->pos, "cast removes address space of expression");
+	if (as1 > 0 && as2 > 0 && as1 != as2)
+		warning(expr->pos, "cast between address spaces (<asn:%d>-><asn:%d>)", as2, as1);
+	if (as1 > 0 && !as2 &&
+	    !is_null_pointer_constant(target) && Wcast_to_as)
+		warning(expr->pos,
+			"cast adds address space to expression (<asn:%d>)", as1);
+
+	if (!(t1->ctype.modifiers & MOD_PTRINHERIT) && class1 == TYPE_PTR &&
+	    !as1 && (target->flags & CEF_ICE)) {
+		if (t1->ctype.base_type == &void_ctype) {
+			if (is_zero_constant(target)) {
+				/* NULL */
+				expr->type = EXPR_VALUE;
+				expr->ctype = &null_ctype;
+				expr->value = 0;
+				return expr->ctype;
+			}
+		}
+	}
+
+	if (t1 == &bool_ctype)
+		cast_to_bool(expr);
+
+out:
+	return ctype;
+}
+
+/*
+ * Evaluate a call expression with a symbol. This
+ * should expand inline functions, and evaluate
+ * builtins.
+ */
+static int evaluate_symbol_call(struct expression *expr)
+{
+	struct expression *fn = expr->fn;
+	struct symbol *ctype = fn->ctype;
+
+	if (fn->type != EXPR_PREOP)
+		return 0;
+
+	if (ctype->op && ctype->op->evaluate)
+		return ctype->op->evaluate(expr);
+
+	if (ctype->ctype.modifiers & MOD_INLINE) {
+		int ret;
+		struct symbol *curr = current_fn;
+
+		if (ctype->definition)
+			ctype = ctype->definition;
+
+		current_fn = ctype->ctype.base_type;
+
+		ret = inline_function(expr, ctype);
+
+		/* restore the old function */
+		current_fn = curr;
+		return ret;
+	}
+
+	return 0;
+}
+
+static struct symbol *evaluate_call(struct expression *expr)
+{
+	int args, fnargs;
+	struct symbol *ctype, *sym;
+	struct expression *fn = expr->fn;
+	struct expression_list *arglist = expr->args;
+
+	if (!evaluate_expression(fn))
+		return NULL;
+	sym = ctype = fn->ctype;
+	if (ctype->type == SYM_NODE)
+		ctype = ctype->ctype.base_type;
+	if (ctype->type == SYM_PTR)
+		ctype = get_base_type(ctype);
+
+	if (ctype->type != SYM_FN) {
+		struct expression *arg;
+		expression_error(expr, "not a function %s",
+			     show_ident(sym->ident));
+		/* do typechecking in arguments */
+		FOR_EACH_PTR (arglist, arg) {
+			evaluate_expression(arg);
+		} END_FOR_EACH_PTR(arg);
+		return NULL;
+	}
+
+	examine_fn_arguments(ctype);
+        if (sym->type == SYM_NODE && fn->type == EXPR_PREOP &&
+	    sym->op && sym->op->args) {
+		if (!sym->op->args(expr))
+			return NULL;
+	} else {
+		if (!evaluate_arguments(ctype, arglist))
+			return NULL;
+		args = expression_list_size(expr->args);
+		fnargs = symbol_list_size(ctype->arguments);
+		if (args < fnargs) {
+			expression_error(expr,
+				     "not enough arguments for function %s",
+				     show_ident(sym->ident));
+			return NULL;
+		}
+		if (args > fnargs && !ctype->variadic)
+			expression_error(expr,
+				     "too many arguments for function %s",
+				     show_ident(sym->ident));
+	}
+	expr->ctype = ctype->ctype.base_type;
+	if (sym->type == SYM_NODE) {
+		if (evaluate_symbol_call(expr))
+			return expr->ctype;
+	}
+	return expr->ctype;
+}
+
+static struct symbol *evaluate_offsetof(struct expression *expr)
+{
+	struct expression *e = expr->down;
+	struct symbol *ctype = expr->in;
+	int class;
+
+	if (expr->op == '.') {
+		struct symbol *field;
+		int offset = 0;
+		if (!ctype) {
+			expression_error(expr, "expected structure or union");
+			return NULL;
+		}
+		examine_symbol_type(ctype);
+		class = classify_type(ctype, &ctype);
+		if (class != TYPE_COMPOUND) {
+			expression_error(expr, "expected structure or union");
+			return NULL;
+		}
+
+		field = find_identifier(expr->ident, ctype->symbol_list, &offset);
+		if (!field) {
+			expression_error(expr, "unknown member");
+			return NULL;
+		}
+		ctype = field;
+		expr->type = EXPR_VALUE;
+		expr->flags = CEF_SET_ICE;
+		expr->value = offset;
+		expr->taint = 0;
+		expr->ctype = size_t_ctype;
+	} else {
+		if (!ctype) {
+			expression_error(expr, "expected structure or union");
+			return NULL;
+		}
+		examine_symbol_type(ctype);
+		class = classify_type(ctype, &ctype);
+		if (class != (TYPE_COMPOUND | TYPE_PTR)) {
+			expression_error(expr, "expected array");
+			return NULL;
+		}
+		ctype = ctype->ctype.base_type;
+		if (!expr->index) {
+			expr->type = EXPR_VALUE;
+			expr->flags = CEF_SET_ICE;
+			expr->value = 0;
+			expr->taint = 0;
+			expr->ctype = size_t_ctype;
+		} else {
+			struct expression *idx = expr->index, *m;
+			struct symbol *i_type = evaluate_expression(idx);
+			unsigned old_idx_flags;
+			int i_class = classify_type(i_type, &i_type);
+
+			if (!is_int(i_class)) {
+				expression_error(expr, "non-integer index");
+				return NULL;
+			}
+			unrestrict(idx, i_class, &i_type);
+			old_idx_flags = idx->flags;
+			idx = cast_to(idx, size_t_ctype);
+			idx->flags = old_idx_flags;
+			m = alloc_const_expression(expr->pos,
+						   bits_to_bytes(ctype->bit_size));
+			m->ctype = size_t_ctype;
+			m->flags = CEF_SET_INT;
+			expr->type = EXPR_BINOP;
+			expr->left = idx;
+			expr->right = m;
+			expr->op = '*';
+			expr->ctype = size_t_ctype;
+			expr->flags = m->flags & idx->flags & ~CEF_CONST_MASK;
+		}
+	}
+	if (e) {
+		struct expression *copy = __alloc_expression(0);
+		*copy = *expr;
+		if (e->type == EXPR_OFFSETOF)
+			e->in = ctype;
+		if (!evaluate_expression(e))
+			return NULL;
+		expr->type = EXPR_BINOP;
+		expr->flags = e->flags & copy->flags & ~CEF_CONST_MASK;
+		expr->op = '+';
+		expr->ctype = size_t_ctype;
+		expr->left = copy;
+		expr->right = e;
+	}
+	return size_t_ctype;
+}
+
+struct symbol *evaluate_expression(struct expression *expr)
+{
+	if (!expr)
+		return NULL;
+	if (expr->ctype)
+		return expr->ctype;
+
+	switch (expr->type) {
+	case EXPR_VALUE:
+	case EXPR_FVALUE:
+		expression_error(expr, "value expression without a type");
+		return NULL;
+	case EXPR_STRING:
+		return evaluate_string(expr);
+	case EXPR_SYMBOL:
+		return evaluate_symbol_expression(expr);
+	case EXPR_BINOP:
+		if (!evaluate_expression(expr->left))
+			return NULL;
+		if (!evaluate_expression(expr->right))
+			return NULL;
+		return evaluate_binop(expr);
+	case EXPR_LOGICAL:
+		return evaluate_logical(expr);
+	case EXPR_COMMA:
+		evaluate_expression(expr->left);
+		if (!evaluate_expression(expr->right))
+			return NULL;
+		return evaluate_comma(expr);
+	case EXPR_COMPARE:
+		if (!evaluate_expression(expr->left))
+			return NULL;
+		if (!evaluate_expression(expr->right))
+			return NULL;
+		return evaluate_compare(expr);
+	case EXPR_ASSIGNMENT:
+		if (!evaluate_expression(expr->left))
+			return NULL;
+		if (!evaluate_expression(expr->right))
+			return NULL;
+		return evaluate_assignment(expr);
+	case EXPR_PREOP:
+		if (!evaluate_expression(expr->unop))
+			return NULL;
+		return evaluate_preop(expr);
+	case EXPR_POSTOP:
+		if (!evaluate_expression(expr->unop))
+			return NULL;
+		return evaluate_postop(expr);
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+	case EXPR_IMPLIED_CAST:
+		return evaluate_cast(expr);
+	case EXPR_SIZEOF:
+		return evaluate_sizeof(expr);
+	case EXPR_PTRSIZEOF:
+		return evaluate_ptrsizeof(expr);
+	case EXPR_ALIGNOF:
+		return evaluate_alignof(expr);
+	case EXPR_DEREF:
+		return evaluate_member_dereference(expr);
+	case EXPR_CALL:
+		return evaluate_call(expr);
+	case EXPR_SELECT:
+	case EXPR_CONDITIONAL:
+		return evaluate_conditional_expression(expr);
+	case EXPR_STATEMENT:
+		expr->ctype = evaluate_statement(expr->statement);
+		return expr->ctype;
+
+	case EXPR_LABEL:
+		expr->ctype = &ptr_ctype;
+		return &ptr_ctype;
+
+	case EXPR_TYPE:
+		/* Evaluate the type of the symbol .. */
+		evaluate_symbol(expr->symbol);
+		/* .. but the type of the _expression_ is a "type" */
+		expr->ctype = &type_ctype;
+		return &type_ctype;
+
+	case EXPR_OFFSETOF:
+		return evaluate_offsetof(expr);
+
+	/* These can not exist as stand-alone expressions */
+	case EXPR_INITIALIZER:
+	case EXPR_IDENTIFIER:
+	case EXPR_INDEX:
+	case EXPR_POS:
+		expression_error(expr, "internal front-end error: initializer in expression");
+		return NULL;
+	case EXPR_SLICE:
+		expression_error(expr, "internal front-end error: SLICE re-evaluated");
+		return NULL;
+	}
+	return NULL;
+}
+
+static void check_duplicates(struct symbol *sym)
+{
+	int declared = 0;
+	struct symbol *next = sym;
+	int initialized = sym->initializer != NULL;
+
+	while ((next = next->same_symbol) != NULL) {
+		const char *typediff;
+		evaluate_symbol(next);
+		if (initialized && next->initializer) {
+			sparse_error(sym->pos, "symbol '%s' has multiple initializers (originally initialized at %s:%d)",
+				show_ident(sym->ident),
+				stream_name(next->pos.stream), next->pos.line);
+			/* Only warn once */
+			initialized = 0;
+		}
+		declared++;
+		typediff = type_difference(&sym->ctype, &next->ctype, 0, 0);
+		if (typediff) {
+			sparse_error(sym->pos, "symbol '%s' redeclared with different type (originally declared at %s:%d) - %s",
+				show_ident(sym->ident),
+				stream_name(next->pos.stream), next->pos.line, typediff);
+			return;
+		}
+	}
+	if (!declared) {
+		unsigned long mod = sym->ctype.modifiers;
+		if (mod & (MOD_STATIC | MOD_REGISTER))
+			return;
+		if (!(mod & MOD_TOPLEVEL))
+			return;
+		if (!Wdecl)
+			return;
+		if (sym->ident == &main_ident)
+			return;
+		warning(sym->pos, "symbol '%s' was not declared. Should it be static?", show_ident(sym->ident));
+	}
+}
+
+static struct symbol *evaluate_symbol(struct symbol *sym)
+{
+	struct symbol *base_type;
+
+	if (!sym)
+		return sym;
+	if (sym->evaluated)
+		return sym;
+	sym->evaluated = 1;
+
+	sym = examine_symbol_type(sym);
+	base_type = get_base_type(sym);
+	if (!base_type)
+		return NULL;
+
+	/* Evaluate the initializers */
+	if (sym->initializer)
+		evaluate_initializer(sym, &sym->initializer);
+
+	/* And finally, evaluate the body of the symbol too */
+	if (base_type->type == SYM_FN) {
+		struct symbol *curr = current_fn;
+
+		if (sym->definition && sym->definition != sym)
+			return evaluate_symbol(sym->definition);
+
+		current_fn = base_type;
+
+		examine_fn_arguments(base_type);
+		if (!base_type->stmt && base_type->inline_stmt)
+			uninline(sym);
+		if (base_type->stmt)
+			evaluate_statement(base_type->stmt);
+
+		current_fn = curr;
+	}
+
+	return base_type;
+}
+
+void evaluate_symbol_list(struct symbol_list *list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		has_error &= ~ERROR_CURR_PHASE;
+		evaluate_symbol(sym);
+		check_duplicates(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+static struct symbol *evaluate_return_expression(struct statement *stmt)
+{
+	struct expression *expr = stmt->expression;
+	struct symbol *fntype;
+
+	evaluate_expression(expr);
+	fntype = current_fn->ctype.base_type;
+	if (!fntype || fntype == &void_ctype) {
+		if (expr && expr->ctype != &void_ctype)
+			expression_error(expr, "return expression in %s function", fntype?"void":"typeless");
+		if (expr && Wreturn_void)
+			warning(stmt->pos, "returning void-valued expression");
+		return NULL;
+	}
+
+	if (!expr) {
+		sparse_error(stmt->pos, "return with no return value");
+		return NULL;
+	}
+	if (!expr->ctype)
+		return NULL;
+	compatible_assignment_types(expr, fntype, &stmt->expression, "return expression");
+	return NULL;
+}
+
+static void evaluate_if_statement(struct statement *stmt)
+{
+	if (!stmt->if_conditional)
+		return;
+
+	evaluate_conditional(stmt->if_conditional, 0);
+	evaluate_statement(stmt->if_true);
+	evaluate_statement(stmt->if_false);
+}
+
+static void evaluate_iterator(struct statement *stmt)
+{
+	evaluate_symbol_list(stmt->iterator_syms);
+	evaluate_conditional(stmt->iterator_pre_condition, 1);
+	evaluate_conditional(stmt->iterator_post_condition,1);
+	evaluate_statement(stmt->iterator_pre_statement);
+	evaluate_statement(stmt->iterator_statement);
+	evaluate_statement(stmt->iterator_post_statement);
+}
+
+static void verify_output_constraint(struct expression *expr, const char *constraint)
+{
+	switch (*constraint) {
+	case '=':	/* Assignment */
+	case '+':	/* Update */
+		break;
+	default:
+		expression_error(expr, "output constraint is not an assignment constraint (\"%s\")", constraint);
+	}
+}
+
+static void verify_input_constraint(struct expression *expr, const char *constraint)
+{
+	switch (*constraint) {
+	case '=':	/* Assignment */
+	case '+':	/* Update */
+		expression_error(expr, "input constraint with assignment (\"%s\")", constraint);
+	}
+}
+
+static void evaluate_asm_statement(struct statement *stmt)
+{
+	struct expression *expr;
+	struct symbol *sym;
+	int state;
+
+	expr = stmt->asm_string;
+	if (!expr || expr->type != EXPR_STRING) {
+		sparse_error(stmt->pos, "need constant string for inline asm");
+		return;
+	}
+
+	state = 0;
+	FOR_EACH_PTR(stmt->asm_outputs, expr) {
+		switch (state) {
+		case 0: /* Identifier */
+			state = 1;
+			continue;
+
+		case 1: /* Constraint */
+			state = 2;
+			if (!expr || expr->type != EXPR_STRING) {
+				sparse_error(expr ? expr->pos : stmt->pos, "asm output constraint is not a string");
+				*THIS_ADDRESS(expr) = NULL;
+				continue;
+			}
+			verify_output_constraint(expr, expr->string->data);
+			continue;
+
+		case 2: /* Expression */
+			state = 0;
+			if (!evaluate_expression(expr))
+				return;
+			if (!lvalue_expression(expr))
+				warning(expr->pos, "asm output is not an lvalue");
+			evaluate_assign_to(expr, expr->ctype);
+			continue;
+		}
+	} END_FOR_EACH_PTR(expr);
+
+	state = 0;
+	FOR_EACH_PTR(stmt->asm_inputs, expr) {
+		switch (state) {
+		case 0: /* Identifier */
+			state = 1;
+			continue;
+
+		case 1:	/* Constraint */
+			state = 2;
+			if (!expr || expr->type != EXPR_STRING) {
+				sparse_error(expr ? expr->pos : stmt->pos, "asm input constraint is not a string");
+				*THIS_ADDRESS(expr) = NULL;
+				continue;
+			}
+			verify_input_constraint(expr, expr->string->data);
+			continue;
+
+		case 2: /* Expression */
+			state = 0;
+			if (!evaluate_expression(expr))
+				return;
+			continue;
+		}
+	} END_FOR_EACH_PTR(expr);
+
+	FOR_EACH_PTR(stmt->asm_clobbers, expr) {
+		if (!expr) {
+			sparse_error(stmt->pos, "bad asm clobbers");
+			return;
+		}
+		if (expr->type == EXPR_STRING)
+			continue;
+		expression_error(expr, "asm clobber is not a string");
+	} END_FOR_EACH_PTR(expr);
+
+	FOR_EACH_PTR(stmt->asm_labels, sym) {
+		if (!sym || sym->type != SYM_LABEL) {
+			sparse_error(stmt->pos, "bad asm label");
+			return;
+		}
+	} END_FOR_EACH_PTR(sym);
+}
+
+static void evaluate_case_statement(struct statement *stmt)
+{
+	evaluate_expression(stmt->case_expression);
+	evaluate_expression(stmt->case_to);
+	evaluate_statement(stmt->case_statement);
+}
+
+static void check_case_type(struct expression *switch_expr,
+			    struct expression *case_expr,
+			    struct expression **enumcase)
+{
+	struct symbol *switch_type, *case_type;
+	int sclass, cclass;
+
+	if (!case_expr)
+		return;
+
+	switch_type = switch_expr->ctype;
+	case_type = evaluate_expression(case_expr);
+
+	if (!switch_type || !case_type)
+		goto Bad;
+	if (enumcase) {
+		if (*enumcase)
+			warn_for_different_enum_types(case_expr->pos, case_type, (*enumcase)->ctype);
+		else if (is_enum_type(case_type))
+			*enumcase = case_expr;
+	}
+
+	sclass = classify_type(switch_type, &switch_type);
+	cclass = classify_type(case_type, &case_type);
+
+	/* both should be arithmetic */
+	if (!(sclass & cclass & TYPE_NUM))
+		goto Bad;
+
+	/* neither should be floating */
+	if ((sclass | cclass) & TYPE_FLOAT)
+		goto Bad;
+
+	/* if neither is restricted, we are OK */
+	if (!((sclass | cclass) & TYPE_RESTRICT))
+		return;
+
+	if (!restricted_binop_type(SPECIAL_EQUAL, case_expr, switch_expr,
+				   cclass, sclass, case_type, switch_type)) {
+		unrestrict(case_expr, cclass, &case_type);
+		unrestrict(switch_expr, sclass, &switch_type);
+	}
+	return;
+
+Bad:
+	expression_error(case_expr, "incompatible types for 'case' statement");
+}
+
+static void evaluate_switch_statement(struct statement *stmt)
+{
+	struct symbol *sym;
+	struct expression *enumcase = NULL;
+	struct expression **enumcase_holder = &enumcase;
+	struct expression *sel = stmt->switch_expression;
+
+	evaluate_expression(sel);
+	evaluate_statement(stmt->switch_statement);
+	if (!sel)
+		return;
+	if (sel->ctype && is_enum_type(sel->ctype))
+		enumcase_holder = NULL; /* Only check cases against switch */
+
+	FOR_EACH_PTR(stmt->switch_case->symbol_list, sym) {
+		struct statement *case_stmt = sym->stmt;
+		check_case_type(sel, case_stmt->case_expression, enumcase_holder);
+		check_case_type(sel, case_stmt->case_to, enumcase_holder);
+	} END_FOR_EACH_PTR(sym);
+}
+
+static void evaluate_goto_statement(struct statement *stmt)
+{
+	struct symbol *label = stmt->goto_label;
+
+	if (label && !label->stmt && !lookup_keyword(label->ident, NS_KEYWORD))
+		sparse_error(stmt->pos, "label '%s' was not declared", show_ident(label->ident));
+
+	evaluate_expression(stmt->goto_expression);
+}
+
+struct symbol *evaluate_statement(struct statement *stmt)
+{
+	if (!stmt)
+		return NULL;
+
+	switch (stmt->type) {
+	case STMT_DECLARATION: {
+		struct symbol *s;
+		FOR_EACH_PTR(stmt->declaration, s) {
+			evaluate_symbol(s);
+		} END_FOR_EACH_PTR(s);
+		return NULL;
+	}
+
+	case STMT_RETURN:
+		return evaluate_return_expression(stmt);
+
+	case STMT_EXPRESSION:
+		if (!evaluate_expression(stmt->expression))
+			return NULL;
+		if (stmt->expression->ctype == &null_ctype)
+			stmt->expression = cast_to(stmt->expression, &ptr_ctype);
+		return degenerate(stmt->expression);
+
+	case STMT_COMPOUND: {
+		struct statement *s;
+		struct symbol *type = NULL;
+
+		/* Evaluate the return symbol in the compound statement */
+		evaluate_symbol(stmt->ret);
+
+		/*
+		 * Then, evaluate each statement, making the type of the
+		 * compound statement be the type of the last statement
+		 */
+		type = evaluate_statement(stmt->args);
+		FOR_EACH_PTR(stmt->stmts, s) {
+			type = evaluate_statement(s);
+		} END_FOR_EACH_PTR(s);
+		if (!type)
+			type = &void_ctype;
+		return type;
+	}
+	case STMT_IF:
+		evaluate_if_statement(stmt);
+		return NULL;
+	case STMT_ITERATOR:
+		evaluate_iterator(stmt);
+		return NULL;
+	case STMT_SWITCH:
+		evaluate_switch_statement(stmt);
+		return NULL;
+	case STMT_CASE:
+		evaluate_case_statement(stmt);
+		return NULL;
+	case STMT_LABEL:
+		return evaluate_statement(stmt->label_statement);
+	case STMT_GOTO:
+		evaluate_goto_statement(stmt);
+		return NULL;
+	case STMT_NONE:
+		break;
+	case STMT_ASM:
+		evaluate_asm_statement(stmt);
+		return NULL;
+	case STMT_CONTEXT:
+		evaluate_expression(stmt->expression);
+		return NULL;
+	case STMT_RANGE:
+		evaluate_expression(stmt->range_expression);
+		evaluate_expression(stmt->range_low);
+		evaluate_expression(stmt->range_high);
+		return NULL;
+	}
+	return NULL;
+}
diff --git a/usr/src/tools/smatch/src/example.c b/usr/src/tools/smatch/src/example.c
new file mode 100644
index 0000000000..691e0f97cb
--- /dev/null
+++ b/usr/src/tools/smatch/src/example.c
@@ -0,0 +1,1957 @@
+/*
+ * Example of how to write a compiler with sparse
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <assert.h>
+
+#include "symbol.h"
+#include "expression.h"
+#include "linearize.h"
+#include "flow.h"
+#include "storage.h"
+#include "target.h"
+
+static const char *opcodes[] = {
+	[OP_BADOP] = "bad_op",
+
+	/* Fn entrypoint */
+	[OP_ENTRY] = "<entry-point>",
+
+	/* Terminator */
+	[OP_RET] = "ret",
+	[OP_BR] = "br",
+	[OP_CBR] = "cbr",
+	[OP_SWITCH] = "switch",
+	[OP_INVOKE] = "invoke",
+	[OP_COMPUTEDGOTO] = "jmp *",
+	[OP_UNWIND] = "unwind",
+	
+	/* Binary */
+	[OP_ADD] = "add",
+	[OP_SUB] = "sub",
+	[OP_MULU] = "mulu",
+	[OP_MULS] = "muls",
+	[OP_DIVU] = "divu",
+	[OP_DIVS] = "divs",
+	[OP_MODU] = "modu",
+	[OP_MODS] = "mods",
+	[OP_SHL] = "shl",
+	[OP_LSR] = "lsr",
+	[OP_ASR] = "asr",
+	
+	/* Logical */
+	[OP_AND] = "and",
+	[OP_OR] = "or",
+	[OP_XOR] = "xor",
+	[OP_AND_BOOL] = "and-bool",
+	[OP_OR_BOOL] = "or-bool",
+
+	/* Binary comparison */
+	[OP_SET_EQ] = "seteq",
+	[OP_SET_NE] = "setne",
+	[OP_SET_LE] = "setle",
+	[OP_SET_GE] = "setge",
+	[OP_SET_LT] = "setlt",
+	[OP_SET_GT] = "setgt",
+	[OP_SET_B] = "setb",
+	[OP_SET_A] = "seta",
+	[OP_SET_BE] = "setbe",
+	[OP_SET_AE] = "setae",
+
+	/* Uni */
+	[OP_NOT] = "not",
+	[OP_NEG] = "neg",
+
+	/* Special three-input */
+	[OP_SEL] = "select",
+	
+	/* Memory */
+	[OP_MALLOC] = "malloc",
+	[OP_FREE] = "free",
+	[OP_ALLOCA] = "alloca",
+	[OP_LOAD] = "load",
+	[OP_STORE] = "store",
+	[OP_SETVAL] = "set",
+	[OP_GET_ELEMENT_PTR] = "getelem",
+
+	/* Other */
+	[OP_PHI] = "phi",
+	[OP_PHISOURCE] = "phisrc",
+	[OP_COPY] = "copy",
+	[OP_CAST] = "cast",
+	[OP_SCAST] = "scast",
+	[OP_FPCAST] = "fpcast",
+	[OP_PTRCAST] = "ptrcast",
+	[OP_CALL] = "call",
+	[OP_VANEXT] = "va_next",
+	[OP_VAARG] = "va_arg",
+	[OP_SLICE] = "slice",
+	[OP_SNOP] = "snop",
+	[OP_LNOP] = "lnop",
+	[OP_NOP] = "nop",
+	[OP_DEATHNOTE] = "dead",
+	[OP_ASM] = "asm",
+
+	/* Sparse tagging (line numbers, context, whatever) */
+	[OP_CONTEXT] = "context",
+};
+
+static int last_reg, stack_offset;
+
+struct hardreg {
+	const char *name;
+	struct pseudo_list *contains;
+	unsigned busy:16,
+		 dead:8,
+		 used:1;
+};
+
+#define TAG_DEAD 1
+#define TAG_DIRTY 2
+
+/* Our "switch" generation is very very stupid. */
+#define SWITCH_REG (1)
+
+static void output_bb(struct basic_block *bb, unsigned long generation);
+
+/*
+ * We only know about the caller-clobbered registers
+ * right now.
+ */
+static struct hardreg hardregs[] = {
+	{ .name = "%eax" },
+	{ .name = "%edx" },
+	{ .name = "%ecx" },
+	{ .name = "%ebx" },
+	{ .name = "%esi" },
+	{ .name = "%edi" },
+
+	{ .name = "%ebp" },
+	{ .name = "%esp" },
+};
+#define REGNO 6
+#define REG_EBP 6
+#define REG_ESP 7
+
+struct bb_state {
+	struct position pos;
+	struct storage_hash_list *inputs;
+	struct storage_hash_list *outputs;
+	struct storage_hash_list *internal;
+
+	/* CC cache.. */
+	int cc_opcode, cc_dead;
+	pseudo_t cc_target;
+};
+
+enum optype {
+	OP_UNDEF,
+	OP_REG,
+	OP_VAL,
+	OP_MEM,
+	OP_ADDR,
+};
+
+struct operand {
+	enum optype type;
+	int size;
+	union {
+		struct hardreg *reg;
+		long long value;
+		struct /* OP_MEM and OP_ADDR */ {
+			unsigned int offset;
+			unsigned int scale;
+			struct symbol *sym;
+			struct hardreg *base;
+			struct hardreg *index;
+		};
+	};
+};
+
+static const char *show_op(struct bb_state *state, struct operand *op)
+{
+	static char buf[256][4];
+	static int bufnr;
+	char *p, *ret;
+	int nr;
+
+	nr = (bufnr + 1) & 3;
+	bufnr = nr;
+	ret = p = buf[nr];
+
+	switch (op->type) {
+	case OP_UNDEF:
+		return "undef";
+	case OP_REG:
+		return op->reg->name;
+	case OP_VAL:
+		sprintf(p, "$%lld", op->value);
+		break;
+	case OP_MEM:
+	case OP_ADDR:
+		if (op->offset)
+			p += sprintf(p, "%d", op->offset);
+		if (op->sym)
+			p += sprintf(p, "%s%s",
+				op->offset ? "+" : "",
+				show_ident(op->sym->ident));
+		if (op->base || op->index) {
+			p += sprintf(p, "(%s%s%s",
+				op->base ? op->base->name : "",
+				(op->base && op->index) ? "," : "",
+				op->index ? op->index->name : "");
+			if (op->scale > 1)
+				p += sprintf(p, ",%d", op->scale);
+			*p++ = ')';
+			*p = '\0';
+		}
+		break;
+	}
+	return ret;
+}
+
+static struct storage_hash *find_storage_hash(pseudo_t pseudo, struct storage_hash_list *list)
+{
+	struct storage_hash *entry;
+	FOR_EACH_PTR(list, entry) {
+		if (entry->pseudo == pseudo)
+			return entry;
+	} END_FOR_EACH_PTR(entry);
+	return NULL;
+}
+
+static struct storage_hash *find_or_create_hash(pseudo_t pseudo, struct storage_hash_list **listp)
+{
+	struct storage_hash *entry;
+
+	entry = find_storage_hash(pseudo, *listp);
+	if (!entry) {
+		entry = alloc_storage_hash(alloc_storage());
+		entry->pseudo = pseudo;
+		add_ptr_list(listp, entry);
+	}
+	return entry;
+}
+
+/* Eventually we should just build it up in memory */
+static void FORMAT_ATTR(2) output_line(struct bb_state *state, const char *fmt, ...)
+{
+	va_list args;
+
+	va_start(args, fmt);
+	vprintf(fmt, args);
+	va_end(args);
+}
+
+static void FORMAT_ATTR(2) output_label(struct bb_state *state, const char *fmt, ...)
+{
+	static char buffer[512];
+	va_list args;
+
+	va_start(args, fmt);
+	vsnprintf(buffer, sizeof(buffer), fmt, args);
+	va_end(args);
+
+	output_line(state, "%s:\n", buffer);
+}
+
+static void FORMAT_ATTR(2) output_insn(struct bb_state *state, const char *fmt, ...)
+{
+	static char buffer[512];
+	va_list args;
+
+	va_start(args, fmt);
+	vsnprintf(buffer, sizeof(buffer), fmt, args);
+	va_end(args);
+
+	output_line(state, "\t%s\n", buffer);
+}
+
+#define output_insn(state, fmt, arg...) \
+	output_insn(state, fmt "\t\t# %s" , ## arg , __FUNCTION__)
+
+static void FORMAT_ATTR(2) output_comment(struct bb_state *state, const char *fmt, ...)
+{
+	static char buffer[512];
+	va_list args;
+
+	if (!verbose)
+		return;
+	va_start(args, fmt);
+	vsnprintf(buffer, sizeof(buffer), fmt, args);
+	va_end(args);
+
+	output_line(state, "\t# %s\n", buffer);
+}
+
+static const char *show_memop(struct storage *storage)
+{
+	static char buffer[1000];
+
+	if (!storage)
+		return "undef";
+	switch (storage->type) {
+	case REG_FRAME:
+		sprintf(buffer, "%d(FP)", storage->offset);
+		break;
+	case REG_STACK:
+		sprintf(buffer, "%d(SP)", storage->offset);
+		break;
+	case REG_REG:
+		return hardregs[storage->regno].name;
+	default:
+		return show_storage(storage);
+	}
+	return buffer;
+}
+
+static int alloc_stack_offset(int size)
+{
+	int ret = stack_offset;
+	stack_offset = ret + size;
+	return ret;
+}
+
+static void alloc_stack(struct bb_state *state, struct storage *storage)
+{
+	storage->type = REG_STACK;
+	storage->offset = alloc_stack_offset(4);
+}
+
+/*
+ * Can we re-generate the pseudo, so that we don't need to
+ * flush it to memory? We can regenerate:
+ *  - immediates and symbol addresses
+ *  - pseudos we got as input in non-registers
+ *  - pseudos we've already saved off earlier..
+ */
+static int can_regenerate(struct bb_state *state, pseudo_t pseudo)
+{
+	struct storage_hash *in;
+
+	switch (pseudo->type) {
+	case PSEUDO_VAL:
+	case PSEUDO_SYM:
+		return 1;
+
+	default:
+		in = find_storage_hash(pseudo, state->inputs);
+		if (in && in->storage->type != REG_REG)
+			return 1;
+		in = find_storage_hash(pseudo, state->internal);
+		if (in)
+			return 1;
+	}
+	return 0;
+}
+
+static void flush_one_pseudo(struct bb_state *state, struct hardreg *hardreg, pseudo_t pseudo)
+{
+	struct storage_hash *out;
+	struct storage *storage;
+
+	if (can_regenerate(state, pseudo))
+		return;
+
+	output_comment(state, "flushing %s from %s", show_pseudo(pseudo), hardreg->name);
+	out = find_storage_hash(pseudo, state->internal);
+	if (!out) {
+		out = find_storage_hash(pseudo, state->outputs);
+		if (!out)
+			out = find_or_create_hash(pseudo, &state->internal);
+	}
+	storage = out->storage;
+	switch (storage->type) {
+	default:
+		/*
+		 * Aieee - the next user wants it in a register, but we
+		 * need to flush it to memory in between. Which means that
+		 * we need to allocate an internal one, dammit..
+		 */
+		out = find_or_create_hash(pseudo, &state->internal);
+		storage = out->storage;
+		/* Fall through */
+	case REG_UDEF:
+		alloc_stack(state, storage);
+		/* Fall through */
+	case REG_STACK:
+		output_insn(state, "movl %s,%s", hardreg->name, show_memop(storage));
+		break;
+	}
+}
+
+/* Flush a hardreg out to the storage it has.. */
+static void flush_reg(struct bb_state *state, struct hardreg *reg)
+{
+	pseudo_t pseudo;
+
+	if (reg->busy)
+		output_comment(state, "reg %s flushed while busy is %d!", reg->name, reg->busy);
+	if (!reg->contains)
+		return;
+	reg->dead = 0;
+	reg->used = 1;
+	FOR_EACH_PTR(reg->contains, pseudo) {
+		if (CURRENT_TAG(pseudo) & TAG_DEAD)
+			continue;
+		if (!(CURRENT_TAG(pseudo) & TAG_DIRTY))
+			continue;
+		flush_one_pseudo(state, reg, pseudo);
+	} END_FOR_EACH_PTR(pseudo);
+	free_ptr_list(&reg->contains);
+}
+
+static struct storage_hash *find_pseudo_storage(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
+{
+	struct storage_hash *src;
+
+	src = find_storage_hash(pseudo, state->internal);
+	if (!src) {
+		src = find_storage_hash(pseudo, state->inputs);
+		if (!src) {
+			src = find_storage_hash(pseudo, state->outputs);
+			/* Undefined? Screw it! */
+			if (!src)
+				return NULL;
+
+			/*
+			 * If we found output storage, it had better be local stack
+			 * that we flushed to earlier..
+			 */
+			if (src->storage->type != REG_STACK)
+				return NULL;
+		}
+	}
+
+	/*
+	 * Incoming pseudo with out any pre-set storage allocation?
+	 * We can make up our own, and obviously prefer to get it
+	 * in the register we already selected (if it hasn't been
+	 * used yet).
+	 */
+	if (src->storage->type == REG_UDEF) {
+		if (reg && !reg->used) {
+			src->storage->type = REG_REG;
+			src->storage->regno = reg - hardregs;
+			return NULL;
+		}
+		alloc_stack(state, src->storage);
+	}
+	return src;
+}
+
+static void mark_reg_dead(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
+{
+	pseudo_t p;
+
+	FOR_EACH_PTR(reg->contains, p) {
+		if (p != pseudo)
+			continue;
+		if (CURRENT_TAG(p) & TAG_DEAD)
+			continue;
+		output_comment(state, "marking pseudo %s in reg %s dead", show_pseudo(pseudo), reg->name);
+		TAG_CURRENT(p, TAG_DEAD);
+		reg->dead++;
+	} END_FOR_EACH_PTR(p);
+}
+
+static void add_pseudo_reg(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
+{
+	output_comment(state, "added pseudo %s to reg %s", show_pseudo(pseudo), reg->name);
+	add_ptr_list_tag(&reg->contains, pseudo, TAG_DIRTY);
+}
+
+static struct hardreg *preferred_reg(struct bb_state *state, pseudo_t target)
+{
+	struct storage_hash *dst;
+
+	dst = find_storage_hash(target, state->outputs);
+	if (dst) {
+		struct storage *storage = dst->storage;
+		if (storage->type == REG_REG)
+			return hardregs + storage->regno;
+	}
+	return NULL;
+}
+
+static struct hardreg *empty_reg(struct bb_state *state)
+{
+	int i;
+	struct hardreg *reg = hardregs;
+
+	for (i = 0; i < REGNO; i++, reg++) {
+		if (!reg->contains)
+			return reg;
+	}
+	return NULL;
+}
+
+static struct hardreg *target_reg(struct bb_state *state, pseudo_t pseudo, pseudo_t target)
+{
+	int i;
+	int unable_to_find_reg = 0;
+	struct hardreg *reg;
+
+	/* First, see if we have a preferred target register.. */
+	reg = preferred_reg(state, target);
+	if (reg && !reg->contains)
+		goto found;
+
+	reg = empty_reg(state);
+	if (reg)
+		goto found;
+
+	i = last_reg;
+	do {
+		i++;
+		if (i >= REGNO)
+			i = 0;
+		reg = hardregs + i;
+		if (!reg->busy) {
+			flush_reg(state, reg);
+			last_reg = i;
+			goto found;
+		}
+	} while (i != last_reg);
+	assert(unable_to_find_reg);
+
+found:
+	add_pseudo_reg(state, pseudo, reg);
+	return reg;
+}
+
+static struct hardreg *find_in_reg(struct bb_state *state, pseudo_t pseudo)
+{
+	int i;
+	struct hardreg *reg;
+
+	for (i = 0; i < REGNO; i++) {
+		pseudo_t p;
+
+		reg = hardregs + i;
+		FOR_EACH_PTR(reg->contains, p) {
+			if (p == pseudo) {
+				last_reg = i;
+				output_comment(state, "found pseudo %s in reg %s (busy=%d)", show_pseudo(pseudo), reg->name, reg->busy);
+				return reg;
+			}
+		} END_FOR_EACH_PTR(p);
+	}
+	return NULL;
+}
+
+static void flush_pseudo(struct bb_state *state, pseudo_t pseudo, struct storage *storage)
+{
+	struct hardreg *reg = find_in_reg(state, pseudo);
+
+	if (reg)
+		flush_reg(state, reg);
+}
+
+static void flush_cc_cache_to_reg(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
+{
+	int opcode = state->cc_opcode;
+
+	state->cc_opcode = 0;
+	state->cc_target = NULL;
+	output_insn(state, "%s %s", opcodes[opcode], reg->name);
+}
+
+static void flush_cc_cache(struct bb_state *state)
+{
+	pseudo_t pseudo = state->cc_target;
+
+	if (pseudo) {
+		struct hardreg *dst;
+
+		state->cc_target = NULL;
+
+		if (!state->cc_dead) {
+			dst = target_reg(state, pseudo, pseudo);
+			flush_cc_cache_to_reg(state, pseudo, dst);
+		}
+	}
+}
+
+static void add_cc_cache(struct bb_state *state, int opcode, pseudo_t pseudo)
+{
+	assert(!state->cc_target);
+	state->cc_target = pseudo;
+	state->cc_opcode = opcode;
+	state->cc_dead = 0;
+	output_comment(state, "caching %s", opcodes[opcode]);
+}
+
+/* Fill a hardreg with the pseudo it has */
+static struct hardreg *fill_reg(struct bb_state *state, struct hardreg *hardreg, pseudo_t pseudo)
+{
+	struct storage_hash *src;
+	struct instruction *def;
+
+	if (state->cc_target == pseudo) {
+		flush_cc_cache_to_reg(state, pseudo, hardreg);
+		return hardreg;
+	}
+
+	switch (pseudo->type) {
+	case PSEUDO_VAL:
+		output_insn(state, "movl $%lld,%s", pseudo->value, hardreg->name);
+		break;
+	case PSEUDO_SYM:
+		src = find_pseudo_storage(state, pseudo, NULL);
+		/* Static thing? */
+		if (!src) {
+			output_insn(state, "movl $<%s>,%s", show_pseudo(pseudo), hardreg->name);
+			break;
+		}
+		switch (src->storage->type) {
+		case REG_REG:
+			/* Aiaiaiaiaii! Need to flush it to temporary memory */
+			src = find_or_create_hash(pseudo, &state->internal);
+			/* Fall through */
+		default:
+			alloc_stack(state, src->storage);
+			/* Fall through */
+		case REG_STACK:
+		case REG_FRAME:
+			flush_pseudo(state, pseudo, src->storage);
+			output_insn(state, "leal %s,%s", show_memop(src->storage), hardreg->name);
+			break;
+		}
+		break;
+	case PSEUDO_ARG:
+	case PSEUDO_REG:
+		def = pseudo->def;
+		if (def && def->opcode == OP_SETVAL) {
+			output_insn(state, "movl $<%s>,%s", show_pseudo(def->target), hardreg->name);
+			break;
+		}
+		src = find_pseudo_storage(state, pseudo, hardreg);
+		if (!src)
+			break;
+		if (src->flags & TAG_DEAD)
+			mark_reg_dead(state, pseudo, hardreg);
+		output_insn(state, "mov.%d %s,%s", 32, show_memop(src->storage), hardreg->name);
+		break;
+	default:
+		output_insn(state, "reload %s from %s", hardreg->name, show_pseudo(pseudo));
+		break;
+	}
+	return hardreg;
+}
+
+static struct hardreg *getreg(struct bb_state *state, pseudo_t pseudo, pseudo_t target)
+{
+	struct hardreg *reg;
+
+	reg = find_in_reg(state, pseudo);
+	if (reg)
+		return reg;
+	reg = target_reg(state, pseudo, target);
+	return fill_reg(state, reg, pseudo);
+}
+
+static void move_reg(struct bb_state *state, struct hardreg *src, struct hardreg *dst)
+{
+	output_insn(state, "movl %s,%s", src->name, dst->name);
+}
+
+static struct hardreg *copy_reg(struct bb_state *state, struct hardreg *src, pseudo_t target)
+{
+	int i;
+	struct hardreg *reg;
+
+	/* If the container has been killed off, just re-use it */
+	if (!src->contains)
+		return src;
+
+	/* If "src" only has one user, and the contents are dead, we can re-use it */
+	if (src->busy == 1 && src->dead == 1)
+		return src;
+
+	reg = preferred_reg(state, target);
+	if (reg && !reg->contains) {
+		output_comment(state, "copying %s to preferred target %s", show_pseudo(target), reg->name);
+		move_reg(state, src, reg);
+		return reg;
+	}
+
+	for (i = 0; i < REGNO; i++) {
+		reg = hardregs + i;
+		if (!reg->contains) {
+			output_comment(state, "copying %s to %s", show_pseudo(target), reg->name);
+			output_insn(state, "movl %s,%s", src->name, reg->name);
+			return reg;
+		}
+	}
+
+	flush_reg(state, src);
+	return src;
+}
+
+static void put_operand(struct bb_state *state, struct operand *op)
+{
+	switch (op->type) {
+	case OP_REG:
+		op->reg->busy--;
+		break;
+	case OP_ADDR:
+	case OP_MEM:
+		if (op->base)
+			op->base->busy--;
+		if (op->index)
+			op->index->busy--;
+		break;
+	default:
+		break;
+	}
+}
+
+static struct operand *alloc_op(void)
+{
+	struct operand *op = malloc(sizeof(*op));
+	memset(op, 0, sizeof(*op));
+	return op;
+}
+
+static struct operand *get_register_operand(struct bb_state *state, pseudo_t pseudo, pseudo_t target)
+{
+	struct operand *op = alloc_op();
+	op->type = OP_REG;
+	op->reg = getreg(state, pseudo, target);
+	op->reg->busy++;
+	return op;
+}
+
+static int get_sym_frame_offset(struct bb_state *state, pseudo_t pseudo)
+{
+	int offset = pseudo->nr;
+	if (offset < 0) {
+		offset = alloc_stack_offset(4);
+		pseudo->nr = offset;
+	}
+	return offset;
+}
+
+static struct operand *get_generic_operand(struct bb_state *state, pseudo_t pseudo)
+{
+	struct hardreg *reg;
+	struct storage *src;
+	struct storage_hash *hash;
+	struct operand *op = malloc(sizeof(*op));
+
+	memset(op, 0, sizeof(*op));
+	switch (pseudo->type) {
+	case PSEUDO_VAL:
+		op->type = OP_VAL;
+		op->value = pseudo->value;
+		break;
+
+	case PSEUDO_SYM: {
+		struct symbol *sym = pseudo->sym;
+		op->type = OP_ADDR;
+		if (sym->ctype.modifiers & MOD_NONLOCAL) {
+			op->sym = sym;
+			break;
+		}
+		op->base = hardregs + REG_EBP;
+		op->offset = get_sym_frame_offset(state, pseudo);
+		break;
+	}
+
+	default:
+		reg = find_in_reg(state, pseudo);
+		if (reg) {
+			op->type = OP_REG;
+			op->reg = reg;
+			reg->busy++;
+			break;
+		}
+		hash = find_pseudo_storage(state, pseudo, NULL);
+		if (!hash)
+			break;
+		src = hash->storage;
+		switch (src->type) {
+		case REG_REG:
+			op->type = OP_REG;
+			op->reg = hardregs + src->regno;
+			op->reg->busy++;
+			break;
+		case REG_FRAME:
+			op->type = OP_MEM;
+			op->offset = src->offset;
+			op->base = hardregs + REG_EBP;
+			break;
+		case REG_STACK:
+			op->type = OP_MEM;
+			op->offset = src->offset;
+			op->base = hardregs + REG_ESP;
+			break;
+		default:
+			break;
+		}
+	}
+	return op;
+}
+
+/* Callers should be made to use the proper "operand" formats */
+static const char *generic(struct bb_state *state, pseudo_t pseudo)
+{
+	struct hardreg *reg;
+	struct operand *op = get_generic_operand(state, pseudo);
+	static char buf[100];
+	const char *str;
+
+	switch (op->type) {
+	case OP_ADDR:
+		if (!op->offset && op->base && !op->sym)
+			return op->base->name;
+		if (op->sym && !op->base) {
+			int len = sprintf(buf, "$ %s", show_op(state, op));
+			if (op->offset)
+				sprintf(buf + len, " + %d", op->offset);
+			return buf;
+		}
+		str = show_op(state, op);
+		put_operand(state, op);
+		reg = target_reg(state, pseudo, NULL);
+		output_insn(state, "lea %s,%s", show_op(state, op), reg->name);
+		return reg->name;		
+
+	default:
+		str = show_op(state, op);
+	}
+	put_operand(state, op);
+	return str;
+}
+
+static struct operand *get_address_operand(struct bb_state *state, struct instruction *memop)
+{
+	struct hardreg *base;
+	struct operand *op = get_generic_operand(state, memop->src);
+
+	switch (op->type) {
+	case OP_ADDR:
+		op->offset += memop->offset;
+		break;
+	default:
+		put_operand(state, op);
+		base = getreg(state, memop->src, NULL);
+		op->type = OP_ADDR;
+		op->base = base;
+		base->busy++;
+		op->offset = memop->offset;
+		op->sym = NULL;
+	}
+	return op;
+}
+
+static const char *address(struct bb_state *state, struct instruction *memop)
+{
+	struct operand *op = get_address_operand(state, memop);
+	const char *str = show_op(state, op);
+	put_operand(state, op);
+	return str;
+}
+
+static const char *reg_or_imm(struct bb_state *state, pseudo_t pseudo)
+{
+	switch(pseudo->type) {
+	case PSEUDO_VAL:
+		return show_pseudo(pseudo);
+	default:
+		return getreg(state, pseudo, NULL)->name;
+	}
+}
+
+static void kill_dead_reg(struct hardreg *reg)
+{
+	if (reg->dead) {
+		pseudo_t p;
+		
+		FOR_EACH_PTR(reg->contains, p) {
+			if (CURRENT_TAG(p) & TAG_DEAD) {
+				DELETE_CURRENT_PTR(p);
+				reg->dead--;
+			}
+		} END_FOR_EACH_PTR(p);
+		PACK_PTR_LIST(&reg->contains);
+		assert(!reg->dead);
+	}
+}
+
+static struct hardreg *target_copy_reg(struct bb_state *state, struct hardreg *src, pseudo_t target)
+{
+	kill_dead_reg(src);
+	return copy_reg(state, src, target);
+}
+
+static void do_binop(struct bb_state *state, struct instruction *insn, pseudo_t val1, pseudo_t val2)
+{
+	const char *op = opcodes[insn->opcode];
+	struct operand *src = get_register_operand(state, val1, insn->target);
+	struct operand *src2 = get_generic_operand(state, val2);
+	struct hardreg *dst;
+
+	dst = target_copy_reg(state, src->reg, insn->target);
+	output_insn(state, "%s.%d %s,%s", op, insn->size, show_op(state, src2), dst->name);
+	put_operand(state, src);
+	put_operand(state, src2);
+	add_pseudo_reg(state, insn->target, dst);
+}
+
+static void generate_binop(struct bb_state *state, struct instruction *insn)
+{
+	flush_cc_cache(state);
+	do_binop(state, insn, insn->src1, insn->src2);
+}
+
+static int is_dead_reg(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
+{
+	pseudo_t p;
+	FOR_EACH_PTR(reg->contains, p) {
+		if (p == pseudo)
+			return CURRENT_TAG(p) & TAG_DEAD;
+	} END_FOR_EACH_PTR(p);
+	return 0;
+}
+
+/*
+ * Commutative binops are much more flexible, since we can switch the
+ * sources around to satisfy the target register, or to avoid having
+ * to load one of them into a register..
+ */
+static void generate_commutative_binop(struct bb_state *state, struct instruction *insn)
+{
+	pseudo_t src1, src2;
+	struct hardreg *reg1, *reg2;
+
+	flush_cc_cache(state);
+	src1 = insn->src1;
+	src2 = insn->src2;
+	reg2 = find_in_reg(state, src2);
+	if (!reg2)
+		goto dont_switch;
+	reg1 = find_in_reg(state, src1);
+	if (!reg1)
+		goto do_switch;
+	if (!is_dead_reg(state, src2, reg2))
+		goto dont_switch;
+	if (!is_dead_reg(state, src1, reg1))
+		goto do_switch;
+
+	/* Both are dead. Is one preferable? */
+	if (reg2 != preferred_reg(state, insn->target))
+		goto dont_switch;
+
+do_switch:
+	src1 = src2;
+	src2 = insn->src1;
+dont_switch:
+	do_binop(state, insn, src1, src2);
+}
+
+/*
+ * This marks a pseudo dead. It still stays on the hardreg list (the hardreg
+ * still has its value), but it's scheduled to be killed after the next
+ * "sequence point" when we call "kill_read_pseudos()"
+ */
+static void mark_pseudo_dead(struct bb_state *state, pseudo_t pseudo)
+{
+	int i;
+	struct storage_hash *src;
+
+	if (state->cc_target == pseudo)
+		state->cc_dead = 1;
+	src = find_pseudo_storage(state, pseudo, NULL);
+	if (src)
+		src->flags |= TAG_DEAD;
+	for (i = 0; i < REGNO; i++)
+		mark_reg_dead(state, pseudo, hardregs + i);
+}
+
+static void kill_dead_pseudos(struct bb_state *state)
+{
+	int i;
+
+	for (i = 0; i < REGNO; i++) {
+		kill_dead_reg(hardregs + i);
+	}
+}
+
+static void generate_store(struct instruction *insn, struct bb_state *state)
+{
+	output_insn(state, "mov.%d %s,%s", insn->size, reg_or_imm(state, insn->target), address(state, insn));
+}
+
+static void generate_load(struct instruction *insn, struct bb_state *state)
+{
+	const char *input = address(state, insn);
+	struct hardreg *dst;
+
+	kill_dead_pseudos(state);
+	dst = target_reg(state, insn->target, NULL);
+	output_insn(state, "mov.%d %s,%s", insn->size, input, dst->name);
+}
+
+static void kill_pseudo(struct bb_state *state, pseudo_t pseudo)
+{
+	int i;
+	struct hardreg *reg;
+
+	output_comment(state, "killing pseudo %s", show_pseudo(pseudo));
+	for (i = 0; i < REGNO; i++) {
+		pseudo_t p;
+
+		reg = hardregs + i;
+		FOR_EACH_PTR(reg->contains, p) {
+			if (p != pseudo)
+				continue;
+			if (CURRENT_TAG(p) & TAG_DEAD)
+				reg->dead--;
+			output_comment(state, "removing pseudo %s from reg %s", 
+				show_pseudo(pseudo), reg->name);
+			DELETE_CURRENT_PTR(p);
+		} END_FOR_EACH_PTR(p);
+		PACK_PTR_LIST(&reg->contains);
+	}
+}
+
+static void generate_copy(struct bb_state *state, struct instruction *insn)
+{
+	struct hardreg *src = getreg(state, insn->src, insn->target);
+	kill_pseudo(state, insn->target);
+	add_pseudo_reg(state, insn->target, src);
+}
+
+static void generate_cast(struct bb_state *state, struct instruction *insn)
+{
+	struct hardreg *src = getreg(state, insn->src, insn->target);
+	struct hardreg *dst;
+	unsigned int old = insn->orig_type ? insn->orig_type->bit_size : 0;
+	unsigned int new = insn->size;
+
+	/*
+	 * Cast to smaller type? Ignore the high bits, we
+	 * just keep both pseudos in the same register.
+	 */
+	if (old >= new) {
+		add_pseudo_reg(state, insn->target, src);
+		return;
+	}
+
+	dst = target_copy_reg(state, src, insn->target);
+
+	if (insn->orig_type && (insn->orig_type->ctype.modifiers & MOD_SIGNED)) {
+		output_insn(state, "sext.%d.%d %s", old, new, dst->name);
+	} else {
+		unsigned long long mask;
+		mask = ~(~0ULL << old);
+		mask &= ~(~0ULL << new);
+		output_insn(state, "andl.%d $%#llx,%s", insn->size, mask, dst->name);
+	}
+	add_pseudo_reg(state, insn->target, dst);
+}
+
+static void generate_output_storage(struct bb_state *state);
+
+static const char *conditional[] = {
+	[OP_SET_EQ] = "e",
+	[OP_SET_NE] = "ne",
+	[OP_SET_LE] = "le",
+	[OP_SET_GE] = "ge",
+	[OP_SET_LT] = "lt",
+	[OP_SET_GT] = "gt",
+	[OP_SET_B] = "b",
+	[OP_SET_A] = "a",
+	[OP_SET_BE] = "be",
+	[OP_SET_AE] = "ae"
+};
+	
+
+static void generate_branch(struct bb_state *state, struct instruction *br)
+{
+	const char *cond = "XXX";
+	struct basic_block *target;
+
+	if (br->cond) {
+		if (state->cc_target == br->cond) {
+			cond = conditional[state->cc_opcode];
+		} else {
+			struct hardreg *reg = getreg(state, br->cond, NULL);
+			output_insn(state, "testl %s,%s", reg->name, reg->name);
+			cond = "ne";
+		}
+	}
+	generate_output_storage(state);
+	target = br->bb_true;
+	if (br->cond) {
+		output_insn(state, "j%s .L%p", cond, target);
+		target = br->bb_false;
+	}
+	output_insn(state, "jmp .L%p", target);
+}
+
+/* We've made sure that there is a dummy reg live for the output */
+static void generate_switch(struct bb_state *state, struct instruction *insn)
+{
+	struct hardreg *reg = hardregs + SWITCH_REG;
+
+	generate_output_storage(state);
+	output_insn(state, "switch on %s", reg->name);
+	output_insn(state, "unimplemented: %s", show_instruction(insn));
+}
+
+static void generate_ret(struct bb_state *state, struct instruction *ret)
+{
+	if (ret->src && ret->src != VOID) {
+		struct hardreg *wants = hardregs+0;
+		struct hardreg *reg = getreg(state, ret->src, NULL);
+		if (reg != wants)
+			output_insn(state, "movl %s,%s", reg->name, wants->name);
+	}
+	output_insn(state, "ret");
+}
+
+/*
+ * Fake "call" linearization just as a taster..
+ */
+static void generate_call(struct bb_state *state, struct instruction *insn)
+{
+	int offset = 0;
+	pseudo_t arg;
+
+	FOR_EACH_PTR(insn->arguments, arg) {
+		output_insn(state, "pushl %s", generic(state, arg));
+		offset += 4;
+	} END_FOR_EACH_PTR(arg);
+	flush_reg(state, hardregs+0);
+	flush_reg(state, hardregs+1);
+	flush_reg(state, hardregs+2);
+	output_insn(state, "call %s", show_pseudo(insn->func));
+	if (offset)
+		output_insn(state, "addl $%d,%%esp", offset);
+	if (insn->target && insn->target != VOID)
+		add_pseudo_reg(state, insn->target, hardregs+0);
+}
+
+static void generate_select(struct bb_state *state, struct instruction *insn)
+{
+	const char *cond;
+	struct hardreg *src1, *src2, *dst;
+
+	src1 = getreg(state, insn->src2, NULL);
+	dst = copy_reg(state, src1, insn->target);
+	add_pseudo_reg(state, insn->target, dst);
+	src2 = getreg(state, insn->src3, insn->target);
+
+	if (state->cc_target == insn->src1) {
+		cond = conditional[state->cc_opcode];
+	} else {
+		struct hardreg *reg = getreg(state, insn->src1, NULL);
+		output_insn(state, "testl %s,%s", reg->name, reg->name);
+		cond = "ne";
+	}
+
+	output_insn(state, "sel%s %s,%s", cond, src2->name, dst->name);
+}
+
+struct asm_arg {
+	const struct ident *name;
+	const char *value;
+	pseudo_t pseudo;
+	struct hardreg *reg;
+};
+
+static void replace_asm_arg(char **dst_p, struct asm_arg *arg)
+{
+	char *dst = *dst_p;
+	int len = strlen(arg->value);
+
+	memcpy(dst, arg->value, len);
+	*dst_p = dst + len;
+}
+
+static void replace_asm_percent(const char **src_p, char **dst_p, struct asm_arg *args, int nr)
+{
+	const char *src = *src_p;
+	char c;
+	int index;
+
+	c = *src++;
+	switch (c) {
+	case '0' ... '9':
+		index = c - '0';
+		if (index < nr)
+			replace_asm_arg(dst_p, args+index);
+		break;
+	}	
+	*src_p = src;
+	return;
+}
+
+static void replace_asm_named(const char **src_p, char **dst_p, struct asm_arg *args, int nr)
+{
+	const char *src = *src_p;
+	const char *end = src;
+
+	for(;;) {
+		char c = *end++;
+		if (!c)
+			return;
+		if (c == ']') {
+			int i;
+
+			*src_p = end;
+			for (i = 0; i < nr; i++) {
+				const struct ident *ident = args[i].name;
+				int len;
+				if (!ident)
+					continue;
+				len = ident->len;
+				if (memcmp(src, ident->name, len))
+					continue;
+				replace_asm_arg(dst_p, args+i);
+				return;
+			}
+		}
+	}
+}
+
+static const char *replace_asm_args(const char *str, struct asm_arg *args, int nr)
+{
+	static char buffer[1000];
+	char *p = buffer;
+
+	for (;;) {
+		char c = *str;
+		*p = c;
+		if (!c)
+			return buffer;
+		str++;
+		switch (c) {
+		case '%':
+			if (*str == '%') {
+				str++;
+				p++;
+				continue;
+			}
+			replace_asm_percent(&str, &p, args, nr);
+			continue;
+		case '[':
+			replace_asm_named(&str, &p, args, nr);
+			continue;
+		default:
+			break;
+		}
+		p++;
+	}
+}
+
+#define MAX_ASM_ARG (50)
+static struct asm_arg asm_arguments[MAX_ASM_ARG];
+
+static struct asm_arg *generate_asm_inputs(struct bb_state *state, struct asm_constraint_list *list, struct asm_arg *arg)
+{
+	struct asm_constraint *entry;
+
+	FOR_EACH_PTR(list, entry) {
+		const char *constraint = entry->constraint;
+		pseudo_t pseudo = entry->pseudo;
+		struct hardreg *reg, *orig;
+		const char *string;
+		int index;
+
+		string = "undef";
+		switch (*constraint) {
+		case 'r':
+			string = getreg(state, pseudo, NULL)->name;
+			break;
+		case '0' ... '9':
+			index = *constraint - '0';
+			reg = asm_arguments[index].reg;
+			orig = find_in_reg(state, pseudo);
+			if (orig)
+				move_reg(state, orig, reg);
+			else
+				fill_reg(state, reg, pseudo);
+			string = reg->name;
+			break;
+		default:
+			string = generic(state, pseudo);
+			break;
+		}
+
+		output_insn(state, "# asm input \"%s\": %s : %s", constraint, show_pseudo(pseudo), string);
+
+		arg->name = entry->ident;
+		arg->value = string;
+		arg->pseudo = NULL;
+		arg->reg = NULL;
+		arg++;
+	} END_FOR_EACH_PTR(entry);
+	return arg;
+}
+
+static struct asm_arg *generate_asm_outputs(struct bb_state *state, struct asm_constraint_list *list, struct asm_arg *arg)
+{
+	struct asm_constraint *entry;
+
+	FOR_EACH_PTR(list, entry) {
+		const char *constraint = entry->constraint;
+		pseudo_t pseudo = entry->pseudo;
+		struct hardreg *reg;
+		const char *string;
+
+		while (*constraint == '=' || *constraint == '+')
+			constraint++;
+
+		string = "undef";
+		switch (*constraint) {
+		case 'r':
+		default:
+			reg = target_reg(state, pseudo, NULL);
+			arg->pseudo = pseudo;
+			arg->reg = reg;
+			string = reg->name;
+			break;
+		}
+
+		output_insn(state, "# asm output \"%s\": %s : %s", constraint, show_pseudo(pseudo), string);
+
+		arg->name = entry->ident;
+		arg->value = string;
+		arg++;
+	} END_FOR_EACH_PTR(entry);
+	return arg;
+}
+
+static void generate_asm(struct bb_state *state, struct instruction *insn)
+{
+	const char *str = insn->string;
+
+	if (insn->asm_rules->outputs || insn->asm_rules->inputs) {
+		struct asm_arg *arg;
+
+		arg = generate_asm_outputs(state, insn->asm_rules->outputs, asm_arguments);
+		arg = generate_asm_inputs(state, insn->asm_rules->inputs, arg);
+		str = replace_asm_args(str, asm_arguments, arg - asm_arguments);
+	}
+	output_insn(state, "%s", str);
+}
+
+static void generate_compare(struct bb_state *state, struct instruction *insn)
+{
+	struct hardreg *src;
+	const char *src2;
+	int opcode;
+
+	flush_cc_cache(state);
+	opcode = insn->opcode;
+
+	/*
+	 * We should try to switch these around if necessary,
+	 * and update the opcode to match..
+	 */
+	src = getreg(state, insn->src1, insn->target);
+	src2 = generic(state, insn->src2);
+
+	output_insn(state, "cmp.%d %s,%s", insn->size, src2, src->name);
+
+	add_cc_cache(state, opcode, insn->target);
+}
+
+static void generate_one_insn(struct instruction *insn, struct bb_state *state)
+{
+	if (verbose)
+		output_comment(state, "%s", show_instruction(insn));
+
+	switch (insn->opcode) {
+	case OP_ENTRY: {
+		struct symbol *sym = insn->bb->ep->name;
+		const char *name = show_ident(sym->ident);
+		if (sym->ctype.modifiers & MOD_STATIC)
+			printf("\n\n%s:\n", name);
+		else
+			printf("\n\n.globl %s\n%s:\n", name, name);
+		break;
+	}
+
+	/*
+	 * OP_SETVAL likewise doesn't actually generate any
+	 * code. On use, the "def" of the pseudo will be
+	 * looked up.
+	 */
+	case OP_SETVAL:
+		break;
+
+	case OP_STORE:
+		generate_store(insn, state);
+		break;
+
+	case OP_LOAD:
+		generate_load(insn, state);
+		break;
+
+	case OP_DEATHNOTE:
+		mark_pseudo_dead(state, insn->target);
+		return;
+
+	case OP_COPY:
+		generate_copy(state, insn);
+		break;
+
+	case OP_ADD: case OP_MULU: case OP_MULS:
+	case OP_AND: case OP_OR: case OP_XOR:
+	case OP_AND_BOOL: case OP_OR_BOOL:
+		generate_commutative_binop(state, insn);
+		break;
+
+	case OP_SUB: case OP_DIVU: case OP_DIVS:
+	case OP_MODU: case OP_MODS:
+	case OP_SHL: case OP_LSR: case OP_ASR:
+ 		generate_binop(state, insn);
+		break;
+
+	case OP_BINCMP ... OP_BINCMP_END:
+		generate_compare(state, insn);
+		break;
+
+	case OP_CAST: case OP_SCAST: case OP_FPCAST: case OP_PTRCAST:
+		generate_cast(state, insn);
+		break;
+
+	case OP_SEL:
+		generate_select(state, insn);
+		break;
+
+	case OP_BR:
+	case OP_CBR:
+		generate_branch(state, insn);
+		break;
+
+	case OP_SWITCH:
+		generate_switch(state, insn);
+		break;
+
+	case OP_CALL:
+		generate_call(state, insn);
+		break;
+
+	case OP_RET:
+		generate_ret(state, insn);
+		break;
+
+	case OP_ASM:
+		generate_asm(state, insn);
+		break;
+
+	case OP_PHI:
+	case OP_PHISOURCE:
+	default:
+		output_insn(state, "unimplemented: %s", show_instruction(insn));
+		break;
+	}
+	kill_dead_pseudos(state);
+}
+
+#define VERY_BUSY 1000
+#define REG_FIXED 2000
+
+static void write_reg_to_storage(struct bb_state *state, struct hardreg *reg, pseudo_t pseudo, struct storage *storage)
+{
+	int i;
+	struct hardreg *out;
+
+	switch (storage->type) {
+	case REG_REG:
+		out = hardregs + storage->regno;
+		if (reg == out)
+			return;
+		output_insn(state, "movl %s,%s", reg->name, out->name);
+		return;
+	case REG_UDEF:
+		if (reg->busy < VERY_BUSY) {
+			storage->type = REG_REG;
+			storage->regno = reg - hardregs;
+			reg->busy = REG_FIXED;
+			return;
+		}
+
+		/* Try to find a non-busy register.. */
+		for (i = 0; i < REGNO; i++) {
+			out = hardregs + i;
+			if (out->contains)
+				continue;
+			output_insn(state, "movl %s,%s", reg->name, out->name);
+			storage->type = REG_REG;
+			storage->regno = i;
+			out->busy = REG_FIXED;
+			return;
+		}
+
+		/* Fall back on stack allocation ... */
+		alloc_stack(state, storage);
+		/* Fall through */
+	default:
+		output_insn(state, "movl %s,%s", reg->name, show_memop(storage));
+		return;
+	}
+}
+
+static void write_val_to_storage(struct bb_state *state, pseudo_t src, struct storage *storage)
+{
+	struct hardreg *out;
+
+	switch (storage->type) {
+	case REG_UDEF:
+		alloc_stack(state, storage);
+	default:
+		output_insn(state, "movl %s,%s", show_pseudo(src), show_memop(storage));
+		break;
+	case REG_REG:
+		out = hardregs + storage->regno;
+		output_insn(state, "movl %s,%s", show_pseudo(src), out->name);
+	}
+}
+
+static void fill_output(struct bb_state *state, pseudo_t pseudo, struct storage *out)
+{
+	int i;
+	struct storage_hash *in;
+	struct instruction *def;
+
+	/* Is that pseudo a constant value? */
+	switch (pseudo->type) {
+	case PSEUDO_VAL:
+		write_val_to_storage(state, pseudo, out);
+		return;
+	case PSEUDO_REG:
+		def = pseudo->def;
+		if (def && def->opcode == OP_SETVAL) {
+			write_val_to_storage(state, pseudo, out);
+			return;
+		}
+	default:
+		break;
+	}
+
+	/* See if we have that pseudo in a register.. */
+	for (i = 0; i < REGNO; i++) {
+		struct hardreg *reg = hardregs + i;
+		pseudo_t p;
+
+		FOR_EACH_PTR(reg->contains, p) {
+			if (p == pseudo) {
+				write_reg_to_storage(state, reg, pseudo, out);
+				return;
+			}
+		} END_FOR_EACH_PTR(p);
+	}
+
+	/* Do we have it in another storage? */
+	in = find_storage_hash(pseudo, state->internal);
+	if (!in) {
+		in = find_storage_hash(pseudo, state->inputs);
+		/* Undefined? */
+		if (!in)
+			return;
+	}
+	switch (out->type) {
+	case REG_UDEF:
+		*out = *in->storage;
+		break;
+	case REG_REG:
+		output_insn(state, "movl %s,%s", show_memop(in->storage), hardregs[out->regno].name);
+		break;
+	default:
+		if (out == in->storage)
+			break;
+		if ((out->type == in->storage->type) && (out->regno == in->storage->regno))
+			break;
+		output_insn(state, "movl %s,%s", show_memop(in->storage), show_memop(out));
+		break;
+	}
+	return;
+}
+
+static int final_pseudo_flush(struct bb_state *state, pseudo_t pseudo, struct hardreg *reg)
+{
+	struct storage_hash *hash;
+	struct storage *out;
+	struct hardreg *dst;
+
+	/*
+	 * Since this pseudo is live at exit, we'd better have output 
+	 * storage for it..
+	 */
+	hash = find_storage_hash(pseudo, state->outputs);
+	if (!hash)
+		return 1;
+	out = hash->storage;
+
+	/* If the output is in a register, try to get it there.. */
+	if (out->type == REG_REG) {
+		dst = hardregs + out->regno;
+		/*
+		 * Two good cases: nobody is using the right register,
+		 * or we've already set it aside for output..
+		 */
+		if (!dst->contains || dst->busy > VERY_BUSY)
+			goto copy_to_dst;
+
+		/* Aiee. Try to keep it in a register.. */
+		dst = empty_reg(state);
+		if (dst)
+			goto copy_to_dst;
+
+		return 0;
+	}
+
+	/* If the output is undefined, let's see if we can put it in a register.. */
+	if (out->type == REG_UDEF) {
+		dst = empty_reg(state);
+		if (dst) {
+			out->type = REG_REG;
+			out->regno = dst - hardregs;
+			goto copy_to_dst;
+		}
+		/* Uhhuh. Not so good. No empty registers right now */
+		return 0;
+	}
+
+	/* If we know we need to flush it, just do so already .. */
+	output_insn(state, "movl %s,%s", reg->name, show_memop(out));
+	return 1;
+
+copy_to_dst:
+	if (reg == dst)
+		return 1;
+	output_insn(state, "movl %s,%s", reg->name, dst->name);
+	add_pseudo_reg(state, pseudo, dst);
+	return 1;
+}
+
+/*
+ * This tries to make sure that we put all the pseudos that are
+ * live on exit into the proper storage
+ */
+static void generate_output_storage(struct bb_state *state)
+{
+	struct storage_hash *entry;
+
+	/* Go through the fixed outputs, making sure we have those regs free */
+	FOR_EACH_PTR(state->outputs, entry) {
+		struct storage *out = entry->storage;
+		if (out->type == REG_REG) {
+			struct hardreg *reg = hardregs + out->regno;
+			pseudo_t p;
+			int flushme = 0;
+
+			reg->busy = REG_FIXED;
+			FOR_EACH_PTR(reg->contains, p) {
+				if (p == entry->pseudo) {
+					flushme = -100;
+					continue;
+				}
+				if (CURRENT_TAG(p) & TAG_DEAD)
+					continue;
+
+				/* Try to write back the pseudo to where it should go ... */
+				if (final_pseudo_flush(state, p, reg)) {
+					DELETE_CURRENT_PTR(p);
+					continue;
+				}
+				flushme++;
+			} END_FOR_EACH_PTR(p);
+			PACK_PTR_LIST(&reg->contains);
+			if (flushme > 0)
+				flush_reg(state, reg);
+		}
+	} END_FOR_EACH_PTR(entry);
+
+	FOR_EACH_PTR(state->outputs, entry) {
+		fill_output(state, entry->pseudo, entry->storage);
+	} END_FOR_EACH_PTR(entry);
+}
+
+static void generate(struct basic_block *bb, struct bb_state *state)
+{
+	int i;
+	struct storage_hash *entry;
+	struct instruction *insn;
+
+	for (i = 0; i < REGNO; i++) {
+		free_ptr_list(&hardregs[i].contains);
+		hardregs[i].busy = 0;
+		hardregs[i].dead = 0;
+		hardregs[i].used = 0;
+	}
+
+	FOR_EACH_PTR(state->inputs, entry) {
+		struct storage *storage = entry->storage;
+		const char *name = show_storage(storage);
+		output_comment(state, "incoming %s in %s", show_pseudo(entry->pseudo), name);
+		if (storage->type == REG_REG) {
+			int regno = storage->regno;
+			add_pseudo_reg(state, entry->pseudo, hardregs + regno);
+			name = hardregs[regno].name;
+		}
+	} END_FOR_EACH_PTR(entry);
+
+	output_label(state, ".L%p", bb);
+	FOR_EACH_PTR(bb->insns, insn) {
+		if (!insn->bb)
+			continue;
+		generate_one_insn(insn, state);
+	} END_FOR_EACH_PTR(insn);
+
+	if (verbose) {
+		output_comment(state, "--- in ---");
+		FOR_EACH_PTR(state->inputs, entry) {
+			output_comment(state, "%s <- %s", show_pseudo(entry->pseudo), show_storage(entry->storage));
+		} END_FOR_EACH_PTR(entry);
+		output_comment(state, "--- spill ---");
+		FOR_EACH_PTR(state->internal, entry) {
+			output_comment(state, "%s <-> %s", show_pseudo(entry->pseudo), show_storage(entry->storage));
+		} END_FOR_EACH_PTR(entry);
+		output_comment(state, "--- out ---");
+		FOR_EACH_PTR(state->outputs, entry) {
+			output_comment(state, "%s -> %s", show_pseudo(entry->pseudo), show_storage(entry->storage));
+		} END_FOR_EACH_PTR(entry);
+	}
+	printf("\n");
+}
+
+static void generate_list(struct basic_block_list *list, unsigned long generation)
+{
+	struct basic_block *bb;
+	FOR_EACH_PTR(list, bb) {
+		if (bb->generation == generation)
+			continue;
+		output_bb(bb, generation);
+	} END_FOR_EACH_PTR(bb);
+}
+
+/*
+ * Mark all the output registers of all the parents
+ * as being "used" - this does not mean that we cannot
+ * re-use them, but it means that we cannot ask the
+ * parents to pass in another pseudo in one of those
+ * registers that it already uses for another child.
+ */
+static void mark_used_registers(struct basic_block *bb, struct bb_state *state)
+{
+	struct basic_block *parent;
+
+	FOR_EACH_PTR(bb->parents, parent) {
+		struct storage_hash_list *outputs = gather_storage(parent, STOR_OUT);
+		struct storage_hash *entry;
+
+		FOR_EACH_PTR(outputs, entry) {
+			struct storage *s = entry->storage;
+			if (s->type == REG_REG) {
+				struct hardreg *reg = hardregs + s->regno;
+				reg->used = 1;
+			}
+		} END_FOR_EACH_PTR(entry);
+	} END_FOR_EACH_PTR(parent);
+}
+
+static void output_bb(struct basic_block *bb, unsigned long generation)
+{
+	struct bb_state state;
+
+	bb->generation = generation;
+
+	/* Make sure all parents have been generated first */
+	generate_list(bb->parents, generation);
+
+	state.pos = bb->pos;
+	state.inputs = gather_storage(bb, STOR_IN);
+	state.outputs = gather_storage(bb, STOR_OUT);
+	state.internal = NULL;
+	state.cc_opcode = 0;
+	state.cc_target = NULL;
+
+	/* Mark incoming registers used */
+	mark_used_registers(bb, &state);
+
+	generate(bb, &state);
+
+	free_ptr_list(&state.inputs);
+	free_ptr_list(&state.outputs);
+
+	/* Generate all children... */
+	generate_list(bb->children, generation);
+}
+
+/*
+ * We should set up argument sources here..
+ *
+ * Things like "first three arguments in registers" etc
+ * are all for this place.
+ *
+ * On x86, we default to stack, unless it's a static
+ * function that doesn't have its address taken.
+ *
+ * I should implement the -mregparm=X cmd line option.
+ */
+static void set_up_arch_entry(struct entrypoint *ep, struct instruction *entry)
+{
+	pseudo_t arg;
+	struct symbol *sym, *argtype;
+	int i, offset, regparm;
+
+	sym = ep->name;
+	regparm = 0;
+	if (!(sym->ctype.modifiers & MOD_ADDRESSABLE))
+		regparm = 3;
+	sym = sym->ctype.base_type;
+	i = 0;
+	offset = 0;
+	PREPARE_PTR_LIST(sym->arguments, argtype);
+	FOR_EACH_PTR(entry->arg_list, arg) {
+		struct storage *in = lookup_storage(entry->bb, arg, STOR_IN);
+		if (!in) {
+			in = alloc_storage();
+			add_storage(in, entry->bb, arg, STOR_IN);
+		}
+		if (i < regparm) {
+			in->type = REG_REG;
+			in->regno = i;
+		} else {
+			int bits = argtype ? argtype->bit_size : 0;
+
+			if (bits < bits_in_int)
+				bits = bits_in_int;
+
+			in->type = REG_FRAME;
+			in->offset = offset;
+			
+			offset += bits_to_bytes(bits);
+		}
+		i++;
+		NEXT_PTR_LIST(argtype);
+	} END_FOR_EACH_PTR(arg);
+	FINISH_PTR_LIST(argtype);
+}
+
+/*
+ * Set up storage information for "return"
+ *
+ * Not strictly necessary, since the code generator will
+ * certainly move the return value to the right register,
+ * but it can help register allocation if the allocator
+ * sees that the target register is going to return in %eax.
+ */
+static void set_up_arch_exit(struct basic_block *bb, struct instruction *ret)
+{
+	pseudo_t pseudo = ret->src;
+
+	if (pseudo && pseudo != VOID) {
+		struct storage *out = lookup_storage(bb, pseudo, STOR_OUT);
+		if (!out) {
+			out = alloc_storage();
+			add_storage(out, bb, pseudo, STOR_OUT);
+		}
+		out->type = REG_REG;
+		out->regno = 0;
+	}
+}
+
+/*
+ * Set up dummy/silly output storage information for a switch
+ * instruction. We need to make sure that a register is available
+ * when we generate code for switch, so force that by creating
+ * a dummy output rule.
+ */
+static void set_up_arch_switch(struct basic_block *bb, struct instruction *insn)
+{
+	pseudo_t pseudo = insn->cond;
+	struct storage *out = lookup_storage(bb, pseudo, STOR_OUT);
+	if (!out) {
+		out = alloc_storage();
+		add_storage(out, bb, pseudo, STOR_OUT);
+	}
+	out->type = REG_REG;
+	out->regno = SWITCH_REG;
+}
+
+static void arch_set_up_storage(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+
+	/* Argument storage etc.. */
+	set_up_arch_entry(ep, ep->entry);
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		struct instruction *insn = last_instruction(bb->insns);
+		if (!insn)
+			continue;
+		switch (insn->opcode) {
+		case OP_RET:
+			set_up_arch_exit(bb, insn);
+			break;
+		case OP_SWITCH:
+			set_up_arch_switch(bb, insn);
+			break;
+		default:
+			/* nothing */;
+		}
+	} END_FOR_EACH_PTR(bb);
+}
+
+static void output(struct entrypoint *ep)
+{
+	unsigned long generation = ++bb_generation;
+
+	last_reg = -1;
+	stack_offset = 0;
+
+	/* Get rid of SSA form (phinodes etc) */
+	unssa(ep);
+
+	/* Set up initial inter-bb storage links */
+	set_up_storage(ep);
+
+	/* Architecture-specific storage rules.. */
+	arch_set_up_storage(ep);
+
+	/* Show the results ... */
+	output_bb(ep->entry->bb, generation);
+
+	/* Clear the storage hashes for the next function.. */
+	free_storage();
+}
+
+static int compile(struct symbol_list *list)
+{
+	struct symbol *sym;
+	FOR_EACH_PTR(list, sym) {
+		struct entrypoint *ep;
+		expand_symbol(sym);
+		ep = linearize_symbol(sym);
+		if (ep)
+			output(ep);
+	} END_FOR_EACH_PTR(sym);
+	
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	char *file;
+
+	compile(sparse_initialize(argc, argv, &filelist));
+	dbg_dead = 1;
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		compile(sparse(file));
+	} END_FOR_EACH_PTR_NOTAG(file);
+	return 0;
+}
+
diff --git a/usr/src/tools/smatch/src/expand.c b/usr/src/tools/smatch/src/expand.c
new file mode 100644
index 0000000000..4113e83cb6
--- /dev/null
+++ b/usr/src/tools/smatch/src/expand.c
@@ -0,0 +1,1321 @@
+/*
+ * sparse/expand.c
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * expand constant expressions.
+ */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "parse.h"
+#include "token.h"
+#include "symbol.h"
+#include "target.h"
+#include "expression.h"
+#include "expand.h"
+
+
+static int expand_expression(struct expression *);
+static int expand_statement(struct statement *);
+static int conservative;
+
+static int expand_symbol_expression(struct expression *expr)
+{
+	struct symbol *sym = expr->symbol;
+
+	if (sym == &zero_int) {
+		if (Wundef)
+			warning(expr->pos, "undefined preprocessor identifier '%s'", show_ident(expr->symbol_name));
+		expr->type = EXPR_VALUE;
+		expr->value = 0;
+		expr->taint = 0;
+		return 0;
+	}
+	/* The cost of a symbol expression is lower for on-stack symbols */
+	return (sym->ctype.modifiers & (MOD_STATIC | MOD_EXTERN)) ? 2 : 1;
+}
+
+static long long get_longlong(struct expression *expr)
+{
+	int no_expand = expr->ctype->ctype.modifiers & MOD_UNSIGNED;
+	long long mask = 1ULL << (expr->ctype->bit_size - 1);
+	long long value = expr->value;
+	long long ormask, andmask;
+
+	if (!(value & mask))
+		no_expand = 1;
+	andmask = mask | (mask-1);
+	ormask = ~andmask;
+	if (no_expand)
+		ormask = 0;
+	return (value & andmask) | ormask;
+}
+
+void cast_value(struct expression *expr, struct symbol *newtype,
+		struct expression *old, struct symbol *oldtype)
+{
+	int old_size = oldtype->bit_size;
+	int new_size = newtype->bit_size;
+	long long value, mask, signmask;
+	long long oldmask, oldsignmask, dropped;
+
+	if (is_float_type(newtype) || is_float_type(oldtype))
+		goto Float;
+
+	// For pointers and integers, we can just move the value around
+	expr->type = EXPR_VALUE;
+	expr->taint = old->taint;
+	if (old_size == new_size) {
+		expr->value = old->value;
+		return;
+	}
+
+	// expand it to the full "long long" value
+	value = get_longlong(old);
+
+Int:
+	// _Bool requires a zero test rather than truncation.
+	if (is_bool_type(newtype)) {
+		expr->value = !!value;
+		if (!conservative && value != 0 && value != 1)
+			warning(old->pos, "odd constant _Bool cast (%llx becomes 1)", value);
+		return;
+	}
+
+	// Truncate it to the new size
+	signmask = 1ULL << (new_size-1);
+	mask = signmask | (signmask-1);
+	expr->value = value & mask;
+
+	// Stop here unless checking for truncation
+	if (!Wcast_truncate || conservative)
+		return;
+	
+	// Check if we dropped any bits..
+	oldsignmask = 1ULL << (old_size-1);
+	oldmask = oldsignmask | (oldsignmask-1);
+	dropped = oldmask & ~mask;
+
+	// OK if the bits were (and still are) purely sign bits
+	if (value & dropped) {
+		if (!(value & oldsignmask) || !(value & signmask) || (value & dropped) != dropped)
+			warning(old->pos, "cast truncates bits from constant value (%llx becomes %llx)",
+				value & oldmask,
+				value & mask);
+	}
+	return;
+
+Float:
+	if (!is_float_type(newtype)) {
+		value = (long long)old->fvalue;
+		expr->type = EXPR_VALUE;
+		expr->taint = 0;
+		goto Int;
+	}
+
+	if (!is_float_type(oldtype))
+		expr->fvalue = (long double)get_longlong(old);
+	else
+		expr->fvalue = old->fvalue;
+
+	if (!(newtype->ctype.modifiers & MOD_LONGLONG) && \
+	    !(newtype->ctype.modifiers & MOD_LONGLONGLONG)) {
+		if ((newtype->ctype.modifiers & MOD_LONG))
+			expr->fvalue = (double)expr->fvalue;
+		else
+			expr->fvalue = (float)expr->fvalue;
+	}
+	expr->type = EXPR_FVALUE;
+}
+
+static int check_shift_count(struct expression *expr, struct symbol *ctype, unsigned int count)
+{
+	warning(expr->pos, "shift too big (%u) for type %s", count, show_typename(ctype));
+	count &= ctype->bit_size-1;
+	return count;
+}
+
+/*
+ * CAREFUL! We need to get the size and sign of the
+ * result right!
+ */
+#define CONVERT(op,s)	(((op)<<1)+(s))
+#define SIGNED(op)	CONVERT(op, 1)
+#define UNSIGNED(op)	CONVERT(op, 0)
+static int simplify_int_binop(struct expression *expr, struct symbol *ctype)
+{
+	struct expression *left = expr->left, *right = expr->right;
+	unsigned long long v, l, r, mask;
+	signed long long sl, sr;
+	int is_signed;
+
+	if (right->type != EXPR_VALUE)
+		return 0;
+	r = right->value;
+	if (expr->op == SPECIAL_LEFTSHIFT || expr->op == SPECIAL_RIGHTSHIFT) {
+		if (r >= ctype->bit_size) {
+			if (conservative)
+				return 0;
+			r = check_shift_count(expr, ctype, r);
+			right->value = r;
+		}
+	}
+	if (left->type != EXPR_VALUE)
+		return 0;
+	l = left->value; r = right->value;
+	is_signed = !(ctype->ctype.modifiers & MOD_UNSIGNED);
+	mask = 1ULL << (ctype->bit_size-1);
+	sl = l; sr = r;
+	if (is_signed && (sl & mask))
+		sl |= ~(mask-1);
+	if (is_signed && (sr & mask))
+		sr |= ~(mask-1);
+	
+	switch (CONVERT(expr->op,is_signed)) {
+	case SIGNED('+'):
+	case UNSIGNED('+'):
+		v = l + r;
+		break;
+
+	case SIGNED('-'):
+	case UNSIGNED('-'):
+		v = l - r;
+		break;
+
+	case SIGNED('&'):
+	case UNSIGNED('&'):
+		v = l & r;
+		break;
+
+	case SIGNED('|'):
+	case UNSIGNED('|'):
+		v = l | r;
+		break;
+
+	case SIGNED('^'):
+	case UNSIGNED('^'):
+		v = l ^ r;
+		break;
+
+	case SIGNED('*'):
+		v = sl * sr;
+		break;
+
+	case UNSIGNED('*'):
+		v = l * r;
+		break;
+
+	case SIGNED('/'):
+		if (!r)
+			goto Div;
+		if (l == mask && sr == -1)
+			goto Overflow;
+		v = sl / sr;
+		break;
+
+	case UNSIGNED('/'):
+		if (!r) goto Div;
+		v = l / r; 
+		break;
+
+	case SIGNED('%'):
+		if (!r)
+			goto Div;
+		if (l == mask && sr == -1)
+			goto Overflow;
+		v = sl % sr;
+		break;
+
+	case UNSIGNED('%'):
+		if (!r) goto Div;
+		v = l % r;
+		break;
+
+	case SIGNED(SPECIAL_LEFTSHIFT):
+	case UNSIGNED(SPECIAL_LEFTSHIFT):
+		v = l << r;
+		break; 
+
+	case SIGNED(SPECIAL_RIGHTSHIFT):
+		v = sl >> r;
+		break;
+
+	case UNSIGNED(SPECIAL_RIGHTSHIFT):
+		v = l >> r;
+		break;
+
+	default:
+		return 0;
+	}
+	mask = mask | (mask-1);
+	expr->value = v & mask;
+	expr->type = EXPR_VALUE;
+	expr->taint = left->taint | right->taint;
+	return 1;
+Div:
+	if (!conservative)
+		warning(expr->pos, "division by zero");
+	return 0;
+Overflow:
+	if (!conservative)
+		warning(expr->pos, "constant integer operation overflow");
+	return 0;
+}
+
+static int simplify_cmp_binop(struct expression *expr, struct symbol *ctype)
+{
+	struct expression *left = expr->left, *right = expr->right;
+	unsigned long long l, r, mask;
+	signed long long sl, sr;
+
+	if (left->type != EXPR_VALUE || right->type != EXPR_VALUE)
+		return 0;
+	l = left->value; r = right->value;
+	mask = 1ULL << (ctype->bit_size-1);
+	sl = l; sr = r;
+	if (sl & mask)
+		sl |= ~(mask-1);
+	if (sr & mask)
+		sr |= ~(mask-1);
+	switch (expr->op) {
+	case '<':		expr->value = sl < sr; break;
+	case '>':		expr->value = sl > sr; break;
+	case SPECIAL_LTE:	expr->value = sl <= sr; break;
+	case SPECIAL_GTE:	expr->value = sl >= sr; break;
+	case SPECIAL_EQUAL:	expr->value = l == r; break;
+	case SPECIAL_NOTEQUAL:	expr->value = l != r; break;
+	case SPECIAL_UNSIGNED_LT:expr->value = l < r; break;
+	case SPECIAL_UNSIGNED_GT:expr->value = l > r; break;
+	case SPECIAL_UNSIGNED_LTE:expr->value = l <= r; break;
+	case SPECIAL_UNSIGNED_GTE:expr->value = l >= r; break;
+	}
+	expr->type = EXPR_VALUE;
+	expr->taint = left->taint | right->taint;
+	return 1;
+}
+
+static int simplify_float_binop(struct expression *expr)
+{
+	struct expression *left = expr->left, *right = expr->right;
+	unsigned long mod = expr->ctype->ctype.modifiers;
+	long double l, r, res;
+
+	if (left->type != EXPR_FVALUE || right->type != EXPR_FVALUE)
+		return 0;
+
+	l = left->fvalue;
+	r = right->fvalue;
+
+	if (mod & MOD_LONGLONG) {
+		switch (expr->op) {
+		case '+':	res = l + r; break;
+		case '-':	res = l - r; break;
+		case '*':	res = l * r; break;
+		case '/':	if (!r) goto Div;
+				res = l / r; break;
+		default: return 0;
+		}
+	} else if (mod & MOD_LONG) {
+		switch (expr->op) {
+		case '+':	res = (double) l + (double) r; break;
+		case '-':	res = (double) l - (double) r; break;
+		case '*':	res = (double) l * (double) r; break;
+		case '/':	if (!r) goto Div;
+				res = (double) l / (double) r; break;
+		default: return 0;
+		}
+	} else {
+		switch (expr->op) {
+		case '+':	res = (float)l + (float)r; break;
+		case '-':	res = (float)l - (float)r; break;
+		case '*':	res = (float)l * (float)r; break;
+		case '/':	if (!r) goto Div;
+				res = (float)l / (float)r; break;
+		default: return 0;
+		}
+	}
+	expr->type = EXPR_FVALUE;
+	expr->fvalue = res;
+	return 1;
+Div:
+	if (!conservative)
+		warning(expr->pos, "division by zero");
+	return 0;
+}
+
+static int simplify_float_cmp(struct expression *expr, struct symbol *ctype)
+{
+	struct expression *left = expr->left, *right = expr->right;
+	long double l, r;
+
+	if (left->type != EXPR_FVALUE || right->type != EXPR_FVALUE)
+		return 0;
+
+	l = left->fvalue;
+	r = right->fvalue;
+	switch (expr->op) {
+	case '<':		expr->value = l < r; break;
+	case '>':		expr->value = l > r; break;
+	case SPECIAL_LTE:	expr->value = l <= r; break;
+	case SPECIAL_GTE:	expr->value = l >= r; break;
+	case SPECIAL_EQUAL:	expr->value = l == r; break;
+	case SPECIAL_NOTEQUAL:	expr->value = l != r; break;
+	}
+	expr->type = EXPR_VALUE;
+	expr->taint = 0;
+	return 1;
+}
+
+static int expand_binop(struct expression *expr)
+{
+	int cost;
+
+	cost = expand_expression(expr->left);
+	cost += expand_expression(expr->right);
+	if (simplify_int_binop(expr, expr->ctype))
+		return 0;
+	if (simplify_float_binop(expr))
+		return 0;
+	return cost + 1;
+}
+
+static int expand_logical(struct expression *expr)
+{
+	struct expression *left = expr->left;
+	struct expression *right;
+	int cost, rcost;
+
+	/* Do immediate short-circuiting ... */
+	cost = expand_expression(left);
+	if (left->type == EXPR_VALUE) {
+		if (expr->op == SPECIAL_LOGICAL_AND) {
+			if (!left->value) {
+				expr->type = EXPR_VALUE;
+				expr->value = 0;
+				expr->taint = left->taint;
+				return 0;
+			}
+		} else {
+			if (left->value) {
+				expr->type = EXPR_VALUE;
+				expr->value = 1;
+				expr->taint = left->taint;
+				return 0;
+			}
+		}
+	}
+
+	right = expr->right;
+	rcost = expand_expression(right);
+	if (left->type == EXPR_VALUE && right->type == EXPR_VALUE) {
+		/*
+		 * We know the left value doesn't matter, since
+		 * otherwise we would have short-circuited it..
+		 */
+		expr->type = EXPR_VALUE;
+		expr->value = right->value != 0;
+		expr->taint = left->taint | right->taint;
+		return 0;
+	}
+
+	/*
+	 * If the right side is safe and cheaper than a branch,
+	 * just avoid the branch and turn it into a regular binop
+	 * style SAFELOGICAL.
+	 */
+	if (rcost < BRANCH_COST) {
+		expr->type = EXPR_BINOP;
+		rcost -= BRANCH_COST - 1;
+	}
+
+	return cost + BRANCH_COST + rcost;
+}
+
+static int expand_comma(struct expression *expr)
+{
+	int cost;
+
+	cost = expand_expression(expr->left);
+	cost += expand_expression(expr->right);
+	if (expr->left->type == EXPR_VALUE || expr->left->type == EXPR_FVALUE) {
+		unsigned flags = expr->flags;
+		unsigned taint;
+		taint = expr->left->type == EXPR_VALUE ? expr->left->taint : 0;
+		*expr = *expr->right;
+		expr->flags = flags;
+		if (expr->type == EXPR_VALUE)
+			expr->taint |= Taint_comma | taint;
+	}
+	return cost;
+}
+
+#define MOD_IGN (MOD_VOLATILE | MOD_CONST)
+
+static int compare_types(int op, struct symbol *left, struct symbol *right)
+{
+	struct ctype c1 = {.base_type = left};
+	struct ctype c2 = {.base_type = right};
+	switch (op) {
+	case SPECIAL_EQUAL:
+		return !type_difference(&c1, &c2, MOD_IGN, MOD_IGN);
+	case SPECIAL_NOTEQUAL:
+		return type_difference(&c1, &c2, MOD_IGN, MOD_IGN) != NULL;
+	case '<':
+		return left->bit_size < right->bit_size;
+	case '>':
+		return left->bit_size > right->bit_size;
+	case SPECIAL_LTE:
+		return left->bit_size <= right->bit_size;
+	case SPECIAL_GTE:
+		return left->bit_size >= right->bit_size;
+	}
+	return 0;
+}
+
+static int expand_compare(struct expression *expr)
+{
+	struct expression *left = expr->left, *right = expr->right;
+	int cost;
+
+	cost = expand_expression(left);
+	cost += expand_expression(right);
+
+	if (left && right) {
+		/* Type comparison? */
+		if (left->type == EXPR_TYPE && right->type == EXPR_TYPE) {
+			int op = expr->op;
+			expr->type = EXPR_VALUE;
+			expr->value = compare_types(op, left->symbol, right->symbol);
+			expr->taint = 0;
+			return 0;
+		}
+		if (simplify_cmp_binop(expr, left->ctype))
+			return 0;
+		if (simplify_float_cmp(expr, left->ctype))
+			return 0;
+	}
+	return cost + 1;
+}
+
+static int expand_conditional(struct expression *expr)
+{
+	struct expression *cond = expr->conditional;
+	struct expression *true = expr->cond_true;
+	struct expression *false = expr->cond_false;
+	int cost, cond_cost;
+
+	cond_cost = expand_expression(cond);
+	if (cond->type == EXPR_VALUE) {
+		unsigned flags = expr->flags;
+		if (!cond->value)
+			true = false;
+		if (!true)
+			true = cond;
+		cost = expand_expression(true);
+		*expr = *true;
+		expr->flags = flags;
+		if (expr->type == EXPR_VALUE)
+			expr->taint |= cond->taint;
+		return cost;
+	}
+
+	cost = expand_expression(true);
+	cost += expand_expression(false);
+
+	if (cost < SELECT_COST) {
+		expr->type = EXPR_SELECT;
+		cost -= BRANCH_COST - 1;
+	}
+
+	return cost + cond_cost + BRANCH_COST;
+}
+		
+static int expand_assignment(struct expression *expr)
+{
+	expand_expression(expr->left);
+	expand_expression(expr->right);
+	return SIDE_EFFECTS;
+}
+
+static int expand_addressof(struct expression *expr)
+{
+	return expand_expression(expr->unop);
+}
+
+/*
+ * Look up a trustable initializer value at the requested offset.
+ *
+ * Return NULL if no such value can be found or statically trusted.
+ *
+ * FIXME!! We should check that the size is right!
+ */
+static struct expression *constant_symbol_value(struct symbol *sym, int offset)
+{
+	struct expression *value;
+
+	if (sym->ctype.modifiers & (MOD_ASSIGNED | MOD_ADDRESSABLE))
+		return NULL;
+	value = sym->initializer;
+	if (!value)
+		return NULL;
+	if (value->type == EXPR_INITIALIZER) {
+		struct expression *entry;
+		FOR_EACH_PTR(value->expr_list, entry) {
+			if (entry->type != EXPR_POS) {
+				if (offset)
+					continue;
+				return entry;
+			}
+			if (entry->init_offset < offset)
+				continue;
+			if (entry->init_offset > offset)
+				return NULL;
+			return entry->init_expr;
+		} END_FOR_EACH_PTR(entry);
+		return NULL;
+	}
+	return value;
+}
+
+static int expand_dereference(struct expression *expr)
+{
+	struct expression *unop = expr->unop;
+	unsigned int offset;
+
+	expand_expression(unop);
+
+	/*
+	 * NOTE! We get a bogus warning right now for some special
+	 * cases: apparently I've screwed up the optimization of
+	 * a zero-offset dereference, and the ctype is wrong.
+	 *
+	 * Leave the warning in anyway, since this is also a good
+	 * test for me to get the type evaluation right..
+	 */
+	if (expr->ctype->ctype.modifiers & MOD_NODEREF)
+		warning(unop->pos, "dereference of noderef expression");
+
+	/*
+	 * Is it "symbol" or "symbol + offset"?
+	 */
+	offset = 0;
+	if (unop->type == EXPR_BINOP && unop->op == '+') {
+		struct expression *right = unop->right;
+		if (right->type == EXPR_VALUE) {
+			offset = right->value;
+			unop = unop->left;
+		}
+	}
+
+	if (unop->type == EXPR_SYMBOL) {
+		struct symbol *sym = unop->symbol;
+		struct expression *value = constant_symbol_value(sym, offset);
+
+		/* Const symbol with a constant initializer? */
+		if (value) {
+			/* FIXME! We should check that the size is right! */
+			if (value->type == EXPR_VALUE) {
+				expr->type = EXPR_VALUE;
+				expr->value = value->value;
+				expr->taint = 0;
+				return 0;
+			} else if (value->type == EXPR_FVALUE) {
+				expr->type = EXPR_FVALUE;
+				expr->fvalue = value->fvalue;
+				return 0;
+			}
+		}
+
+		/* Direct symbol dereference? Cheap and safe */
+		return (sym->ctype.modifiers & (MOD_STATIC | MOD_EXTERN)) ? 2 : 1;
+	}
+
+	return UNSAFE;
+}
+
+static int simplify_preop(struct expression *expr)
+{
+	struct expression *op = expr->unop;
+	unsigned long long v, mask;
+
+	if (op->type != EXPR_VALUE)
+		return 0;
+
+	mask = 1ULL << (expr->ctype->bit_size-1);
+	v = op->value;
+	switch (expr->op) {
+	case '+': break;
+	case '-':
+		if (v == mask && !(expr->ctype->ctype.modifiers & MOD_UNSIGNED))
+			goto Overflow;
+		v = -v;
+		break;
+	case '!': v = !v; break;
+	case '~': v = ~v; break;
+	default: return 0;
+	}
+	mask = mask | (mask-1);
+	expr->value = v & mask;
+	expr->type = EXPR_VALUE;
+	expr->taint = op->taint;
+	return 1;
+
+Overflow:
+	if (!conservative)
+		warning(expr->pos, "constant integer operation overflow");
+	return 0;
+}
+
+static int simplify_float_preop(struct expression *expr)
+{
+	struct expression *op = expr->unop;
+	long double v;
+
+	if (op->type != EXPR_FVALUE)
+		return 0;
+	v = op->fvalue;
+	switch (expr->op) {
+	case '+': break;
+	case '-': v = -v; break;
+	default: return 0;
+	}
+	expr->fvalue = v;
+	expr->type = EXPR_FVALUE;
+	return 1;
+}
+
+/*
+ * Unary post-ops: x++ and x--
+ */
+static int expand_postop(struct expression *expr)
+{
+	expand_expression(expr->unop);
+	return SIDE_EFFECTS;
+}
+
+static int expand_preop(struct expression *expr)
+{
+	int cost;
+
+	switch (expr->op) {
+	case '*':
+		return expand_dereference(expr);
+
+	case '&':
+		return expand_addressof(expr);
+
+	case SPECIAL_INCREMENT:
+	case SPECIAL_DECREMENT:
+		/*
+		 * From a type evaluation standpoint the preops are
+		 * the same as the postops
+		 */
+		return expand_postop(expr);
+
+	default:
+		break;
+	}
+	cost = expand_expression(expr->unop);
+
+	if (simplify_preop(expr))
+		return 0;
+	if (simplify_float_preop(expr))
+		return 0;
+	return cost + 1;
+}
+
+static int expand_arguments(struct expression_list *head)
+{
+	int cost = 0;
+	struct expression *expr;
+
+	FOR_EACH_PTR (head, expr) {
+		cost += expand_expression(expr);
+	} END_FOR_EACH_PTR(expr);
+	return cost;
+}
+
+static int expand_cast(struct expression *expr)
+{
+	int cost;
+	struct expression *target = expr->cast_expression;
+
+	cost = expand_expression(target);
+
+	/* Simplify normal integer casts.. */
+	if (target->type == EXPR_VALUE || target->type == EXPR_FVALUE) {
+		cast_value(expr, expr->ctype, target, target->ctype);
+		return 0;
+	}
+	return cost + 1;
+}
+
+/*
+ * expand a call expression with a symbol. This
+ * should expand builtins.
+ */
+static int expand_symbol_call(struct expression *expr, int cost)
+{
+	struct expression *fn = expr->fn;
+	struct symbol *ctype = fn->ctype;
+
+	if (fn->type != EXPR_PREOP)
+		return SIDE_EFFECTS;
+
+	if (ctype->op && ctype->op->expand)
+		return ctype->op->expand(expr, cost);
+
+	if (ctype->ctype.modifiers & MOD_PURE)
+		return cost + 1;
+
+	return SIDE_EFFECTS;
+}
+
+static int expand_call(struct expression *expr)
+{
+	int cost;
+	struct symbol *sym;
+	struct expression *fn = expr->fn;
+
+	cost = expand_arguments(expr->args);
+	sym = fn->ctype;
+	if (!sym) {
+		expression_error(expr, "function has no type");
+		return SIDE_EFFECTS;
+	}
+	if (sym->type == SYM_NODE)
+		return expand_symbol_call(expr, cost);
+
+	return SIDE_EFFECTS;
+}
+
+static int expand_expression_list(struct expression_list *list)
+{
+	int cost = 0;
+	struct expression *expr;
+
+	FOR_EACH_PTR(list, expr) {
+		cost += expand_expression(expr);
+	} END_FOR_EACH_PTR(expr);
+	return cost;
+}
+
+/* 
+ * We can simplify nested position expressions if
+ * this is a simple (single) positional expression.
+ */
+static int expand_pos_expression(struct expression *expr)
+{
+	struct expression *nested = expr->init_expr;
+	unsigned long offset = expr->init_offset;
+	int nr = expr->init_nr;
+
+	if (nr == 1) {
+		switch (nested->type) {
+		case EXPR_POS:
+			offset += nested->init_offset;
+			*expr = *nested;
+			expr->init_offset = offset;
+			nested = expr;
+			break;
+
+		case EXPR_INITIALIZER: {
+			struct expression *reuse = nested, *entry;
+			*expr = *nested;
+			FOR_EACH_PTR(expr->expr_list, entry) {
+				if (entry->type == EXPR_POS) {
+					entry->init_offset += offset;
+				} else {
+					if (!reuse) {
+						/*
+						 * This happens rarely, but it can happen
+						 * with bitfields that are all at offset
+						 * zero..
+						 */
+						reuse = alloc_expression(entry->pos, EXPR_POS);
+					}
+					reuse->type = EXPR_POS;
+					reuse->ctype = entry->ctype;
+					reuse->init_offset = offset;
+					reuse->init_nr = 1;
+					reuse->init_expr = entry;
+					REPLACE_CURRENT_PTR(entry, reuse);
+					reuse = NULL;
+				}
+			} END_FOR_EACH_PTR(entry);
+			nested = expr;
+			break;
+		}
+
+		default:
+			break;
+		}
+	}
+	return expand_expression(nested);
+}
+
+static unsigned long bit_offset(const struct expression *expr)
+{
+	unsigned long offset = 0;
+	while (expr->type == EXPR_POS) {
+		offset += bytes_to_bits(expr->init_offset);
+		expr = expr->init_expr;
+	}
+	if (expr && expr->ctype)
+		offset += expr->ctype->bit_offset;
+	return offset;
+}
+
+static unsigned long bit_range(const struct expression *expr)
+{
+	unsigned long range = 0;
+	unsigned long size = 0;
+	while (expr->type == EXPR_POS) {
+		unsigned long nr = expr->init_nr;
+		size = expr->ctype->bit_size;
+		range += (nr - 1) * size;
+		expr = expr->init_expr;
+	}
+	range += size;
+	return range;
+}
+
+static int compare_expressions(const void *_a, const void *_b)
+{
+	const struct expression *a = _a;
+	const struct expression *b = _b;
+	unsigned long a_pos = bit_offset(a);
+	unsigned long b_pos = bit_offset(b);
+
+	return (a_pos < b_pos) ? -1 : (a_pos == b_pos) ? 0 : 1;
+}
+
+static void sort_expression_list(struct expression_list **list)
+{
+	sort_list((struct ptr_list **)list, compare_expressions);
+}
+
+static void verify_nonoverlapping(struct expression_list **list, struct expression *expr)
+{
+	struct expression *a = NULL;
+	unsigned long max = 0;
+	unsigned long whole = expr->ctype->bit_size;
+	struct expression *b;
+
+	if (!Woverride_init)
+		return;
+
+	FOR_EACH_PTR(*list, b) {
+		unsigned long off, end;
+		if (!b->ctype || !b->ctype->bit_size)
+			continue;
+		off = bit_offset(b);
+		if (a && off < max) {
+			warning(a->pos, "Initializer entry defined twice");
+			info(b->pos, "  also defined here");
+			if (!Woverride_init_all)
+				return;
+		}
+		end = off + bit_range(b);
+		if (!a && !Woverride_init_whole_range) {
+			// If first entry is the whole range, do not let
+			// any warning about it (this allow to initialize
+			// an array with some default value and then override
+			// some specific entries).
+			if (off == 0 && end == whole)
+				continue;
+		}
+		if (end > max) {
+			max = end;
+			a = b;
+		}
+	} END_FOR_EACH_PTR(b);
+}
+
+static int expand_expression(struct expression *expr)
+{
+	if (!expr)
+		return 0;
+	if (!expr->ctype || expr->ctype == &bad_ctype)
+		return UNSAFE;
+
+	switch (expr->type) {
+	case EXPR_VALUE:
+	case EXPR_FVALUE:
+	case EXPR_STRING:
+		return 0;
+	case EXPR_TYPE:
+	case EXPR_SYMBOL:
+		return expand_symbol_expression(expr);
+	case EXPR_BINOP:
+		return expand_binop(expr);
+
+	case EXPR_LOGICAL:
+		return expand_logical(expr);
+
+	case EXPR_COMMA:
+		return expand_comma(expr);
+
+	case EXPR_COMPARE:
+		return expand_compare(expr);
+
+	case EXPR_ASSIGNMENT:
+		return expand_assignment(expr);
+
+	case EXPR_PREOP:
+		return expand_preop(expr);
+
+	case EXPR_POSTOP:
+		return expand_postop(expr);
+
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+	case EXPR_IMPLIED_CAST:
+		return expand_cast(expr);
+
+	case EXPR_CALL:
+		return expand_call(expr);
+
+	case EXPR_DEREF:
+		warning(expr->pos, "we should not have an EXPR_DEREF left at expansion time");
+		return UNSAFE;
+
+	case EXPR_SELECT:
+	case EXPR_CONDITIONAL:
+		return expand_conditional(expr);
+
+	case EXPR_STATEMENT: {
+		struct statement *stmt = expr->statement;
+		int cost = expand_statement(stmt);
+
+		if (stmt->type == STMT_EXPRESSION && stmt->expression)
+			*expr = *stmt->expression;
+		return cost;
+	}
+
+	case EXPR_LABEL:
+		return 0;
+
+	case EXPR_INITIALIZER:
+		sort_expression_list(&expr->expr_list);
+		verify_nonoverlapping(&expr->expr_list, expr);
+		return expand_expression_list(expr->expr_list);
+
+	case EXPR_IDENTIFIER:
+		return UNSAFE;
+
+	case EXPR_INDEX:
+		return UNSAFE;
+
+	case EXPR_SLICE:
+		return expand_expression(expr->base) + 1;
+
+	case EXPR_POS:
+		return expand_pos_expression(expr);
+
+	case EXPR_SIZEOF:
+	case EXPR_PTRSIZEOF:
+	case EXPR_ALIGNOF:
+	case EXPR_OFFSETOF:
+		expression_error(expr, "internal front-end error: sizeof in expansion?");
+		return UNSAFE;
+	}
+	return SIDE_EFFECTS;
+}
+
+static void expand_const_expression(struct expression *expr, const char *where)
+{
+	if (expr) {
+		expand_expression(expr);
+		if (expr->type != EXPR_VALUE)
+			expression_error(expr, "Expected constant expression in %s", where);
+	}
+}
+
+int expand_symbol(struct symbol *sym)
+{
+	int retval;
+	struct symbol *base_type;
+
+	if (!sym)
+		return 0;
+	base_type = sym->ctype.base_type;
+	if (!base_type)
+		return 0;
+
+	retval = expand_expression(sym->initializer);
+	/* expand the body of the symbol */
+	if (base_type->type == SYM_FN) {
+		if (base_type->stmt)
+			expand_statement(base_type->stmt);
+	}
+	return retval;
+}
+
+static void expand_return_expression(struct statement *stmt)
+{
+	expand_expression(stmt->expression);
+}
+
+static int expand_if_statement(struct statement *stmt)
+{
+	struct expression *expr = stmt->if_conditional;
+
+	if (!expr || !expr->ctype || expr->ctype == &bad_ctype)
+		return UNSAFE;
+
+	expand_expression(expr);
+
+/* This is only valid if nobody jumps into the "dead" side */
+#if 0
+	/* Simplify constant conditionals without even evaluating the false side */
+	if (expr->type == EXPR_VALUE) {
+		struct statement *simple;
+		simple = expr->value ? stmt->if_true : stmt->if_false;
+
+		/* Nothing? */
+		if (!simple) {
+			stmt->type = STMT_NONE;
+			return 0;
+		}
+		expand_statement(simple);
+		*stmt = *simple;
+		return SIDE_EFFECTS;
+	}
+#endif
+	expand_statement(stmt->if_true);
+	expand_statement(stmt->if_false);
+	return SIDE_EFFECTS;
+}
+
+/*
+ * Expanding a compound statement is really just
+ * about adding up the costs of each individual
+ * statement.
+ *
+ * We also collapse a simple compound statement:
+ * this would trigger for simple inline functions,
+ * except we would have to check the "return"
+ * symbol usage. Next time.
+ */
+static int expand_compound(struct statement *stmt)
+{
+	struct statement *s, *last;
+	int cost, statements;
+
+	if (stmt->ret)
+		expand_symbol(stmt->ret);
+
+	last = stmt->args;
+	cost = expand_statement(last);
+	statements = last != NULL;
+	FOR_EACH_PTR(stmt->stmts, s) {
+		statements++;
+		last = s;
+		cost += expand_statement(s);
+	} END_FOR_EACH_PTR(s);
+
+	if (statements == 1 && !stmt->ret)
+		*stmt = *last;
+
+	return cost;
+}
+
+static int expand_statement(struct statement *stmt)
+{
+	if (!stmt)
+		return 0;
+
+	switch (stmt->type) {
+	case STMT_DECLARATION: {
+		struct symbol *sym;
+		FOR_EACH_PTR(stmt->declaration, sym) {
+			expand_symbol(sym);
+		} END_FOR_EACH_PTR(sym);
+		return SIDE_EFFECTS;
+	}
+
+	case STMT_RETURN:
+		expand_return_expression(stmt);
+		return SIDE_EFFECTS;
+
+	case STMT_EXPRESSION:
+		return expand_expression(stmt->expression);
+
+	case STMT_COMPOUND:
+		return expand_compound(stmt);
+
+	case STMT_IF:
+		return expand_if_statement(stmt);
+
+	case STMT_ITERATOR:
+		expand_expression(stmt->iterator_pre_condition);
+		expand_expression(stmt->iterator_post_condition);
+		expand_statement(stmt->iterator_pre_statement);
+		expand_statement(stmt->iterator_statement);
+		expand_statement(stmt->iterator_post_statement);
+		return SIDE_EFFECTS;
+
+	case STMT_SWITCH:
+		expand_expression(stmt->switch_expression);
+		expand_statement(stmt->switch_statement);
+		return SIDE_EFFECTS;
+
+	case STMT_CASE:
+		expand_const_expression(stmt->case_expression, "case statement");
+		expand_const_expression(stmt->case_to, "case statement");
+		expand_statement(stmt->case_statement);
+		return SIDE_EFFECTS;
+
+	case STMT_LABEL:
+		expand_statement(stmt->label_statement);
+		return SIDE_EFFECTS;
+
+	case STMT_GOTO:
+		expand_expression(stmt->goto_expression);
+		return SIDE_EFFECTS;
+
+	case STMT_NONE:
+		break;
+	case STMT_ASM:
+		/* FIXME! Do the asm parameter evaluation! */
+		break;
+	case STMT_CONTEXT:
+		expand_expression(stmt->expression);
+		break;
+	case STMT_RANGE:
+		expand_expression(stmt->range_expression);
+		expand_expression(stmt->range_low);
+		expand_expression(stmt->range_high);
+		break;
+	}
+	return SIDE_EFFECTS;
+}
+
+static inline int bad_integer_constant_expression(struct expression *expr)
+{
+	if (!(expr->flags & CEF_ICE))
+		return 1;
+	if (expr->taint & Taint_comma)
+		return 1;
+	return 0;
+}
+
+static long long __get_expression_value(struct expression *expr, int strict)
+{
+	long long value, mask;
+	struct symbol *ctype;
+
+	if (!expr)
+		return 0;
+	ctype = evaluate_expression(expr);
+	if (!ctype) {
+		expression_error(expr, "bad constant expression type");
+		return 0;
+	}
+	expand_expression(expr);
+	if (expr->type != EXPR_VALUE) {
+		if (strict != 2)
+			expression_error(expr, "bad constant expression");
+		return 0;
+	}
+	if ((strict == 1) && bad_integer_constant_expression(expr)) {
+		expression_error(expr, "bad integer constant expression");
+		return 0;
+	}
+
+	value = expr->value;
+	mask = 1ULL << (ctype->bit_size-1);
+
+	if (value & mask) {
+		while (ctype->type != SYM_BASETYPE)
+			ctype = ctype->ctype.base_type;
+		if (!(ctype->ctype.modifiers & MOD_UNSIGNED))
+			value = value | mask | ~(mask-1);
+	}
+	return value;
+}
+
+long long get_expression_value(struct expression *expr)
+{
+	return __get_expression_value(expr, 0);
+}
+
+long long const_expression_value(struct expression *expr)
+{
+	return __get_expression_value(expr, 1);
+}
+
+long long get_expression_value_silent(struct expression *expr)
+{
+
+	return __get_expression_value(expr, 2);
+}
+
+int expr_truth_value(struct expression *expr)
+{
+	const int saved = conservative;
+	struct symbol *ctype;
+
+	if (!expr)
+		return 0;
+
+	ctype = evaluate_expression(expr);
+	if (!ctype)
+		return -1;
+
+	conservative = 1;
+	expand_expression(expr);
+	conservative = saved;
+
+redo:
+	switch (expr->type) {
+	case EXPR_COMMA:
+		expr = expr->right;
+		goto redo;
+	case EXPR_VALUE:
+		return expr->value != 0;
+	case EXPR_FVALUE:
+		return expr->fvalue != 0;
+	default:
+		return -1;
+	}
+}
+
+int is_zero_constant(struct expression *expr)
+{
+	const int saved = conservative;
+	conservative = 1;
+	expand_expression(expr);
+	conservative = saved;
+	return expr->type == EXPR_VALUE && !expr->value;
+}
diff --git a/usr/src/tools/smatch/src/expand.h b/usr/src/tools/smatch/src/expand.h
new file mode 100644
index 0000000000..27e10c0a87
--- /dev/null
+++ b/usr/src/tools/smatch/src/expand.h
@@ -0,0 +1,34 @@
+#ifndef EXPAND_H
+#define EXPAND_H
+/*
+ * sparse/expand.h
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/* Random cost numbers */
+#define SIDE_EFFECTS 10000	/* The expression has side effects */
+#define UNSAFE 100		/* The expression may be "infinitely costly" due to exceptions */
+#define SELECT_COST 20		/* Cut-off for turning a conditional into a select */
+#define BRANCH_COST 10		/* Cost of a conditional branch */
+
+#endif
diff --git a/usr/src/tools/smatch/src/expression.c b/usr/src/tools/smatch/src/expression.c
new file mode 100644
index 0000000000..cdd5e25170
--- /dev/null
+++ b/usr/src/tools/smatch/src/expression.c
@@ -0,0 +1,906 @@
+/*
+ * sparse/expression.c
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * This is the expression parsing part of parsing C.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <limits.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "scope.h"
+#include "expression.h"
+#include "target.h"
+#include "char.h"
+
+static int match_oplist(int op, ...)
+{
+	va_list args;
+	int nextop;
+
+	va_start(args, op);
+	do {
+		nextop = va_arg(args, int);
+	} while (nextop != 0 && nextop != op);
+	va_end(args);
+
+	return nextop != 0;
+}
+
+static struct token *comma_expression(struct token *, struct expression **);
+
+struct token *parens_expression(struct token *token, struct expression **expr, const char *where)
+{
+	token = expect(token, '(', where);
+	if (match_op(token, '{')) {
+		struct expression *e = alloc_expression(token->pos, EXPR_STATEMENT);
+		struct statement *stmt = alloc_statement(token->pos, STMT_COMPOUND);
+		*expr = e;
+		e->statement = stmt;
+		start_symbol_scope(e->pos);
+		token = compound_statement(token->next, stmt);
+		end_symbol_scope();
+		token = expect(token, '}', "at end of statement expression");
+	} else
+		token = parse_expression(token, expr);
+	return expect(token, ')', where);
+}
+
+/*
+ * Handle __func__, __FUNCTION__ and __PRETTY_FUNCTION__ token
+ * conversion
+ */
+static struct symbol *handle_func(struct token *token)
+{
+	struct ident *ident = token->ident;
+	struct symbol *decl, *array;
+	struct string *string;
+	int len;
+
+	if (ident != &__func___ident &&
+	    ident != &__FUNCTION___ident &&
+	    ident != &__PRETTY_FUNCTION___ident)
+		return NULL;
+
+	if (!current_fn || !current_fn->ident)
+		return NULL;
+
+	/* OK, it's one of ours */
+	array = alloc_symbol(token->pos, SYM_ARRAY);
+	array->ctype.base_type = &char_ctype;
+	array->ctype.alignment = 1;
+	array->endpos = token->pos;
+	decl = alloc_symbol(token->pos, SYM_NODE);
+	decl->ctype.base_type = array;
+	decl->ctype.alignment = 1;
+	decl->ctype.modifiers = MOD_STATIC;
+	decl->endpos = token->pos;
+
+	/* function-scope, but in NS_SYMBOL */
+	bind_symbol(decl, ident, NS_LABEL);
+	decl->namespace = NS_SYMBOL;
+
+	len = current_fn->ident->len;
+	string = __alloc_string(len + 1);
+	memcpy(string->data, current_fn->ident->name, len);
+	string->data[len] = 0;
+	string->length = len + 1;
+
+	decl->initializer = alloc_expression(token->pos, EXPR_STRING);
+	decl->initializer->string = string;
+	decl->initializer->ctype = decl;
+	decl->array_size = alloc_const_expression(token->pos, len + 1);
+	array->array_size = decl->array_size;
+	decl->bit_size = array->bit_size = bytes_to_bits(len + 1);
+
+	return decl;
+}
+
+static struct token *parse_type(struct token *token, struct expression **tree)
+{
+	struct symbol *sym;
+	*tree = alloc_expression(token->pos, EXPR_TYPE);
+	token = typename(token, &sym, NULL);
+	if (sym->ident)
+		sparse_error(token->pos,
+			     "type expression should not include identifier "
+			     "\"%s\"", sym->ident->name);
+	(*tree)->symbol = sym;
+	return token;
+}
+
+static struct token *builtin_types_compatible_p_expr(struct token *token,
+						     struct expression **tree)
+{
+	struct expression *expr = alloc_expression(
+		token->pos, EXPR_COMPARE);
+	expr->op = SPECIAL_EQUAL;
+	token = token->next;
+	if (!match_op(token, '('))
+		return expect(token, '(',
+			      "after __builtin_types_compatible_p");
+	token = token->next;
+	token = parse_type(token, &expr->left);
+	if (!match_op(token, ','))
+		return expect(token, ',',
+			      "in __builtin_types_compatible_p");
+	token = token->next;
+	token = parse_type(token, &expr->right);
+	if (!match_op(token, ')'))
+		return expect(token, ')',
+			      "at end of __builtin_types_compatible_p");
+	token = token->next;
+	
+	*tree = expr;
+	return token;
+}
+
+static struct token *builtin_offsetof_expr(struct token *token,
+					   struct expression **tree)
+{
+	struct expression *expr = NULL;
+	struct expression **p = &expr;
+	struct symbol *sym;
+	int op = '.';
+
+	token = token->next;
+	if (!match_op(token, '('))
+		return expect(token, '(', "after __builtin_offset");
+
+	token = token->next;
+	token = typename(token, &sym, NULL);
+	if (sym->ident)
+		sparse_error(token->pos,
+			     "type expression should not include identifier "
+			     "\"%s\"", sym->ident->name);
+
+	if (!match_op(token, ','))
+		return expect(token, ',', "in __builtin_offset");
+
+	while (1) {
+		struct expression *e;
+		switch (op) {
+		case ')':
+			expr->in = sym;
+			*tree = expr;
+		default:
+			return expect(token, ')', "at end of __builtin_offset");
+		case SPECIAL_DEREFERENCE:
+			e = alloc_expression(token->pos, EXPR_OFFSETOF);
+			e->op = '[';
+			*p = e;
+			p = &e->down;
+			/* fall through */
+		case '.':
+			token = token->next;
+			e = alloc_expression(token->pos, EXPR_OFFSETOF);
+			e->op = '.';
+			if (token_type(token) != TOKEN_IDENT) {
+				sparse_error(token->pos, "Expected member name");
+				return token;
+			}
+			e->ident = token->ident;
+			token = token->next;
+			break;
+		case '[':
+			token = token->next;
+			e = alloc_expression(token->pos, EXPR_OFFSETOF);
+			e->op = '[';
+			token = parse_expression(token, &e->index);
+			token = expect(token, ']',
+					"at end of array dereference");
+			if (!e->index)
+				return token;
+		}
+		*p = e;
+		p = &e->down;
+		op = token_type(token) == TOKEN_SPECIAL ? token->special : 0;
+	}
+}
+
+#ifndef ULLONG_MAX
+#define ULLONG_MAX (~0ULL)
+#endif
+
+static unsigned long long parse_num(const char *nptr, char **end)
+{
+	if (nptr[0] == '0' && tolower((unsigned char)nptr[1]) == 'b')
+		return strtoull(&nptr[2], end, 2);
+	return strtoull(nptr, end, 0);
+}
+
+static void get_number_value(struct expression *expr, struct token *token)
+{
+	const char *str = token->number;
+	unsigned long long value;
+	char *end;
+	int size = 0, want_unsigned = 0;
+	int overflow = 0, do_warn = 0;
+	int try_unsigned = 1;
+	int bits;
+
+	errno = 0;
+	value = parse_num(str, &end);
+	if (end == str)
+		goto Float;
+	if (value == ULLONG_MAX && errno == ERANGE)
+		overflow = 1;
+	while (1) {
+		char c = *end++;
+		if (!c) {
+			break;
+		} else if (c == 'u' || c == 'U') {
+			if (want_unsigned)
+				goto Enoint;
+			want_unsigned = 1;
+		} else if (c == 'l' || c == 'L') {
+			if (size)
+				goto Enoint;
+			size = 1;
+			if (*end == c) {
+				size = 2;
+				end++;
+			}
+		} else
+			goto Float;
+	}
+	if (overflow)
+		goto Eoverflow;
+	/* OK, it's a valid integer */
+	/* decimals can be unsigned only if directly specified as such */
+	if (str[0] != '0' && !want_unsigned)
+		try_unsigned = 0;
+	if (!size) {
+		bits = bits_in_int - 1;
+		if (!(value & (~1ULL << bits))) {
+			if (!(value & (1ULL << bits))) {
+				goto got_it;
+			} else if (try_unsigned) {
+				want_unsigned = 1;
+				goto got_it;
+			}
+		}
+		size = 1;
+		do_warn = 1;
+	}
+	if (size < 2) {
+		bits = bits_in_long - 1;
+		if (!(value & (~1ULL << bits))) {
+			if (!(value & (1ULL << bits))) {
+				goto got_it;
+			} else if (try_unsigned) {
+				want_unsigned = 1;
+				goto got_it;
+			}
+			do_warn |= 2;
+		}
+		size = 2;
+		do_warn |= 1;
+	}
+	bits = bits_in_longlong - 1;
+	if (value & (~1ULL << bits))
+		goto Eoverflow;
+	if (!(value & (1ULL << bits)))
+		goto got_it;
+	if (!try_unsigned)
+		warning(expr->pos, "decimal constant %s is too big for long long",
+			show_token(token));
+	want_unsigned = 1;
+got_it:
+	if (do_warn && Wconstant_suffix)
+		warning(expr->pos, "constant %s is so big it is%s%s%s",
+			show_token(token),
+			want_unsigned ? " unsigned":"",
+			size > 0 ? " long":"",
+			size > 1 ? " long":"");
+	if (do_warn & 2)
+		warning(expr->pos,
+			"decimal constant %s is between LONG_MAX and ULONG_MAX."
+			" For C99 that means long long, C90 compilers are very "
+			"likely to produce unsigned long (and a warning) here",
+			show_token(token));
+        expr->type = EXPR_VALUE;
+	expr->flags = CEF_SET_INT;
+        expr->ctype = ctype_integer(size, want_unsigned);
+        expr->value = value;
+	return;
+Eoverflow:
+	error_die(expr->pos, "constant %s is too big even for unsigned long long",
+			show_token(token));
+	return;
+Float:
+	expr->fvalue = string_to_ld(str, &end);
+	if (str == end)
+		goto Enoint;
+
+	if (*end && end[1])
+		goto Enoint;
+
+	if (*end == 'f' || *end == 'F')
+		expr->ctype = &float_ctype;
+	else if (*end == 'l' || *end == 'L')
+		expr->ctype = &ldouble_ctype;
+	else if (!*end)
+		expr->ctype = &double_ctype;
+	else
+		goto Enoint;
+
+	expr->flags = CEF_SET_FLOAT;
+	expr->type = EXPR_FVALUE;
+	return;
+
+Enoint:
+	error_die(expr->pos, "constant %s is not a valid number", show_token(token));
+}
+
+struct token *primary_expression(struct token *token, struct expression **tree)
+{
+	struct expression *expr = NULL;
+
+	switch (token_type(token)) {
+	case TOKEN_CHAR ... TOKEN_WIDE_CHAR_EMBEDDED_3:
+		expr = alloc_expression(token->pos, EXPR_VALUE);
+		expr->flags = CEF_SET_CHAR;
+		expr->ctype = token_type(token) < TOKEN_WIDE_CHAR ? &int_ctype : &long_ctype;
+		get_char_constant(token, &expr->value);
+		token = token->next;
+		break;
+
+	case TOKEN_NUMBER:
+		expr = alloc_expression(token->pos, EXPR_VALUE);
+		get_number_value(expr, token); /* will see if it's an integer */
+		token = token->next;
+		break;
+
+	case TOKEN_ZERO_IDENT: {
+		expr = alloc_expression(token->pos, EXPR_SYMBOL);
+		expr->flags = CEF_SET_INT;
+		expr->ctype = &int_ctype;
+		expr->symbol = &zero_int;
+		expr->symbol_name = token->ident;
+		token = token->next;
+		break;
+	}
+
+	case TOKEN_IDENT: {
+		struct symbol *sym = lookup_symbol(token->ident, NS_SYMBOL | NS_TYPEDEF);
+		struct token *next = token->next;
+
+		if (!sym) {
+			sym = handle_func(token);
+			if (token->ident == &__builtin_types_compatible_p_ident) {
+				token = builtin_types_compatible_p_expr(token, &expr);
+				break;
+			}
+			if (token->ident == &__builtin_offsetof_ident) {
+				token = builtin_offsetof_expr(token, &expr);
+				break;
+			}
+		} else if (sym->enum_member) {
+			expr = alloc_expression(token->pos, EXPR_VALUE);
+			*expr = *sym->initializer;
+			/* we want the right position reported, thus the copy */
+			expr->pos = token->pos;
+			expr->flags = CEF_SET_ENUM;
+			token = next;
+			break;
+		}
+
+		expr = alloc_expression(token->pos, EXPR_SYMBOL);
+
+		/*
+		 * We support types as real first-class citizens, with type
+		 * comparisons etc:
+		 *
+		 *	if (typeof(a) == int) ..
+		 */
+		if (sym && sym->namespace == NS_TYPEDEF) {
+			sparse_error(token->pos, "typename in expression");
+			sym = NULL;
+		}
+		expr->symbol_name = token->ident;
+		expr->symbol = sym;
+
+		/*
+		 * A pointer to an lvalue designating a static storage
+		 * duration object is an address constant [6.6(9)].
+		 */
+		if (sym && (sym->ctype.modifiers & (MOD_TOPLEVEL | MOD_STATIC)))
+			expr->flags = CEF_ADDR;
+
+		token = next;
+		break;
+	}
+
+	case TOKEN_STRING:
+	case TOKEN_WIDE_STRING:
+		expr = alloc_expression(token->pos, EXPR_STRING);
+		token = get_string_constant(token, expr);
+		break;
+
+	case TOKEN_SPECIAL:
+		if (token->special == '(') {
+			expr = alloc_expression(token->pos, EXPR_PREOP);
+			expr->op = '(';
+			token = parens_expression(token, &expr->unop, "in expression");
+			break;
+		}
+		if (token->special == '[' && lookup_type(token->next)) {
+			expr = alloc_expression(token->pos, EXPR_TYPE);
+			token = typename(token->next, &expr->symbol, NULL);
+			token = expect(token, ']', "in type expression");
+			break;
+		}
+			
+	default:
+		;
+	}
+	*tree = expr;
+	return token;
+}
+
+static struct token *expression_list(struct token *token, struct expression_list **list)
+{
+	while (!match_op(token, ')')) {
+		struct expression *expr = NULL;
+		token = assignment_expression(token, &expr);
+		if (!expr)
+			break;
+		add_expression(list, expr);
+		if (!match_op(token, ','))
+			break;
+		token = token->next;
+	}
+	return token;
+}
+
+/*
+ * extend to deal with the ambiguous C grammar for parsing
+ * a cast expressions followed by an initializer.
+ */
+static struct token *postfix_expression(struct token *token, struct expression **tree, struct expression *cast_init_expr)
+{
+	struct expression *expr = cast_init_expr;
+
+	if (!expr)
+		token = primary_expression(token, &expr);
+
+	while (expr && token_type(token) == TOKEN_SPECIAL) {
+		switch (token->special) {
+		case '[': {			/* Array dereference */
+			struct expression *deref = alloc_expression(token->pos, EXPR_PREOP);
+			struct expression *add = alloc_expression(token->pos, EXPR_BINOP);
+
+			deref->op = '*';
+			deref->unop = add;
+
+			add->op = '+';
+			add->left = expr;
+			token = parse_expression(token->next, &add->right);
+			token = expect(token, ']', "at end of array dereference");
+			expr = deref;
+			continue;
+		}
+		case SPECIAL_INCREMENT:		/* Post-increment */
+		case SPECIAL_DECREMENT:	{	/* Post-decrement */
+			struct expression *post = alloc_expression(token->pos, EXPR_POSTOP);
+			post->op = token->special;
+			post->unop = expr;
+			expr = post;
+			token = token->next;
+			continue;
+		}
+		case SPECIAL_DEREFERENCE: {	/* Structure pointer member dereference */
+			/* "x->y" is just shorthand for "(*x).y" */
+			struct expression *inner = alloc_expression(token->pos, EXPR_PREOP);
+			inner->op = '*';
+			inner->unop = expr;
+			expr = inner;
+		}
+		/* Fall through!! */
+		case '.': {			/* Structure member dereference */
+			struct expression *deref = alloc_expression(token->pos, EXPR_DEREF);
+			deref->op = '.';
+			deref->deref = expr;
+			token = token->next;
+			if (token_type(token) != TOKEN_IDENT) {
+				sparse_error(token->pos, "Expected member name");
+				break;
+			}
+			deref->member = token->ident;
+			deref->member_offset = -1;
+			token = token->next;
+			expr = deref;
+			continue;
+		}
+
+		case '(': {			/* Function call */
+			struct expression *call = alloc_expression(token->pos, EXPR_CALL);
+			call->op = '(';
+			call->fn = expr;
+			token = expression_list(token->next, &call->args);
+			token = expect(token, ')', "in function call");
+			expr = call;
+			continue;
+		}
+
+		default:
+			break;
+		}
+		break;
+	}
+	*tree = expr;
+	return token;
+}
+
+static struct token *cast_expression(struct token *token, struct expression **tree);
+static struct token *unary_expression(struct token *token, struct expression **tree);
+
+static struct token *type_info_expression(struct token *token,
+	struct expression **tree, int type)
+{
+	struct expression *expr = alloc_expression(token->pos, type);
+	struct token *p;
+
+	*tree = expr;
+	expr->flags = CEF_SET_ICE; /* XXX: VLA support will need that changed */
+	token = token->next;
+	if (!match_op(token, '(') || !lookup_type(token->next))
+		return unary_expression(token, &expr->cast_expression);
+	p = token;
+	token = typename(token->next, &expr->cast_type, NULL);
+
+	if (!match_op(token, ')')) {
+		static const char * error[] = {
+			[EXPR_SIZEOF] = "at end of sizeof",
+			[EXPR_ALIGNOF] = "at end of __alignof__",
+			[EXPR_PTRSIZEOF] = "at end of __sizeof_ptr__"
+		};
+		return expect(token, ')', error[type]);
+	}
+
+	token = token->next;
+	/*
+	 * C99 ambiguity: the typename might have been the beginning
+	 * of a typed initializer expression..
+	 */
+	if (match_op(token, '{')) {
+		struct expression *cast = alloc_expression(p->pos, EXPR_CAST);
+		cast->cast_type = expr->cast_type;
+		expr->cast_type = NULL;
+		expr->cast_expression = cast;
+		token = initializer(&cast->cast_expression, token);
+		token = postfix_expression(token, &expr->cast_expression, cast);
+	}
+	return token;
+}
+
+static struct token *unary_expression(struct token *token, struct expression **tree)
+{
+	if (token_type(token) == TOKEN_IDENT) {
+		struct ident *ident = token->ident;
+		if (ident->reserved) {
+			static const struct {
+				struct ident *id;
+				int type;
+			} type_information[] = {
+				{ &sizeof_ident, EXPR_SIZEOF },
+				{ &__alignof___ident, EXPR_ALIGNOF },
+				{ &__alignof_ident, EXPR_ALIGNOF },
+				{ &_Alignof_ident, EXPR_ALIGNOF },
+				{ &__sizeof_ptr___ident, EXPR_PTRSIZEOF },
+			};
+			int i;
+			for (i = 0; i < ARRAY_SIZE(type_information); i++) {
+				if (ident == type_information[i].id)
+					return type_info_expression(token, tree, type_information[i].type);
+			}
+		}
+	}
+
+	if (token_type(token) == TOKEN_SPECIAL) {
+		if (match_oplist(token->special,
+		    SPECIAL_INCREMENT, SPECIAL_DECREMENT,
+		    '&', '*', 0)) {
+		    	struct expression *unop;
+			struct expression *unary;
+			struct token *next;
+
+			next = cast_expression(token->next, &unop);
+			if (!unop) {
+				sparse_error(token->pos, "Syntax error in unary expression");
+				*tree = NULL;
+				return next;
+			}
+			unary = alloc_expression(token->pos, EXPR_PREOP);
+			unary->op = token->special;
+			unary->unop = unop;
+			*tree = unary;
+			return next;
+		}
+		/* possibly constant ones */
+		if (match_oplist(token->special, '+', '-', '~', '!', 0)) {
+		    	struct expression *unop;
+			struct expression *unary;
+			struct token *next;
+
+			next = cast_expression(token->next, &unop);
+			if (!unop) {
+				sparse_error(token->pos, "Syntax error in unary expression");
+				*tree = NULL;
+				return next;
+			}
+			unary = alloc_expression(token->pos, EXPR_PREOP);
+			unary->op = token->special;
+			unary->unop = unop;
+			*tree = unary;
+			return next;
+		}
+		/* Gcc extension: &&label gives the address of a label */
+		if (match_op(token, SPECIAL_LOGICAL_AND) &&
+		    token_type(token->next) == TOKEN_IDENT) {
+			struct expression *label = alloc_expression(token->pos, EXPR_LABEL);
+			struct symbol *sym = label_symbol(token->next);
+			if (!(sym->ctype.modifiers & MOD_ADDRESSABLE)) {
+				sym->ctype.modifiers |= MOD_ADDRESSABLE;
+				add_symbol(&function_computed_target_list, sym);
+			}
+			label->flags = CEF_ADDR;
+			label->label_symbol = sym;
+			*tree = label;
+			return token->next->next;
+		}
+						
+	}
+			
+	return postfix_expression(token, tree, NULL);
+}
+
+/*
+ * Ambiguity: a '(' can be either a cast-expression or
+ * a primary-expression depending on whether it is followed
+ * by a type or not. 
+ *
+ * additional ambiguity: a "cast expression" followed by
+ * an initializer is really a postfix-expression.
+ */
+static struct token *cast_expression(struct token *token, struct expression **tree)
+{
+	if (match_op(token, '(')) {
+		struct token *next = token->next;
+		if (lookup_type(next)) {
+			struct expression *cast = alloc_expression(next->pos, EXPR_CAST);
+			struct expression *v;
+			struct symbol *sym;
+			int is_force;
+
+			token = typename(next, &sym, &is_force);
+			cast->cast_type = sym;
+			token = expect(token, ')', "at end of cast operator");
+			if (match_op(token, '{')) {
+				if (toplevel(block_scope))
+					sym->ctype.modifiers |= MOD_TOPLEVEL;
+				if (is_force)
+					warning(sym->pos,
+						"[force] in compound literal");
+				token = initializer(&cast->cast_expression, token);
+				return postfix_expression(token, tree, cast);
+			}
+			*tree = cast;
+			if (is_force)
+				cast->type = EXPR_FORCE_CAST;
+			token = cast_expression(token, &v);
+			if (!v)
+				return token;
+			cast->cast_expression = v;
+			return token;
+		}
+	}
+	return unary_expression(token, tree);
+}
+
+/*
+ * Generic left-to-right binop parsing
+ *
+ * This _really_ needs to be inlined, because that makes the inner
+ * function call statically deterministic rather than a totally
+ * unpredictable indirect call. But gcc-3 is so "clever" that it
+ * doesn't do so by default even when you tell it to inline it.
+ *
+ * Making it a macro avoids the inlining problem, and also means
+ * that we can pass in the op-comparison as an expression rather
+ * than create a data structure for it.
+ */
+
+#define LR_BINOP_EXPRESSION(__token, tree, type, inner, compare)	\
+	struct expression *left = NULL;					\
+	struct token * next = inner(__token, &left);			\
+									\
+	if (left) {							\
+		while (token_type(next) == TOKEN_SPECIAL) {		\
+			struct expression *top, *right = NULL;		\
+			int op = next->special;				\
+									\
+			if (!(compare))					\
+				goto out;				\
+			top = alloc_expression(next->pos, type);	\
+			next = inner(next->next, &right);		\
+			if (!right) {					\
+				sparse_error(next->pos, "No right hand side of '%s'-expression", show_special(op));	\
+				break;					\
+			}						\
+			top->op = op;					\
+			top->left = left;				\
+			top->right = right;				\
+			left = top;					\
+		}							\
+	}								\
+out:									\
+	*tree = left;							\
+	return next;							\
+
+static struct token *multiplicative_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_BINOP, cast_expression,
+		(op == '*') || (op == '/') || (op == '%')
+	);
+}
+
+static struct token *additive_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_BINOP, multiplicative_expression,
+		(op == '+') || (op == '-')
+	);
+}
+
+static struct token *shift_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_BINOP, additive_expression,
+		(op == SPECIAL_LEFTSHIFT) || (op == SPECIAL_RIGHTSHIFT)
+	);
+}
+
+static struct token *relational_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_COMPARE, shift_expression,
+		(op == '<') || (op == '>') ||
+		(op == SPECIAL_LTE) || (op == SPECIAL_GTE)
+	);
+}
+
+static struct token *equality_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_COMPARE, relational_expression,
+		(op == SPECIAL_EQUAL) || (op == SPECIAL_NOTEQUAL)
+	);
+}
+
+static struct token *bitwise_and_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_BINOP, equality_expression,
+		(op == '&')
+	);
+}
+
+static struct token *bitwise_xor_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_BINOP, bitwise_and_expression,
+		(op == '^')
+	);
+}
+
+static struct token *bitwise_or_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_BINOP, bitwise_xor_expression,
+		(op == '|')
+	);
+}
+
+static struct token *logical_and_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_LOGICAL, bitwise_or_expression,
+		(op == SPECIAL_LOGICAL_AND)
+	);
+}
+
+static struct token *logical_or_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_LOGICAL, logical_and_expression,
+		(op == SPECIAL_LOGICAL_OR)
+	);
+}
+
+struct token *conditional_expression(struct token *token, struct expression **tree)
+{
+	token = logical_or_expression(token, tree);
+	if (*tree && match_op(token, '?')) {
+		struct expression *expr = alloc_expression(token->pos, EXPR_CONDITIONAL);
+		expr->op = token->special;
+		expr->left = *tree;
+		*tree = expr;
+		token = parse_expression(token->next, &expr->cond_true);
+		token = expect(token, ':', "in conditional expression");
+		token = conditional_expression(token, &expr->cond_false);
+	}
+	return token;
+}
+
+struct token *assignment_expression(struct token *token, struct expression **tree)
+{
+	token = conditional_expression(token, tree);
+	if (*tree && token_type(token) == TOKEN_SPECIAL) {
+		static const int assignments[] = {
+			'=',
+			SPECIAL_ADD_ASSIGN, SPECIAL_SUB_ASSIGN,
+			SPECIAL_MUL_ASSIGN, SPECIAL_DIV_ASSIGN,
+			SPECIAL_MOD_ASSIGN, SPECIAL_SHL_ASSIGN,
+			SPECIAL_SHR_ASSIGN, SPECIAL_AND_ASSIGN,
+			SPECIAL_OR_ASSIGN,  SPECIAL_XOR_ASSIGN };
+		int i, op = token->special;
+		for (i = 0; i < ARRAY_SIZE(assignments); i++)
+			if (assignments[i] == op) {
+				struct expression * expr = alloc_expression(token->pos, EXPR_ASSIGNMENT);
+				expr->left = *tree;
+				expr->op = op;
+				*tree = expr;
+				return assignment_expression(token->next, &expr->right);
+			}
+	}
+	return token;
+}
+
+static struct token *comma_expression(struct token *token, struct expression **tree)
+{
+	LR_BINOP_EXPRESSION(
+		token, tree, EXPR_COMMA, assignment_expression,
+		(op == ',')
+	);
+}
+
+struct token *parse_expression(struct token *token, struct expression **tree)
+{
+	return comma_expression(token,tree);
+}
+
+
diff --git a/usr/src/tools/smatch/src/expression.h b/usr/src/tools/smatch/src/expression.h
new file mode 100644
index 0000000000..78813602b8
--- /dev/null
+++ b/usr/src/tools/smatch/src/expression.h
@@ -0,0 +1,311 @@
+#ifndef EXPRESSION_H
+#define EXPRESSION_H
+/*
+ * sparse/expression.h
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Declarations and helper functions for expression parsing.
+ */
+
+#include "allocate.h"
+#include "lib.h"
+#include "symbol.h"
+
+struct expression_list;
+
+enum expression_type {
+	EXPR_VALUE = 1,
+	EXPR_STRING,
+	EXPR_SYMBOL,
+	EXPR_TYPE,
+	EXPR_BINOP,
+	EXPR_ASSIGNMENT,
+	EXPR_LOGICAL,
+	EXPR_DEREF,
+	EXPR_PREOP,
+	EXPR_POSTOP,
+	EXPR_CAST,
+	EXPR_FORCE_CAST,
+	EXPR_IMPLIED_CAST,
+	EXPR_SIZEOF,
+	EXPR_ALIGNOF,
+	EXPR_PTRSIZEOF,
+	EXPR_CONDITIONAL,
+	EXPR_SELECT,		// a "safe" conditional expression
+	EXPR_STATEMENT,
+	EXPR_CALL,
+	EXPR_COMMA,
+	EXPR_COMPARE,
+	EXPR_LABEL,
+	EXPR_INITIALIZER,	// initializer list
+	EXPR_IDENTIFIER,	// identifier in initializer
+	EXPR_INDEX,		// index in initializer
+	EXPR_POS,		// position in initializer
+	EXPR_FVALUE,
+	EXPR_SLICE,
+	EXPR_OFFSETOF,
+};
+
+
+/*
+ * Flags for tracking the promotion of constness related attributes
+ * from subexpressions to their parents.
+ *
+ * The flags are not independent as one might imply another.
+ * The implications are as follows:
+ * - CEF_INT, CEF_ENUM and
+ *   CEF_CHAR imply CEF_ICE.
+ *
+ * Use the CEF_*_SET_MASK and CEF_*_CLEAR_MASK
+ * helper macros defined below to set or clear one of these flags.
+ */
+enum constexpr_flag {
+	CEF_NONE = 0,
+	/*
+	 * A constant in the sense of [6.4.4]:
+	 * - Integer constant [6.4.4.1]
+	 * - Floating point constant [6.4.4.2]
+	 * - Enumeration constant [6.4.4.3]
+	 * - Character constant [6.4.4.4]
+	 */
+	CEF_INT = (1 << 0),
+	CEF_FLOAT = (1 << 1),
+	CEF_ENUM = (1 << 2),
+	CEF_CHAR = (1 << 3),
+
+	/*
+	 * A constant expression in the sense of [6.6]:
+	 * - integer constant expression [6.6(6)]
+	 * - arithmetic constant expression [6.6(8)]
+	 * - address constant [6.6(9)]
+	 */
+	CEF_ICE = (1 << 4),
+	CEF_ACE = (1 << 5),
+	CEF_ADDR = (1 << 6),
+
+	/* integer constant expression => arithmetic constant expression */
+	CEF_SET_ICE = (CEF_ICE | CEF_ACE),
+
+	/* integer constant => integer constant expression */
+	CEF_SET_INT = (CEF_INT | CEF_SET_ICE),
+
+	/* floating point constant => arithmetic constant expression */
+	CEF_SET_FLOAT = (CEF_FLOAT | CEF_ACE),
+
+	/* enumeration constant => integer constant expression */
+	CEF_SET_ENUM = (CEF_ENUM | CEF_SET_ICE),
+
+	/* character constant => integer constant expression */
+	CEF_SET_CHAR = (CEF_CHAR | CEF_SET_ICE),
+
+	/*
+	 * Remove any "Constant" [6.4.4] flag, but retain the "constant
+	 * expression" [6.6] flags.
+	 */
+	CEF_CONST_MASK = (CEF_INT | CEF_FLOAT | CEF_CHAR),
+
+	/*
+	 * not an integer constant expression => neither of integer,
+	 * enumeration and character constant
+	 */
+	CEF_CLR_ICE = (CEF_ICE | CEF_INT | CEF_ENUM | CEF_CHAR),
+};
+
+enum {
+	Handled = 1 << 0,
+	Fake	= 1 << 1,
+}; /* for expr->flags */
+
+enum {
+	Taint_comma = 1,
+}; /* for expr->taint */
+
+struct expression {
+	enum expression_type type:8;
+	unsigned flags:8;
+	unsigned smatch_flags:16;
+	int op;
+	struct position pos;
+	struct symbol *ctype;
+	unsigned long parent;
+	union {
+		// EXPR_VALUE
+		struct {
+			unsigned long long value;
+			unsigned taint;
+		};
+
+		// EXPR_FVALUE
+		long double fvalue;
+
+		// EXPR_STRING
+		struct {
+			int wide;
+			struct string *string;
+		};
+
+		// EXPR_UNOP, EXPR_PREOP and EXPR_POSTOP
+		struct /* unop */ {
+			struct expression *unop;
+			unsigned long op_value;
+		};
+
+		// EXPR_SYMBOL, EXPR_TYPE
+		struct /* symbol_arg */ {
+			struct symbol *symbol;
+			struct ident *symbol_name;
+		};
+
+		// EXPR_STATEMENT
+		struct statement *statement;
+
+		// EXPR_BINOP, EXPR_COMMA, EXPR_COMPARE, EXPR_LOGICAL and EXPR_ASSIGNMENT
+		struct /* binop_arg */ {
+			struct expression *left, *right;
+		};
+		// EXPR_DEREF
+		struct /* deref_arg */ {
+			struct expression *deref;
+			struct ident *member;
+			int member_offset;
+		};
+		// EXPR_SLICE
+		struct /* slice */ {
+			struct expression *base;
+			unsigned r_bitpos, r_nrbits;
+		};
+		// EXPR_CAST and EXPR_SIZEOF
+		struct /* cast_arg */ {
+			struct symbol *cast_type;
+			struct expression *cast_expression;
+		};
+		// EXPR_CONDITIONAL
+		// EXPR_SELECT
+		struct /* conditional_expr */ {
+			struct expression *conditional, *cond_true, *cond_false;
+		};
+		// EXPR_CALL
+		struct /* call_expr */ {
+			struct expression *fn;
+			struct expression_list *args;
+		};
+		// EXPR_LABEL
+		struct /* label_expr */ {
+			struct symbol *label_symbol;
+		};
+		// EXPR_INITIALIZER
+		struct expression_list *expr_list;
+		// EXPR_IDENTIFIER
+		struct /* ident_expr */ {
+			int offset;
+			struct ident *expr_ident;
+			struct symbol *field;
+			struct expression *ident_expression;
+		};
+		// EXPR_INDEX
+		struct /* index_expr */ {
+			unsigned int idx_from, idx_to;
+			struct expression *idx_expression;
+		};
+		// EXPR_POS
+		struct /* initpos_expr */ {
+			unsigned int init_offset, init_nr;
+			struct expression *init_expr;
+		};
+		// EXPR_OFFSETOF
+		struct {
+			struct symbol *in;
+			struct expression *down;
+			union {
+				struct ident *ident;
+				struct expression *index;
+			};
+		};
+	};
+};
+
+/* Constant expression values */
+int is_zero_constant(struct expression *);
+int expr_truth_value(struct expression *expr);
+long long get_expression_value(struct expression *);
+long long const_expression_value(struct expression *);
+long long get_expression_value_silent(struct expression *expr);
+
+/* Expression parsing */
+struct token *parse_expression(struct token *token, struct expression **tree);
+struct token *conditional_expression(struct token *token, struct expression **tree);
+struct token *primary_expression(struct token *token, struct expression **tree);
+struct token *parens_expression(struct token *token, struct expression **expr, const char *where);
+struct token *assignment_expression(struct token *token, struct expression **tree);
+
+extern void evaluate_symbol_list(struct symbol_list *list);
+extern struct symbol *evaluate_statement(struct statement *stmt);
+extern struct symbol *evaluate_expression(struct expression *);
+
+extern int expand_symbol(struct symbol *);
+
+static inline struct expression *alloc_expression(struct position pos, int type)
+{
+	struct expression *expr = __alloc_expression(0);
+	expr->type = type;
+	expr->pos = pos;
+	expr->flags = CEF_NONE;
+	return expr;
+}
+
+static inline struct expression *alloc_const_expression(struct position pos, int value)
+{
+	struct expression *expr = __alloc_expression(0);
+	expr->type = EXPR_VALUE;
+	expr->pos = pos;
+	expr->value = value;
+	expr->ctype = &int_ctype;
+	expr->flags = CEF_SET_INT;
+	return expr;
+}
+
+/* Type name parsing */
+struct token *typename(struct token *, struct symbol **, int *);
+
+static inline int lookup_type(struct token *token)
+{
+	if (token->pos.type == TOKEN_IDENT) {
+		struct symbol *sym = lookup_symbol(token->ident, NS_SYMBOL | NS_TYPEDEF);
+		return sym && (sym->namespace & NS_TYPEDEF);
+	}
+	return 0;
+}
+
+/* Statement parsing */
+struct statement *alloc_statement(struct position pos, int type);
+struct token *initializer(struct expression **tree, struct token *token);
+struct token *compound_statement(struct token *, struct statement *);
+
+/* The preprocessor calls this 'constant_expression()' */
+#define constant_expression(token,tree) conditional_expression(token, tree)
+
+/* Cast folding of constant values.. */
+void cast_value(struct expression *expr, struct symbol *newtype,
+	struct expression *old, struct symbol *oldtype);
+
+#endif
diff --git a/usr/src/tools/smatch/src/flow.c b/usr/src/tools/smatch/src/flow.c
new file mode 100644
index 0000000000..fa5d31c8b2
--- /dev/null
+++ b/usr/src/tools/smatch/src/flow.c
@@ -0,0 +1,1030 @@
+/*
+ * Flow - walk the linearized flowgraph, simplifying it as we
+ * go along.
+ *
+ * Copyright (C) 2004 Linus Torvalds
+ */
+
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <assert.h>
+
+#include "parse.h"
+#include "expression.h"
+#include "linearize.h"
+#include "flow.h"
+#include "target.h"
+
+unsigned long bb_generation;
+
+/*
+ * Dammit, if we have a phi-node followed by a conditional
+ * branch on that phi-node, we should damn well be able to
+ * do something about the source. Maybe.
+ */
+static int rewrite_branch(struct basic_block *bb,
+	struct basic_block **ptr,
+	struct basic_block *old,
+	struct basic_block *new)
+{
+	if (*ptr != old || new == old || !bb->ep)
+		return 0;
+
+	/* We might find new if-conversions or non-dominating CSEs */
+	/* we may also create new dead cycles */
+	repeat_phase |= REPEAT_CSE | REPEAT_CFG_CLEANUP;
+	*ptr = new;
+	replace_bb_in_list(&bb->children, old, new, 1);
+	remove_bb_from_list(&old->parents, bb, 1);
+	add_bb(&new->parents, bb);
+	return 1;
+}
+
+/*
+ * Return the known truth value of a pseudo, or -1 if
+ * it's not known.
+ */
+static int pseudo_truth_value(pseudo_t pseudo)
+{
+	switch (pseudo->type) {
+	case PSEUDO_VAL:
+		return !!pseudo->value;
+
+	case PSEUDO_REG: {
+		struct instruction *insn = pseudo->def;
+
+		/* A symbol address is always considered true.. */
+		if (insn->opcode == OP_SYMADDR && insn->target == pseudo)
+			return 1;
+	}
+		/* Fall through */
+	default:
+		return -1;
+	}
+}
+
+/*
+ * Does a basic block depend on the pseudos that "src" defines?
+ */
+static int bb_depends_on(struct basic_block *target, struct basic_block *src)
+{
+	pseudo_t pseudo;
+
+	FOR_EACH_PTR(src->defines, pseudo) {
+		if (pseudo_in_list(target->needs, pseudo))
+			return 1;
+	} END_FOR_EACH_PTR(pseudo);
+	return 0;
+}
+
+/*
+ * This really should be handled by bb_depends_on()
+ * which efficiently check the dependence using the
+ * defines - needs liveness info. Problem is that
+ * there is no liveness done on OP_PHI & OP_PHISRC.
+ *
+ * This function add the missing dependency checks.
+ */
+static int bb_depends_on_phi(struct basic_block *target, struct basic_block *src)
+{
+	struct instruction *insn;
+	FOR_EACH_PTR(src->insns, insn) {
+		if (!insn->bb)
+			continue;
+		if (insn->opcode != OP_PHI)
+			continue;
+		if (pseudo_in_list(target->needs, insn->target))
+			return 1;
+	} END_FOR_EACH_PTR(insn);
+	return 0;
+}
+
+/*
+ * When we reach here, we have:
+ *  - a basic block that ends in a conditional branch and
+ *    that has no side effects apart from the pseudos it
+ *    may change.
+ *  - the phi-node that the conditional branch depends on
+ *  - full pseudo liveness information
+ *
+ * We need to check if any of the _sources_ of the phi-node
+ * may be constant, and not actually need this block at all.
+ */
+static int try_to_simplify_bb(struct basic_block *bb, struct instruction *first, struct instruction *second)
+{
+	int changed = 0;
+	pseudo_t phi;
+	int bogus;
+
+	/*
+	 * This a due to improper dominance tracking during
+	 * simplify_symbol_usage()/conversion to SSA form.
+	 * No sane simplification can be done when we have this.
+	 */
+	bogus = bb_list_size(bb->parents) != pseudo_list_size(first->phi_list);
+
+	FOR_EACH_PTR(first->phi_list, phi) {
+		struct instruction *def = phi->def;
+		struct basic_block *source, *target;
+		pseudo_t pseudo;
+		struct instruction *br;
+		int true;
+
+		if (!def)
+			continue;
+		source = def->bb;
+		pseudo = def->src1;
+		if (!pseudo || !source)
+			continue;
+		br = last_instruction(source->insns);
+		if (!br)
+			continue;
+		if (br->opcode != OP_CBR && br->opcode != OP_BR)
+			continue;
+		true = pseudo_truth_value(pseudo);
+		if (true < 0)
+			continue;
+		target = true ? second->bb_true : second->bb_false;
+		if (bb_depends_on(target, bb))
+			continue;
+		if (bb_depends_on_phi(target, bb))
+			continue;
+		changed |= rewrite_branch(source, &br->bb_true, bb, target);
+		changed |= rewrite_branch(source, &br->bb_false, bb, target);
+		if (changed && !bogus)
+			kill_use(THIS_ADDRESS(phi));
+	} END_FOR_EACH_PTR(phi);
+	return changed;
+}
+
+static int bb_has_side_effects(struct basic_block *bb)
+{
+	struct instruction *insn;
+	FOR_EACH_PTR(bb->insns, insn) {
+		switch (insn->opcode) {
+		case OP_CALL:
+			/* FIXME! This should take "const" etc into account */
+			return 1;
+
+		case OP_STORE:
+		case OP_CONTEXT:
+			return 1;
+
+		case OP_ASM:
+			/* FIXME! This should take "volatile" etc into account */
+			return 1;
+
+		default:
+			continue;
+		}
+	} END_FOR_EACH_PTR(insn);
+	return 0;
+}
+
+static int simplify_phi_branch(struct basic_block *bb, struct instruction *br)
+{
+	pseudo_t cond = br->cond;
+	struct instruction *def;
+
+	if (cond->type != PSEUDO_REG)
+		return 0;
+	def = cond->def;
+	if (def->bb != bb || def->opcode != OP_PHI)
+		return 0;
+	if (bb_has_side_effects(bb))
+		return 0;
+	return try_to_simplify_bb(bb, def, br);
+}
+
+static int simplify_branch_branch(struct basic_block *bb, struct instruction *br,
+	struct basic_block **target_p, int true)
+{
+	struct basic_block *target = *target_p, *final;
+	struct instruction *insn;
+	int retval;
+
+	if (target == bb)
+		return 0;
+	insn = last_instruction(target->insns);
+	if (!insn || insn->opcode != OP_CBR || insn->cond != br->cond)
+		return 0;
+	/*
+	 * Ahhah! We've found a branch to a branch on the same conditional!
+	 * Now we just need to see if we can rewrite the branch..
+	 */
+	retval = 0;
+	final = true ? insn->bb_true : insn->bb_false;
+	if (bb_has_side_effects(target))
+		goto try_to_rewrite_target;
+	if (bb_depends_on(final, target))
+		goto try_to_rewrite_target;
+	if (bb_depends_on_phi(final, target))
+		return 0;
+	return rewrite_branch(bb, target_p, target, final);
+
+try_to_rewrite_target:
+	/*
+	 * If we're the only parent, at least we can rewrite the
+	 * now-known second branch.
+	 */
+	if (bb_list_size(target->parents) != 1)
+		return retval;
+	insert_branch(target, insn, final);
+	return 1;
+}
+
+static int simplify_one_branch(struct basic_block *bb, struct instruction *br)
+{
+	if (simplify_phi_branch(bb, br))
+		return 1;
+	return simplify_branch_branch(bb, br, &br->bb_true, 1) |
+	       simplify_branch_branch(bb, br, &br->bb_false, 0);
+}
+
+static int simplify_branch_nodes(struct entrypoint *ep)
+{
+	int changed = 0;
+	struct basic_block *bb;
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		struct instruction *br = last_instruction(bb->insns);
+
+		if (!br || br->opcode != OP_CBR)
+			continue;
+		changed |= simplify_one_branch(bb, br);
+	} END_FOR_EACH_PTR(bb);
+	return changed;
+}
+
+/*
+ * This is called late - when we have intra-bb liveness information..
+ */
+int simplify_flow(struct entrypoint *ep)
+{
+	return simplify_branch_nodes(ep);
+}
+
+static inline void concat_user_list(struct pseudo_user_list *src, struct pseudo_user_list **dst)
+{
+	concat_ptr_list((struct ptr_list *)src, (struct ptr_list **)dst);
+}
+
+void convert_instruction_target(struct instruction *insn, pseudo_t src)
+{
+	pseudo_t target;
+	struct pseudo_user *pu;
+	/*
+	 * Go through the "insn->users" list and replace them all..
+	 */
+	target = insn->target;
+	if (target == src)
+		return;
+	FOR_EACH_PTR(target->users, pu) {
+		if (*pu->userp != VOID) {
+			assert(*pu->userp == target);
+			*pu->userp = src;
+		}
+	} END_FOR_EACH_PTR(pu);
+	if (has_use_list(src))
+		concat_user_list(target->users, &src->users);
+	target->users = NULL;
+}
+
+void convert_load_instruction(struct instruction *insn, pseudo_t src)
+{
+	convert_instruction_target(insn, src);
+	/* Turn the load into a no-op */
+	insn->opcode = OP_LNOP;
+	insn->bb = NULL;
+}
+
+static int overlapping_memop(struct instruction *a, struct instruction *b)
+{
+	unsigned int a_start = bytes_to_bits(a->offset);
+	unsigned int b_start = bytes_to_bits(b->offset);
+	unsigned int a_size = a->size;
+	unsigned int b_size = b->size;
+
+	if (a_size + a_start <= b_start)
+		return 0;
+	if (b_size + b_start <= a_start)
+		return 0;
+	return 1;
+}
+
+static inline int same_memop(struct instruction *a, struct instruction *b)
+{
+	return	a->offset == b->offset && a->size == b->size;
+}
+
+static inline int distinct_symbols(pseudo_t a, pseudo_t b)
+{
+	if (a->type != PSEUDO_SYM)
+		return 0;
+	if (b->type != PSEUDO_SYM)
+		return 0;
+	return a->sym != b->sym;
+}
+
+/*
+ * Return 1 if "dom" dominates the access to "pseudo"
+ * in "insn".
+ *
+ * Return 0 if it doesn't, and -1 if you don't know.
+ */
+int dominates(pseudo_t pseudo, struct instruction *insn, struct instruction *dom, int local)
+{
+	int opcode = dom->opcode;
+
+	if (opcode == OP_CALL || opcode == OP_ENTRY)
+		return local ? 0 : -1;
+	if (opcode != OP_LOAD && opcode != OP_STORE)
+		return 0;
+	if (dom->src != pseudo) {
+		if (local)
+			return 0;
+		/* We don't think two explicitly different symbols ever alias */
+		if (distinct_symbols(insn->src, dom->src))
+			return 0;
+		/* We could try to do some alias analysis here */
+		return -1;
+	}
+	if (!same_memop(insn, dom)) {
+		if (dom->opcode == OP_LOAD)
+			return 0;
+		if (!overlapping_memop(insn, dom))
+			return 0;
+		return -1;
+	}
+	return 1;
+}
+
+static int phisrc_in_bb(struct pseudo_list *list, struct basic_block *bb)
+{
+	pseudo_t p;
+	FOR_EACH_PTR(list, p) {
+		if (p->def->bb == bb)
+			return 1;
+	} END_FOR_EACH_PTR(p);
+
+	return 0;
+}
+
+static int find_dominating_parents(pseudo_t pseudo, struct instruction *insn,
+	struct basic_block *bb, unsigned long generation, struct pseudo_list **dominators,
+	int local)
+{
+	struct basic_block *parent;
+
+	if (!bb->parents)
+		return !!local;
+
+	FOR_EACH_PTR(bb->parents, parent) {
+		struct instruction *one;
+		struct instruction *br;
+		pseudo_t phi;
+
+		FOR_EACH_PTR_REVERSE(parent->insns, one) {
+			int dominance;
+			if (one == insn)
+				goto no_dominance;
+			dominance = dominates(pseudo, insn, one, local);
+			if (dominance < 0) {
+				if (one->opcode == OP_LOAD)
+					continue;
+				return 0;
+			}
+			if (!dominance)
+				continue;
+			goto found_dominator;
+		} END_FOR_EACH_PTR_REVERSE(one);
+no_dominance:
+		if (parent->generation == generation)
+			continue;
+		parent->generation = generation;
+
+		if (!find_dominating_parents(pseudo, insn, parent, generation, dominators, local))
+			return 0;
+		continue;
+
+found_dominator:
+		if (dominators && phisrc_in_bb(*dominators, parent))
+			continue;
+		br = delete_last_instruction(&parent->insns);
+		phi = alloc_phi(parent, one->target, one->size);
+		phi->ident = phi->ident ? : pseudo->ident;
+		add_instruction(&parent->insns, br);
+		use_pseudo(insn, phi, add_pseudo(dominators, phi));
+	} END_FOR_EACH_PTR(parent);
+	return 1;
+}		
+
+/*
+ * We should probably sort the phi list just to make it easier to compare
+ * later for equality. 
+ */
+void rewrite_load_instruction(struct instruction *insn, struct pseudo_list *dominators)
+{
+	pseudo_t new, phi;
+
+	/*
+	 * Check for somewhat common case of duplicate
+	 * phi nodes.
+	 */
+	new = first_pseudo(dominators)->def->src1;
+	FOR_EACH_PTR(dominators, phi) {
+		if (new != phi->def->src1)
+			goto complex_phi;
+		new->ident = new->ident ? : phi->ident;
+	} END_FOR_EACH_PTR(phi);
+
+	/*
+	 * All the same pseudo - mark the phi-nodes unused
+	 * and convert the load into a LNOP and replace the
+	 * pseudo.
+	 */
+	FOR_EACH_PTR(dominators, phi) {
+		kill_instruction(phi->def);
+	} END_FOR_EACH_PTR(phi);
+	convert_load_instruction(insn, new);
+	return;
+
+complex_phi:
+	/* We leave symbol pseudos with a bogus usage list here */
+	if (insn->src->type != PSEUDO_SYM)
+		kill_use(&insn->src);
+	insn->opcode = OP_PHI;
+	insn->phi_list = dominators;
+}
+
+static int find_dominating_stores(pseudo_t pseudo, struct instruction *insn,
+	unsigned long generation, int local)
+{
+	struct basic_block *bb = insn->bb;
+	struct instruction *one, *dom = NULL;
+	struct pseudo_list *dominators;
+	int partial;
+
+	/* Unreachable load? Undo it */
+	if (!bb) {
+		insn->opcode = OP_LNOP;
+		return 1;
+	}
+
+	partial = 0;
+	FOR_EACH_PTR(bb->insns, one) {
+		int dominance;
+		if (one == insn)
+			goto found;
+		dominance = dominates(pseudo, insn, one, local);
+		if (dominance < 0) {
+			/* Ignore partial load dominators */
+			if (one->opcode == OP_LOAD)
+				continue;
+			dom = NULL;
+			partial = 1;
+			continue;
+		}
+		if (!dominance)
+			continue;
+		dom = one;
+		partial = 0;
+	} END_FOR_EACH_PTR(one);
+	/* Whaa? */
+	warning(pseudo->sym->pos, "unable to find symbol read");
+	return 0;
+found:
+	if (partial)
+		return 0;
+
+	if (dom) {
+		convert_load_instruction(insn, dom->target);
+		return 1;
+	}
+
+	/* OK, go find the parents */
+	bb->generation = generation;
+
+	dominators = NULL;
+	if (!find_dominating_parents(pseudo, insn, bb, generation, &dominators, local))
+		return 0;
+
+	/* This happens with initial assignments to structures etc.. */
+	if (!dominators) {
+		if (!local)
+			return 0;
+		check_access(insn);
+		convert_load_instruction(insn, value_pseudo(insn->type, 0));
+		return 1;
+	}
+
+	/*
+	 * If we find just one dominating instruction, we
+	 * can turn it into a direct thing. Otherwise we'll
+	 * have to turn the load into a phi-node of the
+	 * dominators.
+	 */
+	rewrite_load_instruction(insn, dominators);
+	return 1;
+}
+
+static void kill_store(struct instruction *insn)
+{
+	if (insn) {
+		insn->bb = NULL;
+		insn->opcode = OP_SNOP;
+		kill_use(&insn->target);
+	}
+}
+
+/* Kill a pseudo that is dead on exit from the bb */
+static void kill_dead_stores(pseudo_t pseudo, unsigned long generation, struct basic_block *bb, int local)
+{
+	struct instruction *insn;
+	struct basic_block *parent;
+
+	if (bb->generation == generation)
+		return;
+	bb->generation = generation;
+	FOR_EACH_PTR_REVERSE(bb->insns, insn) {
+		int opcode = insn->opcode;
+
+		if (opcode != OP_LOAD && opcode != OP_STORE) {
+			if (local)
+				continue;
+			if (opcode == OP_CALL)
+				return;
+			continue;
+		}
+		if (insn->src == pseudo) {
+			if (opcode == OP_LOAD)
+				return;
+			kill_store(insn);
+			continue;
+		}
+		if (local)
+			continue;
+		if (insn->src->type != PSEUDO_SYM)
+			return;
+	} END_FOR_EACH_PTR_REVERSE(insn);
+
+	FOR_EACH_PTR(bb->parents, parent) {
+		struct basic_block *child;
+		FOR_EACH_PTR(parent->children, child) {
+			if (child && child != bb)
+				return;
+		} END_FOR_EACH_PTR(child);
+		kill_dead_stores(pseudo, generation, parent, local);
+	} END_FOR_EACH_PTR(parent);
+}
+
+/*
+ * This should see if the "insn" trivially dominates some previous store, and kill the
+ * store if unnecessary.
+ */
+static void kill_dominated_stores(pseudo_t pseudo, struct instruction *insn, 
+	unsigned long generation, struct basic_block *bb, int local, int found)
+{
+	struct instruction *one;
+	struct basic_block *parent;
+
+	/* Unreachable store? Undo it */
+	if (!bb) {
+		kill_store(insn);
+		return;
+	}
+	if (bb->generation == generation)
+		return;
+	bb->generation = generation;
+	FOR_EACH_PTR_REVERSE(bb->insns, one) {
+		int dominance;
+		if (!found) {
+			if (one != insn)
+				continue;
+			found = 1;
+			continue;
+		}
+		dominance = dominates(pseudo, insn, one, local);
+		if (!dominance)
+			continue;
+		if (dominance < 0)
+			return;
+		if (one->opcode == OP_LOAD)
+			return;
+		kill_store(one);
+	} END_FOR_EACH_PTR_REVERSE(one);
+
+	if (!found) {
+		warning(bb->pos, "Unable to find instruction");
+		return;
+	}
+
+	FOR_EACH_PTR(bb->parents, parent) {
+		struct basic_block *child;
+		FOR_EACH_PTR(parent->children, child) {
+			if (child && child != bb)
+				return;
+		} END_FOR_EACH_PTR(child);
+		kill_dominated_stores(pseudo, insn, generation, parent, local, found);
+	} END_FOR_EACH_PTR(parent);
+}
+
+void check_access(struct instruction *insn)
+{
+	pseudo_t pseudo = insn->src;
+
+	if (insn->bb && pseudo->type == PSEUDO_SYM) {
+		int offset = insn->offset, bit = bytes_to_bits(offset) + insn->size;
+		struct symbol *sym = pseudo->sym;
+
+		if (sym->bit_size > 0 && (offset < 0 || bit > sym->bit_size))
+			warning(insn->pos, "invalid access %s '%s' (%d %d)",
+				offset < 0 ? "below" : "past the end of",
+				show_ident(sym->ident), offset,
+				bits_to_bytes(sym->bit_size));
+	}
+}
+
+static void simplify_one_symbol(struct entrypoint *ep, struct symbol *sym)
+{
+	pseudo_t pseudo;
+	struct pseudo_user *pu;
+	unsigned long mod;
+	int all;
+
+	/* Never used as a symbol? */
+	pseudo = sym->pseudo;
+	if (!pseudo)
+		return;
+
+	/* We don't do coverage analysis of volatiles.. */
+	if (sym->ctype.modifiers & MOD_VOLATILE)
+		return;
+
+	/* ..and symbols with external visibility need more care */
+	mod = sym->ctype.modifiers & (MOD_NONLOCAL | MOD_STATIC | MOD_ADDRESSABLE);
+	if (mod)
+		goto external_visibility;
+
+	FOR_EACH_PTR(pseudo->users, pu) {
+		/* We know that the symbol-pseudo use is the "src" in the instruction */
+		struct instruction *insn = pu->insn;
+
+		switch (insn->opcode) {
+		case OP_STORE:
+			break;
+		case OP_LOAD:
+			break;
+		case OP_SYMADDR:
+			if (!insn->bb)
+				continue;
+			mod |= MOD_ADDRESSABLE;
+			goto external_visibility;
+		case OP_NOP:
+		case OP_SNOP:
+		case OP_LNOP:
+		case OP_PHI:
+			continue;
+		default:
+			warning(sym->pos, "symbol '%s' pseudo used in unexpected way", show_ident(sym->ident));
+		}
+	} END_FOR_EACH_PTR(pu);
+
+external_visibility:
+	all = 1;
+	FOR_EACH_PTR_REVERSE(pseudo->users, pu) {
+		struct instruction *insn = pu->insn;
+		if (insn->opcode == OP_LOAD)
+			all &= find_dominating_stores(pseudo, insn, ++bb_generation, !mod);
+	} END_FOR_EACH_PTR_REVERSE(pu);
+
+	/* If we converted all the loads, remove the stores. They are dead */
+	if (all && !mod) {
+		FOR_EACH_PTR(pseudo->users, pu) {
+			struct instruction *insn = pu->insn;
+			if (insn->opcode == OP_STORE)
+				kill_store(insn);
+		} END_FOR_EACH_PTR(pu);
+	} else {
+		/*
+		 * If we couldn't take the shortcut, see if we can at least kill some
+		 * of them..
+		 */
+		FOR_EACH_PTR(pseudo->users, pu) {
+			struct instruction *insn = pu->insn;
+			if (insn->opcode == OP_STORE)
+				kill_dominated_stores(pseudo, insn, ++bb_generation, insn->bb, !mod, 0);
+		} END_FOR_EACH_PTR(pu);
+
+		if (!(mod & (MOD_NONLOCAL | MOD_STATIC))) {
+			struct basic_block *bb;
+			FOR_EACH_PTR(ep->bbs, bb) {
+				if (!bb->children)
+					kill_dead_stores(pseudo, ++bb_generation, bb, !mod);
+			} END_FOR_EACH_PTR(bb);
+		}
+	}
+			
+	return;
+}
+
+void simplify_symbol_usage(struct entrypoint *ep)
+{
+	pseudo_t pseudo;
+
+	FOR_EACH_PTR(ep->accesses, pseudo) {
+		simplify_one_symbol(ep, pseudo->sym);
+	} END_FOR_EACH_PTR(pseudo);
+}
+
+static void mark_bb_reachable(struct basic_block *bb, unsigned long generation)
+{
+	struct basic_block *child;
+
+	if (bb->generation == generation)
+		return;
+	bb->generation = generation;
+	FOR_EACH_PTR(bb->children, child) {
+		mark_bb_reachable(child, generation);
+	} END_FOR_EACH_PTR(child);
+}
+
+static void kill_defs(struct instruction *insn)
+{
+	pseudo_t target = insn->target;
+
+	if (!has_use_list(target))
+		return;
+	if (target->def != insn)
+		return;
+
+	convert_instruction_target(insn, VOID);
+}
+
+void kill_bb(struct basic_block *bb)
+{
+	struct instruction *insn;
+	struct basic_block *child, *parent;
+
+	FOR_EACH_PTR(bb->insns, insn) {
+		kill_instruction_force(insn);
+		kill_defs(insn);
+		/*
+		 * We kill unreachable instructions even if they
+		 * otherwise aren't "killable" (e.g. volatile loads)
+		 */
+	} END_FOR_EACH_PTR(insn);
+	bb->insns = NULL;
+
+	FOR_EACH_PTR(bb->children, child) {
+		remove_bb_from_list(&child->parents, bb, 0);
+	} END_FOR_EACH_PTR(child);
+	bb->children = NULL;
+
+	FOR_EACH_PTR(bb->parents, parent) {
+		remove_bb_from_list(&parent->children, bb, 0);
+	} END_FOR_EACH_PTR(parent);
+	bb->parents = NULL;
+}
+
+void kill_unreachable_bbs(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+	unsigned long generation = ++bb_generation;
+
+	mark_bb_reachable(ep->entry->bb, generation);
+	FOR_EACH_PTR(ep->bbs, bb) {
+		if (bb->generation == generation)
+			continue;
+		/* Mark it as being dead */
+		kill_bb(bb);
+		bb->ep = NULL;
+		DELETE_CURRENT_PTR(bb);
+	} END_FOR_EACH_PTR(bb);
+	PACK_PTR_LIST(&ep->bbs);
+}
+
+static int rewrite_parent_branch(struct basic_block *bb, struct basic_block *old, struct basic_block *new)
+{
+	int changed = 0;
+	struct instruction *insn = last_instruction(bb->insns);
+
+	if (!insn)
+		return 0;
+
+	/* Infinite loops: let's not "optimize" them.. */
+	if (old == new)
+		return 0;
+
+	switch (insn->opcode) {
+	case OP_CBR:
+		changed |= rewrite_branch(bb, &insn->bb_false, old, new);
+		/* fall through */
+	case OP_BR:
+		changed |= rewrite_branch(bb, &insn->bb_true, old, new);
+		assert(changed);
+		return changed;
+	case OP_SWITCH: {
+		struct multijmp *jmp;
+		FOR_EACH_PTR(insn->multijmp_list, jmp) {
+			changed |= rewrite_branch(bb, &jmp->target, old, new);
+		} END_FOR_EACH_PTR(jmp);
+		assert(changed);
+		return changed;
+	}
+	default:
+		return 0;
+	}
+}
+
+static struct basic_block * rewrite_branch_bb(struct basic_block *bb, struct instruction *br)
+{
+	struct basic_block *parent;
+	struct basic_block *target = br->bb_true;
+	struct basic_block *false = br->bb_false;
+
+	if (br->opcode == OP_CBR) {
+		pseudo_t cond = br->cond;
+		if (cond->type != PSEUDO_VAL)
+			return NULL;
+		target = cond->value ? target : false;
+	}
+
+	/*
+	 * We can't do FOR_EACH_PTR() here, because the parent list
+	 * may change when we rewrite the parent.
+	 */
+	while ((parent = first_basic_block(bb->parents)) != NULL) {
+		if (!rewrite_parent_branch(parent, bb, target))
+			return NULL;
+	}
+	return target;
+}
+
+static void vrfy_bb_in_list(struct basic_block *bb, struct basic_block_list *list)
+{
+	if (bb) {
+		struct basic_block *tmp;
+		int no_bb_in_list = 0;
+
+		FOR_EACH_PTR(list, tmp) {
+			if (bb == tmp)
+				return;
+		} END_FOR_EACH_PTR(tmp);
+		assert(no_bb_in_list);
+	}
+}
+
+static void vrfy_parents(struct basic_block *bb)
+{
+	struct basic_block *tmp;
+	FOR_EACH_PTR(bb->parents, tmp) {
+		vrfy_bb_in_list(bb, tmp->children);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void vrfy_children(struct basic_block *bb)
+{
+	struct basic_block *tmp;
+	struct instruction *br = last_instruction(bb->insns);
+
+	if (!br) {
+		assert(!bb->children);
+		return;
+	}
+	switch (br->opcode) {
+		struct multijmp *jmp;
+	case OP_CBR:
+		vrfy_bb_in_list(br->bb_false, bb->children);
+		/* fall through */
+	case OP_BR:
+		vrfy_bb_in_list(br->bb_true, bb->children);
+		break;
+	case OP_SWITCH:
+	case OP_COMPUTEDGOTO:
+		FOR_EACH_PTR(br->multijmp_list, jmp) {
+			vrfy_bb_in_list(jmp->target, bb->children);
+		} END_FOR_EACH_PTR(jmp);
+		break;
+	default:
+		break;
+	}
+		
+	FOR_EACH_PTR(bb->children, tmp) {
+		vrfy_bb_in_list(bb, tmp->parents);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void vrfy_bb_flow(struct basic_block *bb)
+{
+	vrfy_children(bb);
+	vrfy_parents(bb);
+}
+
+void vrfy_flow(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+	struct basic_block *entry = ep->entry->bb;
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		if (bb == entry)
+			entry = NULL;
+		vrfy_bb_flow(bb);
+	} END_FOR_EACH_PTR(bb);
+	assert(!entry);
+}
+
+void pack_basic_blocks(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+
+	/* See if we can merge a bb into another one.. */
+	FOR_EACH_PTR(ep->bbs, bb) {
+		struct instruction *first, *insn;
+		struct basic_block *parent, *child, *last;
+
+		if (!bb_reachable(bb))
+			continue;
+
+		/*
+		 * Just a branch?
+		 */
+		FOR_EACH_PTR(bb->insns, first) {
+			if (!first->bb)
+				continue;
+			switch (first->opcode) {
+			case OP_NOP: case OP_LNOP: case OP_SNOP:
+				continue;
+			case OP_CBR:
+			case OP_BR: {
+				struct basic_block *replace;
+				replace = rewrite_branch_bb(bb, first);
+				if (replace) {
+					kill_bb(bb);
+					goto no_merge;
+				}
+			}
+			/* fallthrough */
+			default:
+				goto out;
+			}
+		} END_FOR_EACH_PTR(first);
+
+out:
+		/*
+		 * See if we only have one parent..
+		 */
+		last = NULL;
+		FOR_EACH_PTR(bb->parents, parent) {
+			if (last) {
+				if (last != parent)
+					goto no_merge;
+				continue;
+			}
+			last = parent;
+		} END_FOR_EACH_PTR(parent);
+
+		parent = last;
+		if (!parent || parent == bb)
+			continue;
+
+		/*
+		 * Goodie. See if the parent can merge..
+		 */
+		FOR_EACH_PTR(parent->children, child) {
+			if (child != bb)
+				goto no_merge;
+		} END_FOR_EACH_PTR(child);
+
+		/*
+		 * Merge the two.
+		 */
+		repeat_phase |= REPEAT_CSE;
+
+		parent->children = bb->children;
+		bb->children = NULL;
+		bb->parents = NULL;
+
+		FOR_EACH_PTR(parent->children, child) {
+			replace_bb_in_list(&child->parents, bb, parent, 0);
+		} END_FOR_EACH_PTR(child);
+
+		kill_instruction(delete_last_instruction(&parent->insns));
+		FOR_EACH_PTR(bb->insns, insn) {
+			if (insn->bb) {
+				assert(insn->bb == bb);
+				insn->bb = parent;
+			}
+			add_instruction(&parent->insns, insn);
+		} END_FOR_EACH_PTR(insn);
+		bb->insns = NULL;
+
+	no_merge:
+		/* nothing to do */;
+	} END_FOR_EACH_PTR(bb);
+}
+
+
diff --git a/usr/src/tools/smatch/src/flow.h b/usr/src/tools/smatch/src/flow.h
new file mode 100644
index 0000000000..b592ad4d3c
--- /dev/null
+++ b/usr/src/tools/smatch/src/flow.h
@@ -0,0 +1,52 @@
+#ifndef FLOW_H
+#define FLOW_H
+
+#include "lib.h"
+
+extern unsigned long bb_generation;
+
+#define REPEAT_CSE		1
+#define REPEAT_SYMBOL_CLEANUP	2
+#define REPEAT_CFG_CLEANUP	3
+
+struct entrypoint;
+struct instruction;
+
+extern int simplify_flow(struct entrypoint *ep);
+
+extern void simplify_symbol_usage(struct entrypoint *ep);
+extern void simplify_memops(struct entrypoint *ep);
+extern void pack_basic_blocks(struct entrypoint *ep);
+
+extern void convert_instruction_target(struct instruction *insn, pseudo_t src);
+extern void cleanup_and_cse(struct entrypoint *ep);
+extern int simplify_instruction(struct instruction *);
+
+extern void kill_bb(struct basic_block *);
+extern void kill_use(pseudo_t *);
+extern void kill_unreachable_bbs(struct entrypoint *ep);
+
+extern void kill_insn(struct instruction *, int force);
+static inline void kill_instruction(struct instruction *insn)
+{
+	kill_insn(insn, 0);
+}
+static inline void kill_instruction_force(struct instruction *insn)
+{
+	kill_insn(insn, 1);
+}
+
+void check_access(struct instruction *insn);
+void convert_load_instruction(struct instruction *, pseudo_t);
+void rewrite_load_instruction(struct instruction *, struct pseudo_list *);
+int dominates(pseudo_t pseudo, struct instruction *insn, struct instruction *dom, int local);
+
+extern void clear_liveness(struct entrypoint *ep);
+extern void track_pseudo_liveness(struct entrypoint *ep);
+extern void track_pseudo_death(struct entrypoint *ep);
+extern void track_phi_uses(struct instruction *insn);
+
+extern void vrfy_flow(struct entrypoint *ep);
+extern int pseudo_in_list(struct pseudo_list *list, pseudo_t pseudo);
+
+#endif
diff --git a/usr/src/tools/smatch/src/gcc-attr-list.h b/usr/src/tools/smatch/src/gcc-attr-list.h
new file mode 100644
index 0000000000..9acb982fd7
--- /dev/null
+++ b/usr/src/tools/smatch/src/gcc-attr-list.h
@@ -0,0 +1,221 @@
+GCC_ATTR(BELOW100)
+GCC_ATTR(OS_Task)
+GCC_ATTR(OS_main)
+GCC_ATTR(OS_task)
+GCC_ATTR(abi_tag)
+GCC_ATTR(absdata)
+GCC_ATTR(address)
+GCC_ATTR(alias)
+GCC_ATTR(aligned)
+GCC_ATTR(alloc_align)
+GCC_ATTR(alloc_size)
+GCC_ATTR(altivec)
+GCC_ATTR(always_inline)
+GCC_ATTR(artificial)
+GCC_ATTR(assume_aligned)
+GCC_ATTR(aux)
+GCC_ATTR(bank_switch)
+GCC_ATTR(based)
+GCC_ATTR(below100)
+GCC_ATTR(bnd_instrument)
+GCC_ATTR(bnd_legacy)
+GCC_ATTR(bnd_variable_size)
+GCC_ATTR(break_handler)
+GCC_ATTR(brk_interrupt)
+GCC_ATTR(callee_pop_aggregate_return)
+GCC_ATTR(cb)
+GCC_ATTR(cdecl)
+GCC_ATTR(cleanup)
+GCC_ATTR(cmse_nonsecure_call)
+GCC_ATTR(cmse_nonsecure_entry)
+GCC_ATTR(cold)
+GCC_ATTR(common)
+GCC_ATTR(common_object)
+GCC_ATTR(const)
+GCC_ATTR(constructor)
+GCC_ATTR(critical)
+GCC_ATTR(default)
+GCC_ATTR(deprecated)
+GCC_ATTR(designated_init)
+GCC_ATTR(destructor)
+GCC_ATTR(disinterrupt)
+GCC_ATTR(dllexport)
+GCC_ATTR(dllimport)
+GCC_ATTR(eightbit_data)
+GCC_ATTR(either)
+GCC_ATTR(error)
+GCC_ATTR(exception)
+GCC_ATTR(exception_handler)
+GCC_ATTR(externally_visible)
+GCC_ATTR(fallthrough)
+GCC_ATTR(far)
+GCC_ATTR(fast_interrupt)
+GCC_ATTR(fastcall)
+GCC_ATTR(flatten)
+GCC_ATTR(force_align_arg_pointer)
+GCC_ATTR(format)
+GCC_ATTR(format_arg)
+GCC_ATTR(forwarder_section)
+GCC_ATTR(function_return)
+GCC_ATTR(function_return_mem)
+GCC_ATTR(function_return_reg)
+GCC_ATTR(function_vector)
+GCC_ATTR(gcc_struct)
+GCC_ATTR(gnu_inline)
+GCC_ATTR(hidden)
+GCC_ATTR(hot)
+GCC_ATTR(hotpatch)
+GCC_ATTR(ifunc)
+GCC_ATTR(indirect_branch)
+GCC_ATTR(indirect_branch_call)
+GCC_ATTR(indirect_branch_jump)
+GCC_ATTR(init_priority)
+GCC_ATTR(interfacearm)
+GCC_ATTR(internal)
+GCC_ATTR(interrupt)
+GCC_ATTR(interrupt_handler)
+GCC_ATTR(interrupt_thread)
+GCC_ATTR(io)
+GCC_ATTR(io_low)
+GCC_ATTR(isr)
+GCC_ATTR(jli_always)
+GCC_ATTR(jli_fixed)
+GCC_ATTR(keep_interrupts_masked)
+GCC_ATTR(kernel)
+GCC_ATTR(kspisusp)
+GCC_ATTR(l1_data)
+GCC_ATTR(l1_data_A)
+GCC_ATTR(l1_data_B)
+GCC_ATTR(l1_text)
+GCC_ATTR(l2)
+GCC_ATTR(leaf)
+GCC_ATTR(long_call)
+GCC_ATTR(longcall)
+GCC_ATTR(lower)
+GCC_ATTR(malloc)
+GCC_ATTR(may_alias)
+GCC_ATTR(maybe_unused)
+GCC_ATTR(medium_call)
+GCC_ATTR(micromips)
+GCC_ATTR(mips16)
+GCC_ATTR(mode)
+GCC_ATTR(model)
+GCC_ATTR(monitor)
+GCC_ATTR(ms_abi)
+GCC_ATTR(ms_hook_prologue)
+GCC_ATTR(ms_struct)
+GCC_ATTR(naked)
+GCC_ATTR(near)
+GCC_ATTR(nested)
+GCC_ATTR(nested_ready)
+GCC_ATTR(nesting)
+GCC_ATTR(nmi)
+GCC_ATTR(nmi_handler)
+GCC_ATTR(no_address_safety_analysis)
+GCC_ATTR(no_caller_saved_registers)
+GCC_ATTR(no_gccisr)
+GCC_ATTR(no_icf)
+GCC_ATTR(no_instrument_function)
+GCC_ATTR(no_profile_instrument_function)
+GCC_ATTR(no_reorder)
+GCC_ATTR(no_sanitize)
+GCC_ATTR(no_sanitize_address)
+GCC_ATTR(no_sanitize_thread)
+GCC_ATTR(no_sanitize_undefined)
+GCC_ATTR(no_split_stack)
+GCC_ATTR(no_stack_limit)
+GCC_ATTR(nocf_check)
+GCC_ATTR(noclone)
+GCC_ATTR(nocommon)
+GCC_ATTR(nocompression)
+GCC_ATTR(nodiscard)
+GCC_ATTR(noinit)
+GCC_ATTR(noinline)
+GCC_ATTR(noipa)
+GCC_ATTR(nomicromips)
+GCC_ATTR(nomips16)
+GCC_ATTR(nonnull)
+GCC_ATTR(nonstring)
+GCC_ATTR(noplt)
+GCC_ATTR(noreturn)
+GCC_ATTR(nosave_low_regs)
+GCC_ATTR(not_nested)
+GCC_ATTR(nothrow)
+GCC_ATTR(notshared)
+GCC_ATTR(optimize)
+GCC_ATTR(packed)
+GCC_ATTR(partial_save)
+GCC_ATTR(patchable_function_entry)
+GCC_ATTR(pcs)
+GCC_ATTR(persistent)
+GCC_ATTR(progmem)
+GCC_ATTR(protected)
+GCC_ATTR(pure)
+GCC_ATTR(reentrant)
+GCC_ATTR(regparm)
+GCC_ATTR(renesas)
+GCC_ATTR(resbank)
+GCC_ATTR(reset)
+GCC_ATTR(returns_nonnull)
+GCC_ATTR(returns_twice)
+GCC_ATTR(s390_vector_bool)
+GCC_ATTR(saddr)
+GCC_ATTR(save_all)
+GCC_ATTR(save_volatiles)
+GCC_ATTR(saveall)
+GCC_ATTR(scalar_storage_order)
+GCC_ATTR(sda)
+GCC_ATTR(section)
+GCC_ATTR(secure_call)
+GCC_ATTR(selectany)
+GCC_ATTR(sentinel)
+GCC_ATTR(shared)
+GCC_ATTR(short_call)
+GCC_ATTR(shortcall)
+GCC_ATTR(signal)
+GCC_ATTR(simd)
+GCC_ATTR(sp_switch)
+GCC_ATTR(spu_vector)
+GCC_ATTR(sseregparm)
+GCC_ATTR(stack_protect)
+GCC_ATTR(stdcall)
+GCC_ATTR(syscall_linkage)
+GCC_ATTR(sysv_abi)
+GCC_ATTR(target)
+GCC_ATTR(target_clones)
+GCC_ATTR(tda)
+GCC_ATTR(thiscall)
+GCC_ATTR(tiny)
+GCC_ATTR(tiny_data)
+GCC_ATTR(tls_model)
+GCC_ATTR(transaction_callable)
+GCC_ATTR(transaction_may_cancel_outer)
+GCC_ATTR(transaction_pure)
+GCC_ATTR(transaction_safe)
+GCC_ATTR(transaction_safe_dynamic)
+GCC_ATTR(transaction_unsafe)
+GCC_ATTR(transaction_wrap)
+GCC_ATTR(transparent_union)
+GCC_ATTR(trap_exit)
+GCC_ATTR(trapa_handler)
+GCC_ATTR(uncached)
+GCC_ATTR(unused)
+GCC_ATTR(upper)
+GCC_ATTR(use_debug_exception_return)
+GCC_ATTR(use_shadow_register_set)
+GCC_ATTR(used)
+GCC_ATTR(vector)
+GCC_ATTR(vector_size)
+GCC_ATTR(version_id)
+GCC_ATTR(visibility)
+GCC_ATTR(vliw)
+GCC_ATTR(volatile)
+GCC_ATTR(wakeup)
+GCC_ATTR(warm)
+GCC_ATTR(warn_if_not_aligned)
+GCC_ATTR(warn_unused)
+GCC_ATTR(warn_unused_result)
+GCC_ATTR(warning)
+GCC_ATTR(weak)
+GCC_ATTR(weakref)
+GCC_ATTR(zda)
diff --git a/usr/src/tools/smatch/src/gdbhelpers b/usr/src/tools/smatch/src/gdbhelpers
new file mode 100644
index 0000000000..86347863ae
--- /dev/null
+++ b/usr/src/tools/smatch/src/gdbhelpers
@@ -0,0 +1,307 @@
+
+# Don't forget to rebuild sparse with uncommented debug options
+# in the Makefile. Also, gcc 3 is known to screw up with the
+# cpp macros in the debugging info.
+
+
+# If a gdb_show_* function is running at a non-zero recursion
+# level, only a short summary is shown, preventing further
+# recursion. Also note that gdb has only one, global, scope
+# for variables, so we need to be careful with recursions.
+
+
+set $showing_token = 0
+set $showing_ident = 0
+set $showing_symbol = 0
+
+set $ntabs = 0
+
+define gdb_tabs
+	set $tmp = $ntabs
+	while ($tmp--)
+		printf "\t"
+	end
+end
+
+
+# Ptr list handling
+define ptr_entry
+	set $ptr = $arg0
+	set $index = $arg1
+	set $entry = &($arg2)
+
+	set *($entry) = (void *) (~3UL & (unsigned long)$ptr->list[$index])
+end
+
+
+# Ptr list looping skeleton
+define gdb_ptr_list_for_each
+
+	set $my_head = (struct ptr_list *) $arg0
+	set $my_list = $my_head
+
+
+	if ($my_head)
+		while (1)
+			set $my_nr = 0
+			while ($my_nr < $my_list->nr)
+
+				# Put your iterator code here
+				set $my_nr++
+			end
+
+			if (($my_list = $my_list->next) == $my_head)
+				loop_break
+			end
+		end
+	end
+end
+
+# Show symbols in a symbol_list. Non-recursive
+define gdb_ptr_list_for_each_show_symbol
+
+	set $my_head = (struct ptr_list *) $arg0
+	set $my_list = $my_head
+
+
+	if ($my_head)
+		while (1)
+			set $my_nr = 0
+			while ($my_nr < ($my_list)->nr)
+				set $my_symbol = (struct symbol *) ((~3UL) & (unsigned long)($my_list)->list[$my_nr])
+				gdb_show_symbol($my_symbol)
+
+				set $my_nr++
+			end
+
+			set $my_list = ($my_list)->next
+			if ($my_list == $my_head)
+				loop_break
+			end
+		end
+	end
+end
+
+
+#define gdb_show_statement
+
+
+# Recursive
+define gdb_show_ctype
+	printf "modifiers: "
+	if ($arg0->modifiers & MOD_AUTO)
+		printf "MOD_AUTO "
+	end
+	if ($arg0->modifiers & MOD_REGISTER)
+		printf "MOD_REGISTER "
+	end
+	if ($arg0->modifiers & MOD_STATIC)
+		printf "MOD_STATIC "
+	end
+	if ($arg0->modifiers & MOD_EXTERN)
+		printf "MOD_EXTERN "
+	end
+	if ($arg0->modifiers & MOD_CONST)
+		printf "MOD_CONST "
+	end
+	if ($arg0->modifiers & MOD_VOLATILE)
+		printf "MOD_VOLATILE "
+	end
+	if ($arg0->modifiers & MOD_SIGNED)
+		printf "MOD_SIGNED "
+	end
+	if ($arg0->modifiers & MOD_UNSIGNED)
+		printf "MOD_UNSIGNED "
+	end
+	if ($arg0->modifiers & MOD_CHAR)
+		printf "MOD_CHAR "
+	end
+	if ($arg0->modifiers & MOD_SHORT)
+		printf "MOD_SHORT "
+	end
+	if ($arg0->modifiers & MOD_LONG)
+		printf "MOD_LONG "
+	end
+	if ($arg0->modifiers & MOD_LONGLONG)
+		printf "MOD_LONGLONG "
+	end
+	if ($arg0->modifiers & MOD_LONGLONGLONG)
+		printf "MOD_LONGLONGLONG "
+	end
+	if ($arg0->modifiers & MOD_TYPEDEF)
+		printf "MOD_TYPEDEF "
+	end
+	if ($arg0->modifiers & MOD_INLINE)
+		printf "MOD_INLINE "
+	end
+	if ($arg0->modifiers & MOD_ADDRESSABLE)
+		printf "MOD_ADDRESSABLE "
+	end
+	if ($arg0->modifiers & MOD_NOCAST)
+		printf "MOD_NOCAST "
+	end
+	if ($arg0->modifiers & MOD_NODEREF)
+		printf "MOD_NODEREF "
+	end
+	if ($arg0->modifiers & MOD_ACCESSED)
+		printf "MOD_ACCESSED "
+	end
+	if ($arg0->modifiers & MOD_TOPLEVEL)
+		printf "MOD_TOPLEVEL "
+	end
+	if ($arg0->modifiers & MOD_ASSIGNED)
+		printf "MOD_ASSIGNED "
+	end
+	if ($arg0->modifiers & MOD_TYPE)
+		printf "MOD_TYPE "
+	end
+	if ($arg0->modifiers & MOD_SAFE)
+		printf "MOD_SAFE "
+	end
+	if ($arg0->modifiers & MOD_USERTYPE)
+		printf "MOD_USERTYPE "
+	end
+	if ($arg0->modifiers & MOD_EXPLICITLY_SIGNED)
+		printf "MOD_EXPLICITLY_SIGNED"
+	end
+	if ($arg0->modifiers & MOD_BITWISE)
+		printf "MOD_BITWISE "
+	end
+	if (!$arg0->modifiers)
+		printf "0"
+	end
+
+	printf ", alignment = %d", $arg0->alignment
+	if ($arg0->as)
+		printf ", address_space = %d", $arg0->as
+	end
+	printf "\n"
+
+
+	set $ntabs++
+	if ($arg0->base_type)
+		gdb_tabs
+		printf "base_type = "
+		gdb_show_symbol($arg0->base_type)
+	end
+
+	set $ntabs--
+
+
+end
+
+define gdb_show_symbol
+	printf "(%x) type = ", $arg0
+	output $arg0->type
+	printf ", namespace = "
+	output $arg0->namespace
+	if ($arg0->ident)
+		printf ", ident = %s\n", show_ident($arg0->ident)
+	else
+		printf ", ident = NULL\n"
+	end
+
+#	print "zz"
+
+	gdb_tabs
+	printf "dump:\n"
+	call show_symbol($arg0)
+
+	set $ntabs++
+	if ($arg0->namespace == NS_SYMBOL)
+		gdb_tabs
+		printf "ctype = "
+		gdb_show_ctype(&($arg0->ctype))
+	end
+	set $ntabs--
+end
+
+
+# non-recursive
+define gdb_show_symbols_next_id
+	set $sym = $arg0
+	printf "{\n"
+	set $ntabs++
+	while ($sym)
+		gdb_tabs
+		printf "symbol = "
+		gdb_show_symbol($sym)
+		set $sym = $sym->next_id
+	end
+	set $ntabs--
+	gdb_tabs
+	printf "}\n"
+end
+
+define gdb_show_ident
+	if ($arg0)
+		printf "(%p) '%s'\n", $arg0, show_ident($arg0)
+	else
+		printf "NULL\n"
+	end
+
+	if (! $showing_ident)
+		set $showing_ident = 1
+		set $ntabs++
+
+		set $ident = $arg0
+
+		if ($ident->symbols)
+			gdb_tabs
+			printf "symbols = "
+			gdb_show_symbols_next_id($ident->symbols)
+		end
+
+		set $ntabs--
+		set $showing_ident = 0
+	end
+end
+
+define gdb_show_token
+	printf "%p: '%s', type = ", $arg0, show_token($arg0)
+	output (enum token_type) ($arg0)->pos.type
+	printf "\n"
+
+	if (! $showing_token)
+		set $showing_token = 1
+		set $ntabs++
+
+		set $token = $arg0
+
+		if ($token->pos.type == TOKEN_IDENT)
+			gdb_tabs
+			printf "ident = "
+			gdb_show_ident $token.ident
+		end
+
+		if ($token->pos.type == TOKEN_MACRO_ARGUMENT)
+			gdb_tabs
+			printf "argnum = %d\n", $token->argnum
+		end
+
+		if ($token->pos.type == TOKEN_SPECIAL)
+			gdb_tabs
+			printf "special = \"%s\"\n", show_special($token.special)
+		end
+
+		set $ntabs--
+		set $showing_token = 0
+	end
+end
+
+# non-recursive
+define gdb_show_tokens
+	set $t = $arg0
+	printf "{\n"
+	set $ntabs++
+	while ($t != &eof_token_entry)
+		gdb_tabs
+		printf "token = "
+		gdb_show_token($t)
+		set $t = ($t)->next
+	end
+	set $ntabs--
+	gdb_tabs
+	printf "}\n"
+end
+
diff --git a/usr/src/tools/smatch/src/graph.c b/usr/src/tools/smatch/src/graph.c
new file mode 100644
index 0000000000..22c90be936
--- /dev/null
+++ b/usr/src/tools/smatch/src/graph.c
@@ -0,0 +1,202 @@
+/* Copyright © International Business Machines Corp., 2006
+ *              Adelard LLP, 2007
+ *
+ * Author: Josh Triplett <josh@freedesktop.org>
+ *         Dan Sheridan <djs@adelard.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+#include "linearize.h"
+
+
+/* Draw the subgraph for a given entrypoint. Includes details of loads
+ * and stores for globals, and marks return bbs */
+static void graph_ep(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+	struct instruction *insn;
+
+	const char *fname, *sname;
+
+	fname = show_ident(ep->name->ident);
+	sname = stream_name(ep->entry->bb->pos.stream);
+
+	printf("subgraph cluster%p {\n"
+	       "    color=blue;\n"
+	       "    label=<<TABLE BORDER=\"0\" CELLBORDER=\"0\">\n"
+	       "             <TR><TD>%s</TD></TR>\n"
+	       "             <TR><TD><FONT POINT-SIZE=\"21\">%s()</FONT></TD></TR>\n"
+	       "           </TABLE>>;\n"
+	       "    file=\"%s\";\n"
+	       "    fun=\"%s\";\n"
+	       "    ep=bb%p;\n",
+	       ep, sname, fname, sname, fname, ep->entry->bb);
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		struct basic_block *child;
+		int ret = 0;
+		const char * s = ", ls=\"[";
+
+		/* Node for the bb */
+		printf("    bb%p [shape=ellipse,label=%d,line=%d,col=%d",
+		       bb, bb->pos.line, bb->pos.line, bb->pos.pos);
+
+
+		/* List loads and stores */
+		FOR_EACH_PTR(bb->insns, insn) {
+			switch(insn->opcode) {
+			case OP_STORE:
+				if (insn->symbol->type == PSEUDO_SYM) {
+				  printf("%s store(%s)", s, show_ident(insn->symbol->sym->ident));
+				  s = ",";
+				}
+				break;
+
+			case OP_LOAD:
+				if (insn->symbol->type == PSEUDO_SYM) {
+				  printf("%s load(%s)", s, show_ident(insn->symbol->sym->ident));
+				  s = ",";
+				}
+				break;
+
+			case OP_RET:
+				ret = 1;
+				break;
+
+			}
+		} END_FOR_EACH_PTR(insn);
+		if (s[1] == 0)
+			printf("]\"");
+		if (ret)
+			printf(",op=ret");
+		printf("];\n");
+
+		/* Edges between bbs; lower weight for upward edges */
+		FOR_EACH_PTR(bb->children, child) {
+			printf("    bb%p -> bb%p [op=br, %s];\n", bb, child,
+			       (bb->pos.line > child->pos.line) ? "weight=5" : "weight=10");
+		} END_FOR_EACH_PTR(child);
+	} END_FOR_EACH_PTR(bb);
+
+	printf("}\n");
+}
+
+
+/* Insert edges for intra- or inter-file calls, depending on the value
+ * of internal. Bold edges are used for calls with destinations;
+ * dashed for calls to external functions */
+static void graph_calls(struct entrypoint *ep, int internal)
+{
+	struct basic_block *bb;
+	struct instruction *insn;
+
+	show_ident(ep->name->ident);
+	stream_name(ep->entry->bb->pos.stream);
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		if (!bb)
+			continue;
+		if (!bb->parents && !bb->children && !bb->insns && verbose < 2)
+			continue;
+
+		FOR_EACH_PTR(bb->insns, insn) {
+			if (insn->opcode == OP_CALL &&
+			    internal == !(insn->func->sym->ctype.modifiers & MOD_EXTERN)) {
+
+				/* Find the symbol for the callee's definition */
+				struct symbol * sym;
+				if (insn->func->type == PSEUDO_SYM) {
+					for (sym = insn->func->sym->ident->symbols;
+					     sym; sym = sym->next_id) {
+						if (sym->namespace & NS_SYMBOL && sym->ep)
+							break;
+					}
+
+					if (sym)
+						printf("bb%p -> bb%p"
+						       "[label=%d,line=%d,col=%d,op=call,style=bold,weight=30];\n",
+						       bb, sym->ep->entry->bb,
+						       insn->pos.line, insn->pos.line, insn->pos.pos);
+					else
+						printf("bb%p -> \"%s\" "
+						       "[label=%d,line=%d,col=%d,op=extern,style=dashed];\n",
+						       bb, show_pseudo(insn->func),
+						       insn->pos.line, insn->pos.line, insn->pos.pos);
+				}
+			}
+		} END_FOR_EACH_PTR(insn);
+	} END_FOR_EACH_PTR(bb);
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	char *file;
+	struct symbol *sym;
+
+	struct symbol_list *fsyms, *all_syms=NULL;
+
+	printf("digraph call_graph {\n");
+	fsyms = sparse_initialize(argc, argv, &filelist);
+	concat_symbol_list(fsyms, &all_syms);
+
+	/* Linearize all symbols, graph internal basic block
+	 * structures and intra-file calls */
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+
+		fsyms = sparse(file);
+		concat_symbol_list(fsyms, &all_syms);
+
+		FOR_EACH_PTR(fsyms, sym) {
+			expand_symbol(sym);
+			linearize_symbol(sym);
+		} END_FOR_EACH_PTR(sym);
+
+		FOR_EACH_PTR(fsyms, sym) {
+			if (sym->ep) {
+				graph_ep(sym->ep);
+				graph_calls(sym->ep, 1);
+			}
+		} END_FOR_EACH_PTR_NOTAG(sym);
+
+	} END_FOR_EACH_PTR_NOTAG(file);
+
+	/* Graph inter-file calls */
+	FOR_EACH_PTR(all_syms, sym) {
+		if (sym->ep)
+			graph_calls(sym->ep, 0);
+	} END_FOR_EACH_PTR_NOTAG(sym);
+
+	printf("}\n");
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/gvpr/return-paths b/usr/src/tools/smatch/src/gvpr/return-paths
new file mode 100755
index 0000000000..5815fc70b7
--- /dev/null
+++ b/usr/src/tools/smatch/src/gvpr/return-paths
@@ -0,0 +1,107 @@
+#!/usr/bin/gvpr -f
+// Split call sites into call site and return site nodes and add
+// return edges
+//
+// Run with graph ... | return-paths
+
+BEGIN {
+	// Find the immediate parent subgraph of this object
+	graph_t find_owner(obj_t o, graph_t g)
+	{
+		graph_t g1;
+		for (g1 = fstsubg(g); g1; g1 = nxtsubg(g1))
+			if(isIn(g1,o)) return g1;
+		return NULL;
+	}
+}
+
+BEG_G {
+	node_t calls[]; // Crude hash table for tracking who calls what
+	graph_t g,g2;
+	edge_t e,e2;
+	string idx;
+	node_t n, n2;
+	int i;
+
+	$tvtype = TV_en;
+}
+
+// Each call edge which hasn't already been seen
+E [op == "call" && tail.split != 1] {
+	int offset=0;
+
+	// Clear the label of this call
+	label = "";
+	g = find_owner(tail, $G);
+
+	// Consider each outgoing call. Split the node accordingly
+	n = tail;
+	for (e = fstout(tail); e; e = nxtout(e)) {
+		if (e.op == "call") {
+
+			// Split node
+			n2 = node(g, sprintf("%s%s%d", tail.name, "x", offset++));
+			copyA(tail, n2);
+			n2.line = e.line;
+			n2.label = e.line;
+			n2.col = e.col;
+			n2.split = 1;
+			n2.op = "target";
+
+			// Record this call
+			g2 = find_owner(e.head, $G);
+			i = 0;
+			while(calls[sprintf("%s%d", g2.name, ++i)]) {
+			}
+			calls[sprintf("%s%d", g2.name, i)] = n2;
+
+			// Connect original to split
+			e2 = edge(n, n2, "call");
+			e2.style = "dotted";
+			e2.weight = 50;
+
+			// Replace this outedge
+			if (n != tail) {
+				e2 = edge(n, e.head, "transformed-call");
+				copyA(e,e2);
+				e2.label = "";
+				delete($G,e);
+			}
+
+			// Record where we were
+			n = n2;
+		}
+	}
+
+	// Consider the outgoing control flow: move down to the bottom of
+	// the call sequence nodes
+	for (e = fstout(tail); e; e = nxtout(e)) {
+		if (e.op == "br") {
+			// Replace this outedge
+			e2 = edge(n,e.head,"transformed");
+			copyA(e,e2);
+			delete($G,e);
+		}
+	}
+}
+
+// Each return node: add edges back to the caller
+N [op == "ret"] {
+	for (g = fstsubg($G); g; g = nxtsubg(g)) {
+		if(isIn(g,$)) {
+			i = 0;
+			while(calls[sprintf("%s%d", g.name, ++i)]) {
+				e = edge($, calls[sprintf("%s%d", g.name, i)], "return");
+				e.style = "dotted";
+				e.op = "ret";
+				e.line = e.tail.line;
+				e.weight = 5;
+			}
+		}
+	}
+}
+
+
+END_G {
+	write($);
+}
diff --git a/usr/src/tools/smatch/src/gvpr/subg-fwd b/usr/src/tools/smatch/src/gvpr/subg-fwd
new file mode 100755
index 0000000000..c407213035
--- /dev/null
+++ b/usr/src/tools/smatch/src/gvpr/subg-fwd
@@ -0,0 +1,79 @@
+#!/usr/bin/gvpr -f
+// Compute the forward partition of the chosen function
+//
+// Run with graph ... | return-paths | subg-fwd -a functionname
+//       or graph ... | subg-fwd
+
+
+BEGIN {
+	// Find the immediate parent subgraph of this object
+	graph_t find_owner(obj_t o, graph_t g)
+	{
+		graph_t g1;
+		for (g1 = fstsubg(g); g1; g1 = nxtsubg(g1))
+			if(isIn(g1,o)) return g1;
+		return NULL;
+	}
+}
+
+BEG_G {
+	graph_t sg = subg ($, sprintf("incoming-%s", ARGV[0]));
+	graph_t returns = graph("return-edges", ""); // Temporary graph to hold return edges
+	graph_t target, g, g2;
+	node_t n;
+	edge_t e;
+	int i;
+
+	$tvtype = TV_fwd;
+
+	// find the ep corresponding to ARG[0]
+	for (g = fstsubg($G); g; g = nxtsubg(g)) {
+		if(g.fun == ARGV[0]) {
+			n = node($,g.ep);
+			$tvroot = n;
+			n.style = "filled";
+			target = g;
+			break;
+		}
+	}
+	if(!target) {
+		printf(2, "Function %s not found\n", ARGV[0]);
+		exit(1);
+	}
+}
+
+// Preserve external functions
+E [op == "extern"] {
+	subnode (sg, head);
+}
+
+// Move unused return edges into a separate graph so they don't get followed
+N [op == "ret"] {
+	for (e = fstout($); e; e = nxtout(e))
+		if (e.op == "ret" && !isIn(sg, e.head)) {
+			clone(returns, e);
+			delete($G, e);
+		}
+}
+
+// Recover elided return edge for this target node
+N [op == "target" && indegree == 1] {
+	n = copy(returns, $);
+	e = fstin(n); // each target node can only have one return edge
+	e = edge(copy(sg, e.tail), $, "recovered"); // clone should work here, but doesn't
+	copyA(fstin(n), e);
+}
+
+// Copy relevant nodes
+N {
+	$tvroot = NULL;
+
+	g = find_owner($, $G);
+	if(g && g != sg)
+		subnode (copy(sg, g), $);
+}
+
+END_G {
+	induce(sg);
+	write(sg);
+}
diff --git a/usr/src/tools/smatch/src/gvpr/subg-rev b/usr/src/tools/smatch/src/gvpr/subg-rev
new file mode 100755
index 0000000000..cd9bdddd0b
--- /dev/null
+++ b/usr/src/tools/smatch/src/gvpr/subg-rev
@@ -0,0 +1,101 @@
+#!/usr/bin/gvpr -f
+// Compute the reverse partition of the chosen function
+//
+// Run with graph ... | return-paths | subg-rev -a functionname
+
+
+BEGIN {
+	// Find the immediate parent subgraph of this object
+	graph_t find_owner(obj_t o, graph_t g)
+	{
+		graph_t g1;
+		for (g1 = fstsubg(g); g1; g1 = nxtsubg(g1))
+			if(isIn(g1,o)) return g1;
+		return NULL;
+	}
+}
+
+BEG_G {
+	graph_t calls[]; // Crude hash table for tracking who calls what
+	graph_t sg = subg ($, "reachable");
+	graph_t target, g, g2;
+	edge_t e;
+	int i;
+
+	$tvtype = TV_rev;
+
+	// find the ep corresponding to ARG[0]
+	for (g = fstsubg($G); g; g = nxtsubg(g)) {
+		if(g.fun == ARGV[0]) {
+			node_t n;
+			n = node($,g.ep);
+			$tvroot = n;
+			n.style = "filled";
+			target = g;
+			break;
+		}
+	}
+	if(!target) {
+		printf(2, "Function %s not found\n", ARGV[0]);
+		exit(1);
+	}
+
+	// Add the incoming call edges to the allowed call list
+	i = 0;
+	for(e = fstin(n); e; e = nxtin(e)) {
+		if (e.op = "call") {
+			g2 = find_owner(e.tail, $G);
+			calls[sprintf("%s%d", g2.name, ++i)] = g;
+		}
+	}
+}
+
+
+E [op == "ret"] {
+
+	// This is a return edge. Allow the corresponding call
+	g = find_owner(head, $G);
+	i = 0;
+	while(calls[sprintf("%s%d", g.name, ++i)]) {
+	}
+	calls[sprintf("%s%d", g.name, i)] = find_owner(tail, $G);
+	g2 = find_owner(tail, $G);
+}
+
+
+N [split == 1] {
+
+	// Ignore returns back to the target function
+	for (e = fstin($); e; e = nxtin(e))
+		if (e.op == "ret" && isIn(target,e.tail))
+			delete($G,e);
+}
+
+N {
+	$tvroot = NULL;
+
+	for (e = fstin($); e; e = nxtin(e)) {
+		if (e.op == "call") {
+			int found = 0;
+			g = find_owner(e.tail, $G);
+			i = 0;
+			while(calls[sprintf("%s%d", g.name, ++i)]) {
+				if (isIn(calls[sprintf("%s%d", g.name, i)],e.head))
+					found = 1;
+			}
+			g2 = find_owner(e.head, $G);
+			if (!found) delete($G, e);
+		}
+	}
+
+	for (g = fstsubg($G); g; g = nxtsubg(g)) {
+		if(isIn(g,$) && g != sg) {
+			subnode (copy(sg, g), $);
+		}
+	}
+}
+
+END_G {
+	induce(sg);
+	write(sg);
+}
diff --git a/usr/src/tools/smatch/src/ident-list.h b/usr/src/tools/smatch/src/ident-list.h
new file mode 100644
index 0000000000..3fb817e9cc
--- /dev/null
+++ b/usr/src/tools/smatch/src/ident-list.h
@@ -0,0 +1,85 @@
+
+#define IDENT(n) __IDENT(n## _ident, #n, 0)
+#define IDENT_RESERVED(n) __IDENT(n## _ident, #n, 1)
+
+/* Basic C reserved words.. */
+IDENT_RESERVED(sizeof);
+IDENT_RESERVED(if);
+IDENT_RESERVED(else);
+IDENT_RESERVED(return);
+IDENT_RESERVED(switch);
+IDENT_RESERVED(case);
+IDENT_RESERVED(default);
+IDENT_RESERVED(break);
+IDENT_RESERVED(continue);
+IDENT_RESERVED(for);
+IDENT_RESERVED(while);
+IDENT_RESERVED(do);
+IDENT_RESERVED(goto);
+
+/* C typenames. They get marked as reserved when initialized */
+IDENT(struct);
+IDENT(union);
+IDENT(enum);
+IDENT(__attribute); IDENT(__attribute__);
+IDENT(volatile); IDENT(__volatile); IDENT(__volatile__);
+IDENT(double);
+
+/* C storage classes. They get marked as reserved when initialized */
+IDENT(static);
+
+/* C99 keywords */
+IDENT(restrict); IDENT(__restrict); IDENT(__restrict__);
+IDENT(_Bool);
+IDENT(_Complex);
+IDENT_RESERVED(_Imaginary);
+
+/* C11 keywords */
+IDENT(_Alignas);
+IDENT_RESERVED(_Alignof);
+IDENT_RESERVED(_Atomic);
+IDENT_RESERVED(_Generic);
+IDENT(_Noreturn);
+IDENT_RESERVED(_Static_assert);
+IDENT(_Thread_local);
+
+/* Special case for L'\t' */
+IDENT(L);
+
+/* Extended gcc identifiers */
+IDENT(asm); IDENT_RESERVED(__asm); IDENT_RESERVED(__asm__);
+IDENT(alignof); IDENT_RESERVED(__alignof); IDENT_RESERVED(__alignof__); 
+IDENT_RESERVED(__sizeof_ptr__);
+IDENT_RESERVED(__builtin_types_compatible_p);
+IDENT_RESERVED(__builtin_offsetof);
+IDENT_RESERVED(__label__);
+
+/* Preprocessor idents.  Direct use of __IDENT avoids mentioning the keyword
+ * itself by name, preventing these tokens from expanding when compiling
+ * sparse. */
+IDENT(defined);
+IDENT(once);
+__IDENT(pragma_ident, "__pragma__", 0);
+__IDENT(_Pragma_ident, "_Pragma", 0);
+__IDENT(__VA_ARGS___ident, "__VA_ARGS__", 0);
+__IDENT(__LINE___ident, "__LINE__", 0);
+__IDENT(__FILE___ident, "__FILE__", 0);
+__IDENT(__DATE___ident, "__DATE__", 0);
+__IDENT(__TIME___ident, "__TIME__", 0);
+__IDENT(__func___ident, "__func__", 0);
+__IDENT(__FUNCTION___ident, "__FUNCTION__", 0);
+__IDENT(__PRETTY_FUNCTION___ident, "__PRETTY_FUNCTION__", 0);
+__IDENT(__COUNTER___ident, "__COUNTER__", 0);
+
+/* Sparse commands */
+IDENT_RESERVED(__context__);
+IDENT_RESERVED(__range__);
+
+/* Magic function names we recognize */
+IDENT(memset); IDENT(memcpy);
+IDENT(copy_to_user); IDENT(copy_from_user);
+IDENT(main);
+
+#undef __IDENT
+#undef IDENT
+#undef IDENT_RESERVED
diff --git a/usr/src/tools/smatch/src/inline.c b/usr/src/tools/smatch/src/inline.c
new file mode 100644
index 0000000000..a3002c6bda
--- /dev/null
+++ b/usr/src/tools/smatch/src/inline.c
@@ -0,0 +1,585 @@
+/*
+ * Sparse - a semantic source parser.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+
+static struct expression * dup_expression(struct expression *expr)
+{
+	struct expression *dup = alloc_expression(expr->pos, expr->type);
+	*dup = *expr;
+	return dup;
+}
+
+static struct statement * dup_statement(struct statement *stmt)
+{
+	struct statement *dup = alloc_statement(stmt->pos, stmt->type);
+	*dup = *stmt;
+	return dup;
+}
+
+static struct symbol *copy_symbol(struct position pos, struct symbol *sym)
+{
+	if (!sym)
+		return sym;
+	if (sym->ctype.modifiers & (MOD_STATIC | MOD_EXTERN | MOD_TOPLEVEL | MOD_INLINE))
+		return sym;
+	if (!sym->replace) {
+		warning(pos, "unreplaced symbol '%s'", show_ident(sym->ident));
+		return sym;
+	}
+	return sym->replace;
+}
+
+static struct symbol_list *copy_symbol_list(struct symbol_list *src)
+{
+	struct symbol_list *dst = NULL;
+	struct symbol *sym;
+
+	FOR_EACH_PTR(src, sym) {
+		struct symbol *newsym = copy_symbol(sym->pos, sym);
+		add_symbol(&dst, newsym);
+	} END_FOR_EACH_PTR(sym);
+	return dst;
+}
+
+static struct expression * copy_expression(struct expression *expr)
+{
+	if (!expr)
+		return NULL;
+
+	switch (expr->type) {
+	/*
+	 * EXPR_SYMBOL is the interesting case, we may need to replace the
+	 * symbol to the new copy.
+	 */
+	case EXPR_SYMBOL: {
+		struct symbol *sym = copy_symbol(expr->pos, expr->symbol);
+		if (sym == expr->symbol)
+			break;
+		expr = dup_expression(expr);
+		expr->symbol = sym;
+		break;
+	}
+
+	/* Atomics, never change, just return the expression directly */
+	case EXPR_VALUE:
+	case EXPR_STRING:
+	case EXPR_FVALUE:
+	case EXPR_TYPE:
+		break;
+
+	/* Unops: check if the subexpression is unique */
+	case EXPR_PREOP:
+	case EXPR_POSTOP: {
+		struct expression *unop = copy_expression(expr->unop);
+		if (expr->unop == unop)
+			break;
+		expr = dup_expression(expr);
+		expr->unop = unop;
+		break;
+	}
+
+	case EXPR_SLICE: {
+		struct expression *base = copy_expression(expr->base);
+		expr = dup_expression(expr);
+		expr->base = base;
+		break;
+	}
+
+	/* Binops: copy left/right expressions */
+	case EXPR_BINOP:
+	case EXPR_COMMA:
+	case EXPR_COMPARE:
+	case EXPR_LOGICAL: {
+		struct expression *left = copy_expression(expr->left);
+		struct expression *right = copy_expression(expr->right);
+		if (left == expr->left && right == expr->right)
+			break;
+		expr = dup_expression(expr);
+		expr->left = left;
+		expr->right = right;
+		break;
+	}
+
+	case EXPR_ASSIGNMENT: {
+		struct expression *left = copy_expression(expr->left);
+		struct expression *right = copy_expression(expr->right);
+		if (expr->op == '=' && left == expr->left && right == expr->right)
+			break;
+		expr = dup_expression(expr);
+		expr->left = left;
+		expr->right = right;
+		break;
+	}
+
+	/* Dereference */
+	case EXPR_DEREF: {
+		struct expression *deref = copy_expression(expr->deref);
+		expr = dup_expression(expr);
+		expr->deref = deref;
+		break;
+	}
+
+	/* Cast/sizeof/__alignof__ */
+	case EXPR_CAST:
+		if (expr->cast_expression->type == EXPR_INITIALIZER) {
+			struct expression *cast = expr->cast_expression;
+			struct symbol *sym = expr->cast_type;
+			expr = dup_expression(expr);
+			expr->cast_expression = copy_expression(cast);
+			expr->cast_type = alloc_symbol(sym->pos, sym->type);
+			*expr->cast_type = *sym;
+			break;
+		}
+	case EXPR_FORCE_CAST:
+	case EXPR_IMPLIED_CAST:
+	case EXPR_SIZEOF: 
+	case EXPR_PTRSIZEOF:
+	case EXPR_ALIGNOF: {
+		struct expression *cast = copy_expression(expr->cast_expression);
+		if (cast == expr->cast_expression)
+			break;
+		expr = dup_expression(expr);
+		expr->cast_expression = cast;
+		break;
+	}
+
+	/* Conditional expression */
+	case EXPR_SELECT:
+	case EXPR_CONDITIONAL: {
+		struct expression *cond = copy_expression(expr->conditional);
+		struct expression *true = copy_expression(expr->cond_true);
+		struct expression *false = copy_expression(expr->cond_false);
+		if (cond == expr->conditional && true == expr->cond_true && false == expr->cond_false)
+			break;
+		expr = dup_expression(expr);
+		expr->conditional = cond;
+		expr->cond_true = true;
+		expr->cond_false = false;
+		break;
+	}
+
+	/* Statement expression */
+	case EXPR_STATEMENT: {
+		struct statement *stmt = alloc_statement(expr->pos, STMT_COMPOUND);
+		copy_statement(expr->statement, stmt);
+		expr = dup_expression(expr);
+		expr->statement = stmt;
+		break;
+	}
+
+	/* Call expression */
+	case EXPR_CALL: {
+		struct expression *fn = copy_expression(expr->fn);
+		struct expression_list *list = expr->args;
+		struct expression *arg;
+
+		expr = dup_expression(expr);
+		expr->fn = fn;
+		expr->args = NULL;
+		FOR_EACH_PTR(list, arg) {
+			add_expression(&expr->args, copy_expression(arg));
+		} END_FOR_EACH_PTR(arg);
+		break;
+	}
+
+	/* Initializer list statement */
+	case EXPR_INITIALIZER: {
+		struct expression_list *list = expr->expr_list;
+		struct expression *entry;
+		expr = dup_expression(expr);
+		expr->expr_list = NULL;
+		FOR_EACH_PTR(list, entry) {
+			add_expression(&expr->expr_list, copy_expression(entry));
+		} END_FOR_EACH_PTR(entry);
+		break;
+	}
+
+	/* Label in inline function - hmm. */
+	case EXPR_LABEL: {
+		struct symbol *label_symbol = copy_symbol(expr->pos, expr->label_symbol);
+		expr = dup_expression(expr);
+		expr->label_symbol = label_symbol;
+		break;
+	}
+
+	case EXPR_INDEX: {
+		struct expression *sub_expr = copy_expression(expr->idx_expression);
+		expr = dup_expression(expr);
+		expr->idx_expression = sub_expr;
+		break;
+	}
+		
+	case EXPR_IDENTIFIER: {
+		struct expression *sub_expr = copy_expression(expr->ident_expression);
+		expr = dup_expression(expr);
+		expr->ident_expression = sub_expr;
+		break;
+	}
+
+	/* Position in initializer.. */
+	case EXPR_POS: {
+		struct expression *val = copy_expression(expr->init_expr);
+		expr = dup_expression(expr);
+		expr->init_expr = val;
+		break;
+	}
+	case EXPR_OFFSETOF: {
+		struct expression *val = copy_expression(expr->down);
+		if (expr->op == '.') {
+			if (expr->down != val) {
+				expr = dup_expression(expr);
+				expr->down = val;
+			}
+		} else {
+			struct expression *idx = copy_expression(expr->index);
+			if (expr->down != val || expr->index != idx) {
+				expr = dup_expression(expr);
+				expr->down = val;
+				expr->index = idx;
+			}
+		}
+		break;
+	}
+	default:
+		warning(expr->pos, "trying to copy expression type %d", expr->type);
+	}
+	return expr;
+}
+
+static struct expression_list *copy_asm_constraints(struct expression_list *in)
+{
+	struct expression_list *out = NULL;
+	struct expression *expr;
+	int state = 0;
+
+	FOR_EACH_PTR(in, expr) {
+		switch (state) {
+		case 0: /* identifier */
+		case 1: /* constraint */
+			state++;
+			add_expression(&out, expr);
+			continue;
+		case 2: /* expression */
+			state = 0;
+			add_expression(&out, copy_expression(expr));
+			continue;
+		}
+	} END_FOR_EACH_PTR(expr);
+	return out;
+}
+
+static void set_replace(struct symbol *old, struct symbol *new)
+{
+	new->replace = old;
+	old->replace = new;
+}
+
+static void unset_replace(struct symbol *sym)
+{
+	struct symbol *r = sym->replace;
+	if (!r) {
+		warning(sym->pos, "symbol '%s' not replaced?", show_ident(sym->ident));
+		return;
+	}
+	r->replace = NULL;
+	sym->replace = NULL;
+}
+
+static void unset_replace_list(struct symbol_list *list)
+{
+	struct symbol *sym;
+	FOR_EACH_PTR(list, sym) {
+		unset_replace(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+static struct statement *copy_one_statement(struct statement *stmt)
+{
+	if (!stmt)
+		return NULL;
+	switch(stmt->type) {
+	case STMT_NONE:
+		break;
+	case STMT_DECLARATION: {
+		struct symbol *sym;
+		struct statement *newstmt = dup_statement(stmt);
+		newstmt->declaration = NULL;
+		FOR_EACH_PTR(stmt->declaration, sym) {
+			struct symbol *newsym = copy_symbol(stmt->pos, sym);
+			if (newsym != sym)
+				newsym->initializer = copy_expression(sym->initializer);
+			add_symbol(&newstmt->declaration, newsym);
+		} END_FOR_EACH_PTR(sym);
+		stmt = newstmt;
+		break;
+	}
+	case STMT_CONTEXT:
+	case STMT_EXPRESSION: {
+		struct expression *expr = copy_expression(stmt->expression);
+		if (expr == stmt->expression)
+			break;
+		stmt = dup_statement(stmt);
+		stmt->expression = expr;
+		break;
+	}
+	case STMT_RANGE: {
+		struct expression *expr = copy_expression(stmt->range_expression);
+		if (expr == stmt->expression)
+			break;
+		stmt = dup_statement(stmt);
+		stmt->range_expression = expr;
+		break;
+	}
+	case STMT_COMPOUND: {
+		struct statement *new = alloc_statement(stmt->pos, STMT_COMPOUND);
+		copy_statement(stmt, new);
+		stmt = new;
+		break;
+	}
+	case STMT_IF: {
+		struct expression *cond = stmt->if_conditional;
+		struct statement *true = stmt->if_true;
+		struct statement *false = stmt->if_false;
+
+		cond = copy_expression(cond);
+		true = copy_one_statement(true);
+		false = copy_one_statement(false);
+		if (stmt->if_conditional == cond &&
+		    stmt->if_true == true &&
+		    stmt->if_false == false)
+			break;
+		stmt = dup_statement(stmt);
+		stmt->if_conditional = cond;
+		stmt->if_true = true;
+		stmt->if_false = false;
+		break;
+	}
+	case STMT_RETURN: {
+		struct expression *retval = copy_expression(stmt->ret_value);
+		struct symbol *sym = copy_symbol(stmt->pos, stmt->ret_target);
+
+		stmt = dup_statement(stmt);
+		stmt->ret_value = retval;
+		stmt->ret_target = sym;
+		break;
+	}
+	case STMT_CASE: {
+		stmt = dup_statement(stmt);
+		stmt->case_label = copy_symbol(stmt->pos, stmt->case_label);
+		stmt->case_label->stmt = stmt;
+		stmt->case_expression = copy_expression(stmt->case_expression);
+		stmt->case_to = copy_expression(stmt->case_to);
+		stmt->case_statement = copy_one_statement(stmt->case_statement);
+		break;
+	}
+	case STMT_SWITCH: {
+		struct symbol *switch_break = copy_symbol(stmt->pos, stmt->switch_break);
+		struct symbol *switch_case = copy_symbol(stmt->pos, stmt->switch_case);
+		struct expression *expr = copy_expression(stmt->switch_expression);
+		struct statement *switch_stmt = copy_one_statement(stmt->switch_statement);
+
+		stmt = dup_statement(stmt);
+		switch_case->symbol_list = copy_symbol_list(switch_case->symbol_list);
+		stmt->switch_break = switch_break;
+		stmt->switch_case = switch_case;
+		stmt->switch_expression = expr;
+		stmt->switch_statement = switch_stmt;
+		break;		
+	}
+	case STMT_ITERATOR: {
+		stmt = dup_statement(stmt);
+		stmt->iterator_break = copy_symbol(stmt->pos, stmt->iterator_break);
+		stmt->iterator_continue = copy_symbol(stmt->pos, stmt->iterator_continue);
+		stmt->iterator_syms = copy_symbol_list(stmt->iterator_syms);
+
+		stmt->iterator_pre_statement = copy_one_statement(stmt->iterator_pre_statement);
+		stmt->iterator_pre_condition = copy_expression(stmt->iterator_pre_condition);
+
+		stmt->iterator_statement = copy_one_statement(stmt->iterator_statement);
+
+		stmt->iterator_post_statement = copy_one_statement(stmt->iterator_post_statement);
+		stmt->iterator_post_condition = copy_expression(stmt->iterator_post_condition);
+		break;
+	}
+	case STMT_LABEL: {
+		stmt = dup_statement(stmt);
+		stmt->label_identifier = copy_symbol(stmt->pos, stmt->label_identifier);
+		stmt->label_statement = copy_one_statement(stmt->label_statement);
+		break;
+	}
+	case STMT_GOTO: {
+		stmt = dup_statement(stmt);
+		stmt->goto_label = copy_symbol(stmt->pos, stmt->goto_label);
+		stmt->goto_expression = copy_expression(stmt->goto_expression);
+		stmt->target_list = copy_symbol_list(stmt->target_list);
+		break;
+	}
+	case STMT_ASM: {
+		stmt = dup_statement(stmt);
+		stmt->asm_inputs = copy_asm_constraints(stmt->asm_inputs);
+		stmt->asm_outputs = copy_asm_constraints(stmt->asm_outputs);
+		/* no need to dup "clobbers", since they are all constant strings */
+		break;
+	}
+	default:
+		warning(stmt->pos, "trying to copy statement type %d", stmt->type);
+		break;
+	}
+	return stmt;
+}
+
+/*
+ * Copy a statement tree from 'src' to 'dst', where both
+ * source and destination are of type STMT_COMPOUND.
+ *
+ * We do this for the tree-level inliner.
+ *
+ * This doesn't do the symbol replacement right: it's not
+ * re-entrant.
+ */
+void copy_statement(struct statement *src, struct statement *dst)
+{
+	struct statement *stmt;
+
+	FOR_EACH_PTR(src->stmts, stmt) {
+		add_statement(&dst->stmts, copy_one_statement(stmt));
+	} END_FOR_EACH_PTR(stmt);
+	dst->args = copy_one_statement(src->args);
+	dst->ret = copy_symbol(src->pos, src->ret);
+	dst->inline_fn = src->inline_fn;
+}
+
+static struct symbol *create_copy_symbol(struct symbol *orig)
+{
+	struct symbol *sym = orig;
+	if (orig) {
+		sym = alloc_symbol(orig->pos, orig->type);
+		*sym = *orig;
+		sym->bb_target = NULL;
+		sym->pseudo = NULL;
+		set_replace(orig, sym);
+		orig = sym;
+	}
+	return orig;
+}
+
+static struct symbol_list *create_symbol_list(struct symbol_list *src)
+{
+	struct symbol_list *dst = NULL;
+	struct symbol *sym;
+
+	FOR_EACH_PTR(src, sym) {
+		struct symbol *newsym = create_copy_symbol(sym);
+		add_symbol(&dst, newsym);
+	} END_FOR_EACH_PTR(sym);
+	return dst;
+}
+
+int inline_function(struct expression *expr, struct symbol *sym)
+{
+	struct symbol_list * fn_symbol_list;
+	struct symbol *fn = sym->ctype.base_type;
+	struct expression_list *arg_list = expr->args;
+	struct statement *stmt = alloc_statement(expr->pos, STMT_COMPOUND);
+	struct symbol_list *name_list, *arg_decl;
+	struct symbol *name;
+	struct expression *arg;
+
+	if (!fn->inline_stmt) {
+		sparse_error(fn->pos, "marked inline, but without a definition");
+		return 0;
+	}
+	if (fn->expanding)
+		return 0;
+
+	fn->expanding = 1;
+
+	name_list = fn->arguments;
+
+	expr->type = EXPR_STATEMENT;
+	expr->statement = stmt;
+	expr->ctype = fn->ctype.base_type;
+
+	fn_symbol_list = create_symbol_list(sym->inline_symbol_list);
+
+	arg_decl = NULL;
+	PREPARE_PTR_LIST(name_list, name);
+	FOR_EACH_PTR(arg_list, arg) {
+		struct symbol *a = alloc_symbol(arg->pos, SYM_NODE);
+
+		a->ctype.base_type = arg->ctype;
+		if (name) {
+			*a = *name;
+			set_replace(name, a);
+			add_symbol(&fn_symbol_list, a);
+		}
+		a->initializer = arg;
+		add_symbol(&arg_decl, a);
+
+		NEXT_PTR_LIST(name);
+	} END_FOR_EACH_PTR(arg);
+	FINISH_PTR_LIST(name);
+
+	copy_statement(fn->inline_stmt, stmt);
+
+	if (arg_decl) {
+		struct statement *decl = alloc_statement(expr->pos, STMT_DECLARATION);
+		decl->declaration = arg_decl;
+		stmt->args = decl;
+	}
+	stmt->inline_fn = sym;
+
+	unset_replace_list(fn_symbol_list);
+
+	evaluate_statement(stmt);
+
+	fn->expanding = 0;
+	return 1;
+}
+
+void uninline(struct symbol *sym)
+{
+	struct symbol *fn = sym->ctype.base_type;
+	struct symbol_list *arg_list = fn->arguments;
+	struct symbol *p;
+
+	sym->symbol_list = create_symbol_list(sym->inline_symbol_list);
+	FOR_EACH_PTR(arg_list, p) {
+		p->replace = p;
+	} END_FOR_EACH_PTR(p);
+	fn->stmt = alloc_statement(fn->pos, STMT_COMPOUND);
+	copy_statement(fn->inline_stmt, fn->stmt);
+	unset_replace_list(sym->symbol_list);
+	unset_replace_list(arg_list);
+}
diff --git a/usr/src/tools/smatch/src/lib.c b/usr/src/tools/smatch/src/lib.c
new file mode 100644
index 0000000000..9189d7885f
--- /dev/null
+++ b/usr/src/tools/smatch/src/lib.c
@@ -0,0 +1,1503 @@
+/*
+ * 'sparse' library helper routines.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <ctype.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include <sys/types.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+#include "scope.h"
+#include "linearize.h"
+#include "target.h"
+#include "version.h"
+
+static const char *progname;
+
+int sparse_errors = 0;
+int sparse_warnings = 0;
+
+int verbose, optimize, optimize_size, preprocessing;
+int die_if_error = 0;
+int parse_error;
+int has_error = 0;
+
+#ifndef __GNUC__
+# define __GNUC__ 2
+# define __GNUC_MINOR__ 95
+# define __GNUC_PATCHLEVEL__ 0
+#endif
+
+int gcc_major = __GNUC__;
+int gcc_minor = __GNUC_MINOR__;
+int gcc_patchlevel = __GNUC_PATCHLEVEL__;
+
+static const char *gcc_base_dir = GCC_BASE;
+static const char *multiarch_dir = MULTIARCH_TRIPLET;
+
+struct token *skip_to(struct token *token, int op)
+{
+	while (!match_op(token, op) && !eof_token(token))
+		token = token->next;
+	return token;
+}
+
+struct token *expect(struct token *token, int op, const char *where)
+{
+	if (!match_op(token, op)) {
+		static struct token bad_token;
+		if (token != &bad_token) {
+			bad_token.next = token;
+			sparse_error(token->pos, "Expected %s %s", show_special(op), where);
+			sparse_error(token->pos, "got %s", show_token(token));
+		}
+		if (op == ';')
+			return skip_to(token, op);
+		return &bad_token;
+	}
+	return token->next;
+}
+
+unsigned int hexval(unsigned int c)
+{
+	int retval = 256;
+	switch (c) {
+	case '0'...'9':
+		retval = c - '0';
+		break;
+	case 'a'...'f':
+		retval = c - 'a' + 10;
+		break;
+	case 'A'...'F':
+		retval = c - 'A' + 10;
+		break;
+	}
+	return retval;
+}
+
+static void do_warn(const char *type, struct position pos, const char * fmt, va_list args)
+{
+	static char buffer[512];
+	const char *name;
+
+	vsprintf(buffer, fmt, args);	
+	name = stream_name(pos.stream);
+		
+	fprintf(stderr, "%s: %s:%d:%d: %s%s\n",
+		progname, name, pos.line, pos.pos, type, buffer);
+}
+
+static int max_warnings = 100;
+static int show_info = 1;
+
+void info(struct position pos, const char * fmt, ...)
+{
+	va_list args;
+
+	if (!show_info)
+		return;
+	va_start(args, fmt);
+	do_warn("", pos, fmt, args);
+	va_end(args);
+}
+
+static void do_error(struct position pos, const char * fmt, va_list args)
+{
+	static int errors = 0;
+
+	parse_error = 1;
+        die_if_error = 1;
+	show_info = 1;
+	/* Shut up warnings after an error */
+	has_error |= ERROR_CURR_PHASE;
+	if (errors > 100) {
+		static int once = 0;
+		show_info = 0;
+		if (once)
+			return;
+		fmt = "too many errors";
+		once = 1;
+	}
+
+	do_warn("error: ", pos, fmt, args);
+	errors++;
+}	
+
+void warning(struct position pos, const char * fmt, ...)
+{
+	va_list args;
+
+	if (Wsparse_error) {
+		va_start(args, fmt);
+		do_error(pos, fmt, args);
+		va_end(args);
+		return;
+	}
+
+	if (!max_warnings || has_error) {
+		show_info = 0;
+		return;
+	}
+
+	if (!--max_warnings) {
+		show_info = 0;
+		fmt = "too many warnings";
+	}
+
+	va_start(args, fmt);
+	do_warn("warning: ", pos, fmt, args);
+	va_end(args);
+}
+
+void sparse_error(struct position pos, const char * fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	do_error(pos, fmt, args);
+	va_end(args);
+}
+
+void expression_error(struct expression *expr, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	do_error(expr->pos, fmt, args);
+	va_end(args);
+	expr->ctype = &bad_ctype;
+}
+
+NORETURN_ATTR
+void error_die(struct position pos, const char * fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	do_warn("error: ", pos, fmt, args);
+	va_end(args);
+	exit(1);
+}
+
+NORETURN_ATTR
+void die(const char *fmt, ...)
+{
+	va_list args;
+	static char buffer[512];
+
+	va_start(args, fmt);
+	vsnprintf(buffer, sizeof(buffer), fmt, args);
+	va_end(args);
+
+	fprintf(stderr, "%s: %s\n", progname, buffer);
+	exit(1);
+}
+
+static struct token *pre_buffer_begin = NULL;
+static struct token *pre_buffer_end = NULL;
+
+int Waddress = 0;
+int Waddress_space = 1;
+int Wbitwise = 1;
+int Wcast_to_as = 0;
+int Wcast_truncate = 1;
+int Wconstant_suffix = 0;
+int Wconstexpr_not_const = 0;
+int Wcontext = 1;
+int Wdecl = 1;
+int Wdeclarationafterstatement = -1;
+int Wdefault_bitfield_sign = 0;
+int Wdesignated_init = 1;
+int Wdo_while = 0;
+int Wimplicit_int = 1;
+int Winit_cstring = 0;
+int Wenum_mismatch = 1;
+int Wexternal_function_has_definition = 1;
+int Wsparse_error = 0;
+int Wmemcpy_max_count = 1;
+int Wnon_pointer_null = 1;
+int Wold_initializer = 1;
+int Wold_style_definition = 1;
+int Wone_bit_signed_bitfield = 1;
+int Woverride_init = 1;
+int Woverride_init_all = 0;
+int Woverride_init_whole_range = 0;
+int Wparen_string = 0;
+int Wpointer_arith = 0;
+int Wptr_subtraction_blows = 0;
+int Wreturn_void = 0;
+int Wshadow = 0;
+int Wsizeof_bool = 0;
+int Wstrict_prototypes = 1;
+int Wtautological_compare = 0;
+int Wtransparent_union = 0;
+int Wtypesign = 0;
+int Wundef = 0;
+int Wuninitialized = 1;
+int Wunknown_attribute = 0;
+int Wvla = 1;
+
+int dump_macro_defs = 0;
+
+int dbg_entry = 0;
+int dbg_dead = 0;
+
+int fmem_report = 0;
+int fdump_linearize;
+unsigned long long fmemcpy_max_count = 100000;
+
+int preprocess_only;
+
+static enum { STANDARD_C89,
+              STANDARD_C94,
+              STANDARD_C99,
+              STANDARD_C11,
+              STANDARD_GNU11,
+              STANDARD_GNU89,
+              STANDARD_GNU99, } standard = STANDARD_GNU89;
+
+#define ARCH_LP32  0
+#define ARCH_LP64  1
+#define ARCH_LLP64 2
+
+#ifdef __x86_64__
+#define ARCH_M64_DEFAULT ARCH_LP64
+#else
+#define ARCH_M64_DEFAULT ARCH_LP32
+#endif
+
+int arch_m64 = ARCH_M64_DEFAULT;
+int arch_msize_long = 0;
+
+#ifdef __BIG_ENDIAN__
+#define ARCH_BIG_ENDIAN 1
+#else
+#define ARCH_BIG_ENDIAN 0
+#endif
+int arch_big_endian = ARCH_BIG_ENDIAN;
+
+
+#define CMDLINE_INCLUDE 20
+static int cmdline_include_nr = 0;
+static char *cmdline_include[CMDLINE_INCLUDE];
+
+
+void add_pre_buffer(const char *fmt, ...)
+{
+	va_list args;
+	unsigned int size;
+	struct token *begin, *end;
+	char buffer[4096];
+
+	va_start(args, fmt);
+	size = vsnprintf(buffer, sizeof(buffer), fmt, args);
+	va_end(args);
+	begin = tokenize_buffer(buffer, size, &end);
+	if (!pre_buffer_begin)
+		pre_buffer_begin = begin;
+	if (pre_buffer_end)
+		pre_buffer_end->next = begin;
+	pre_buffer_end = end;
+}
+
+static char **handle_switch_D(char *arg, char **next)
+{
+	const char *name = arg + 1;
+	const char *value = "1";
+
+	if (!*name) {
+		arg = *++next;
+		if (!arg)
+			die("argument to `-D' is missing");
+		name = arg;
+	}
+
+	for (;;arg++) {
+		char c;
+		c = *arg;
+		if (!c)
+			break;
+		if (c == '=') {
+			*arg = '\0';
+			value = arg + 1;
+			break;
+		}
+	}
+	add_pre_buffer("#define %s %s\n", name, value);
+	return next;
+}
+
+static char **handle_switch_E(char *arg, char **next)
+{
+	if (arg[1] == '\0')
+		preprocess_only = 1;
+	return next;
+}
+
+static char **handle_switch_I(char *arg, char **next)
+{
+	char *path = arg+1;
+
+	switch (arg[1]) {
+	case '-':
+		add_pre_buffer("#split_include\n");
+		break;
+
+	case '\0':	/* Plain "-I" */
+		path = *++next;
+		if (!path)
+			die("missing argument for -I option");
+		/* Fall through */
+	default:
+		add_pre_buffer("#add_include \"%s/\"\n", path);
+	}
+	return next;
+}
+
+static void add_cmdline_include(char *filename)
+{
+	if (cmdline_include_nr >= CMDLINE_INCLUDE)
+		die("too many include files for %s\n", filename);
+	cmdline_include[cmdline_include_nr++] = filename;
+}
+
+static char **handle_switch_i(char *arg, char **next)
+{
+	if (*next && !strcmp(arg, "include"))
+		add_cmdline_include(*++next);
+	else if (*next && !strcmp(arg, "imacros"))
+		add_cmdline_include(*++next);
+	else if (*next && !strcmp(arg, "isystem")) {
+		char *path = *++next;
+		if (!path)
+			die("missing argument for -isystem option");
+		add_pre_buffer("#add_isystem \"%s/\"\n", path);
+	} else if (*next && !strcmp(arg, "idirafter")) {
+		char *path = *++next;
+		if (!path)
+			die("missing argument for -idirafter option");
+		add_pre_buffer("#add_dirafter \"%s/\"\n", path);
+	}
+	return next;
+}
+
+static char **handle_switch_M(char *arg, char **next)
+{
+	if (!strcmp(arg, "MF") || !strcmp(arg,"MQ") || !strcmp(arg,"MT")) {
+		if (!*next)
+			die("missing argument for -%s option", arg);
+		return next + 1;
+	}
+	return next;
+}
+
+static char **handle_multiarch_dir(char *arg, char **next)
+{
+	multiarch_dir = *++next;
+	if (!multiarch_dir)
+		die("missing argument for -multiarch-dir option");
+	return next;
+}
+
+static char **handle_switch_m(char *arg, char **next)
+{
+	if (!strcmp(arg, "m64")) {
+		arch_m64 = ARCH_LP64;
+	} else if (!strcmp(arg, "m32")) {
+		arch_m64 = ARCH_LP32;
+	} else if (!strcmp(arg, "msize-llp64")) {
+		arch_m64 = ARCH_LLP64;
+	} else if (!strcmp(arg, "msize-long")) {
+		arch_msize_long = 1;
+	} else if (!strcmp(arg, "multiarch-dir")) {
+		return handle_multiarch_dir(arg, next);
+	} else if (!strcmp(arg, "mbig-endian")) {
+		arch_big_endian = 1;
+	} else if (!strcmp(arg, "mlittle-endian")) {
+		arch_big_endian = 0;
+	}
+	return next;
+}
+
+static void handle_arch_m64_finalize(void)
+{
+	switch (arch_m64) {
+	case ARCH_LP32:
+		/* default values */
+#if defined(__x86_64__) || defined (__i386)
+ 		add_pre_buffer("#weak_define __i386__ 1\n");
+ 		add_pre_buffer("#weak_define __i386 1\n");
+ 		add_pre_buffer("#weak_define i386 1\n");
+#endif
+		return;
+	case ARCH_LP64:
+		bits_in_long = 64;
+		max_int_alignment = 8;
+		size_t_ctype = &ulong_ctype;
+		ssize_t_ctype = &long_ctype;
+		add_pre_buffer("#weak_define __LP64__ 1\n");
+		add_pre_buffer("#weak_define __LP64 1\n");
+		add_pre_buffer("#weak_define _LP64 1\n");
+		goto case_64bit_common;
+	case ARCH_LLP64:
+		bits_in_long = 32;
+		max_int_alignment = 4;
+		size_t_ctype = &ullong_ctype;
+		ssize_t_ctype = &llong_ctype;
+		add_pre_buffer("#weak_define __LLP64__ 1\n");
+		goto case_64bit_common;
+	case_64bit_common:
+		bits_in_pointer = 64;
+		pointer_alignment = 8;
+#if defined(__x86_64__) || defined (__i386)
+		add_pre_buffer("#weak_define __x86_64__ 1\n");
+		add_pre_buffer("#weak_define __x86_64 1\n");
+#endif
+		break;
+	}
+}
+
+static void handle_arch_msize_long_finalize(void)
+{
+	if (arch_msize_long) {
+		size_t_ctype = &ulong_ctype;
+		ssize_t_ctype = &long_ctype;
+	}
+}
+
+static void handle_arch_finalize(void)
+{
+	handle_arch_m64_finalize();
+	handle_arch_msize_long_finalize();
+}
+
+
+static int handle_simple_switch(const char *arg, const char *name, int *flag)
+{
+	int val = 1;
+
+	// Prefixe "no-" mean to turn flag off.
+	if (strncmp(arg, "no-", 3) == 0) {
+		arg += 3;
+		val = 0;
+	}
+
+	if (strcmp(arg, name) == 0) {
+		*flag = val;
+		return 1;
+	}
+
+	// not handled
+	return 0;
+}
+
+static char **handle_switch_o(char *arg, char **next)
+{
+	if (!strcmp (arg, "o")) {       // "-o foo"
+		if (!*++next)
+			die("argument to '-o' is missing");
+	}
+	// else "-ofoo"
+
+	return next;
+}
+
+static const struct warning {
+	const char *name;
+	int *flag;
+} warnings[] = {
+	{ "address", &Waddress },
+	{ "address-space", &Waddress_space },
+	{ "bitwise", &Wbitwise },
+	{ "cast-to-as", &Wcast_to_as },
+	{ "cast-truncate", &Wcast_truncate },
+	{ "constant-suffix", &Wconstant_suffix },
+	{ "constexpr-not-const", &Wconstexpr_not_const},
+	{ "context", &Wcontext },
+	{ "decl", &Wdecl },
+	{ "declaration-after-statement", &Wdeclarationafterstatement },
+	{ "default-bitfield-sign", &Wdefault_bitfield_sign },
+	{ "designated-init", &Wdesignated_init },
+	{ "do-while", &Wdo_while },
+	{ "enum-mismatch", &Wenum_mismatch },
+	{ "external-function-has-definition", &Wexternal_function_has_definition },
+	{ "implicit-int", &Wimplicit_int },
+	{ "init-cstring", &Winit_cstring },
+	{ "memcpy-max-count", &Wmemcpy_max_count },
+	{ "non-pointer-null", &Wnon_pointer_null },
+	{ "old-initializer", &Wold_initializer },
+	{ "old-style-definition", &Wold_style_definition },
+	{ "one-bit-signed-bitfield", &Wone_bit_signed_bitfield },
+	{ "override-init", &Woverride_init },
+	{ "override-init-all", &Woverride_init_all },
+	{ "paren-string", &Wparen_string },
+	{ "ptr-subtraction-blows", &Wptr_subtraction_blows },
+	{ "return-void", &Wreturn_void },
+	{ "shadow", &Wshadow },
+	{ "sizeof-bool", &Wsizeof_bool },
+	{ "strict-prototypes", &Wstrict_prototypes },
+	{ "pointer-arith", &Wpointer_arith },
+	{ "sparse-error", &Wsparse_error },
+	{ "tautological-compare", &Wtautological_compare },
+	{ "transparent-union", &Wtransparent_union },
+	{ "typesign", &Wtypesign },
+	{ "undef", &Wundef },
+	{ "uninitialized", &Wuninitialized },
+	{ "unknown-attribute", &Wunknown_attribute },
+	{ "vla", &Wvla },
+};
+
+enum {
+	WARNING_OFF,
+	WARNING_ON,
+	WARNING_FORCE_OFF
+};
+
+
+static char **handle_onoff_switch(char *arg, char **next, const struct warning warnings[], int n)
+{
+	int flag = WARNING_ON;
+	char *p = arg + 1;
+	unsigned i;
+
+	if (!strcmp(p, "sparse-all")) {
+		for (i = 0; i < n; i++) {
+			if (*warnings[i].flag != WARNING_FORCE_OFF && warnings[i].flag != &Wsparse_error)
+				*warnings[i].flag = WARNING_ON;
+		}
+	}
+
+	// Prefixes "no" and "no-" mean to turn warning off.
+	if (p[0] == 'n' && p[1] == 'o') {
+		p += 2;
+		if (p[0] == '-')
+			p++;
+		flag = WARNING_FORCE_OFF;
+	}
+
+	for (i = 0; i < n; i++) {
+		if (!strcmp(p,warnings[i].name)) {
+			*warnings[i].flag = flag;
+			return next;
+		}
+	}
+
+	// Unknown.
+	return NULL;
+}
+
+static char **handle_switch_W(char *arg, char **next)
+{
+	char ** ret = handle_onoff_switch(arg, next, warnings, ARRAY_SIZE(warnings));
+	if (ret)
+		return ret;
+
+	// Unknown.
+	return next;
+}
+
+static struct warning debugs[] = {
+	{ "entry", &dbg_entry},
+	{ "dead", &dbg_dead},
+};
+
+
+static char **handle_switch_v(char *arg, char **next)
+{
+	char ** ret = handle_onoff_switch(arg, next, debugs, ARRAY_SIZE(debugs));
+	if (ret)
+		return ret;
+
+	// Unknown.
+	do {
+		verbose++;
+	} while (*++arg == 'v');
+	return next;
+}
+
+static struct warning dumps[] = {
+	{ "D", &dump_macro_defs},
+};
+
+static char **handle_switch_d(char *arg, char **next)
+{
+	char ** ret = handle_onoff_switch(arg, next, dumps, ARRAY_SIZE(dumps));
+	if (ret)
+		return ret;
+
+	return next;
+}
+
+
+static void handle_onoff_switch_finalize(const struct warning warnings[], int n)
+{
+	unsigned i;
+
+	for (i = 0; i < n; i++) {
+		if (*warnings[i].flag == WARNING_FORCE_OFF)
+			*warnings[i].flag = WARNING_OFF;
+	}
+}
+
+static void handle_switch_W_finalize(void)
+{
+	handle_onoff_switch_finalize(warnings, ARRAY_SIZE(warnings));
+
+	/* default Wdeclarationafterstatement based on the C dialect */
+	if (-1 == Wdeclarationafterstatement)
+	{
+		switch (standard)
+		{
+			case STANDARD_C89:
+			case STANDARD_C94:
+				Wdeclarationafterstatement = 1;
+				break;
+
+			case STANDARD_C99:
+			case STANDARD_GNU89:
+			case STANDARD_GNU99:
+			case STANDARD_C11:
+			case STANDARD_GNU11:
+				Wdeclarationafterstatement = 0;
+				break;
+
+			default:
+				assert (0);
+		}
+
+	}
+}
+
+static void handle_switch_v_finalize(void)
+{
+	handle_onoff_switch_finalize(debugs, ARRAY_SIZE(debugs));
+}
+
+static char **handle_switch_U(char *arg, char **next)
+{
+	const char *name = arg + 1;
+	if (*name == '\0')
+		name = *++next;
+	add_pre_buffer ("#undef %s\n", name);
+	return next;
+}
+
+static char **handle_switch_O(char *arg, char **next)
+{
+	int level = 1;
+	if (arg[1] >= '0' && arg[1] <= '9')
+		level = arg[1] - '0';
+	optimize = level;
+	optimize_size = arg[1] == 's';
+	return next;
+}
+
+static char **handle_switch_fmemcpy_max_count(char *arg, char **next)
+{
+	unsigned long long val;
+	char *end;
+
+	val = strtoull(arg, &end, 0);
+	if (*end != '\0' || end == arg)
+		die("error: missing argument to \"-fmemcpy-max-count=\"");
+
+	if (val == 0)
+		val = ~0ULL;
+	fmemcpy_max_count = val;
+	return next;
+}
+
+static char **handle_switch_ftabstop(char *arg, char **next)
+{
+	char *end;
+	unsigned long val;
+
+	if (*arg == '\0')
+		die("error: missing argument to \"-ftabstop=\"");
+
+	/* we silently ignore silly values */
+	val = strtoul(arg, &end, 10);
+	if (*end == '\0' && 1 <= val && val <= 100)
+		tabstop = val;
+
+	return next;
+}
+
+static int funsigned_char;
+static void handle_funsigned_char(void)
+{
+	if (funsigned_char) {
+		char_ctype.ctype.modifiers &= ~MOD_SIGNED;
+		char_ctype.ctype.modifiers |= MOD_UNSIGNED;
+	}
+}
+
+	static char **handle_switch_fdump(char *arg, char **next)
+{
+	if (!strncmp(arg, "linearize", 9)) {
+		arg += 9;
+		if (*arg == '\0')
+			fdump_linearize = 1;
+		else if (!strcmp(arg, "=only"))
+			fdump_linearize = 2;
+		else
+			goto err;
+	}
+
+	/* ignore others flags */
+	return next;
+
+err:
+	die("error: unknown flag \"-fdump-%s\"", arg);
+}
+
+static char **handle_switch_f(char *arg, char **next)
+{
+	arg++;
+
+	if (!strncmp(arg, "tabstop=", 8))
+		return handle_switch_ftabstop(arg+8, next);
+	if (!strncmp(arg, "dump-", 5))
+		return handle_switch_fdump(arg+5, next);
+	if (!strncmp(arg, "memcpy-max-count=", 17))
+		return handle_switch_fmemcpy_max_count(arg+17, next);
+
+	if (!strcmp(arg, "unsigned-char")) {
+		funsigned_char = 1;
+		return next;
+	}
+
+	/* handle switches w/ arguments above, boolean and only boolean below */
+	if (handle_simple_switch(arg, "mem-report", &fmem_report))
+		return next;
+
+	return next;
+}
+
+static char **handle_switch_G(char *arg, char **next)
+{
+	if (!strcmp (arg, "G") && *next)
+		return next + 1; // "-G 0"
+	else
+		return next;     // "-G0" or (bogus) terminal "-G"
+}
+
+static char **handle_switch_a(char *arg, char **next)
+{
+	if (!strcmp (arg, "ansi"))
+		standard = STANDARD_C89;
+
+	return next;
+}
+
+static char **handle_switch_s(char *arg, char **next)
+{
+	if (!strncmp (arg, "std=", 4))
+	{
+		arg += 4;
+
+		if (!strcmp (arg, "c89") ||
+		    !strcmp (arg, "iso9899:1990"))
+			standard = STANDARD_C89;
+
+		else if (!strcmp (arg, "iso9899:199409"))
+			standard = STANDARD_C94;
+
+		else if (!strcmp (arg, "c99") ||
+			 !strcmp (arg, "c9x") ||
+			 !strcmp (arg, "iso9899:1999") ||
+			 !strcmp (arg, "iso9899:199x"))
+			standard = STANDARD_C99;
+
+		else if (!strcmp (arg, "gnu89"))
+			standard = STANDARD_GNU89;
+
+		else if (!strcmp (arg, "gnu99") || !strcmp (arg, "gnu9x"))
+			standard = STANDARD_GNU99;
+
+		else if (!strcmp(arg, "c11") ||
+			 !strcmp(arg, "c1x") ||
+			 !strcmp(arg, "iso9899:2011"))
+			standard = STANDARD_C11;
+
+		else if (!strcmp(arg, "gnu11"))
+			standard = STANDARD_GNU11;
+
+		else
+			die ("Unsupported C dialect");
+	}
+
+	return next;
+}
+
+static char **handle_nostdinc(char *arg, char **next)
+{
+	add_pre_buffer("#nostdinc\n");
+	return next;
+}
+
+static char **handle_switch_n(char *arg, char **next)
+{
+	if (!strcmp (arg, "nostdinc"))
+		return handle_nostdinc(arg, next);
+
+	return next;
+}
+
+static char **handle_base_dir(char *arg, char **next)
+{
+	gcc_base_dir = *++next;
+	if (!gcc_base_dir)
+		die("missing argument for -gcc-base-dir option");
+	return next;
+}
+
+static char **handle_no_lineno(char *arg, char **next)
+{
+	no_lineno = 1;
+	return next;
+}
+
+static char **handle_switch_g(char *arg, char **next)
+{
+	if (!strcmp (arg, "gcc-base-dir"))
+		return handle_base_dir(arg, next);
+
+	return next;
+}
+
+static char **handle_version(char *arg, char **next)
+{
+	printf("%s\n", SPARSE_VERSION);
+	exit(0);
+}
+
+static char **handle_param(char *arg, char **next)
+{
+	char *value = NULL;
+
+	/* Ignore smatch's --param-mapper */
+	if (strcmp(arg, "-mapper") == 0)
+		return next;
+
+
+	/* For now just skip any '--param=*' or '--param *' */
+	if (*arg == '\0') {
+		value = *++next;
+	} else if (isspace((unsigned char)*arg) || *arg == '=') {
+		value = ++arg;
+	}
+
+	if (!value)
+		die("missing argument for --param option");
+
+	return next;
+}
+
+struct switches {
+	const char *name;
+	char **(*fn)(char *, char **);
+	unsigned int prefix:1;
+};
+
+static char **handle_long_options(char *arg, char **next)
+{
+	static struct switches cmd[] = {
+		{ "param", handle_param, 1 },
+		{ "version", handle_version },
+		{ "nostdinc", handle_nostdinc },
+		{ "gcc-base-dir", handle_base_dir},
+		{ "no-lineno", handle_no_lineno},
+		{ NULL, NULL }
+	};
+	struct switches *s = cmd;
+
+	while (s->name) {
+		int optlen = strlen(s->name);
+		if (!strncmp(s->name, arg, optlen + !s->prefix))
+			return s->fn(arg + optlen, next);
+		s++;
+	}
+	return next;
+}
+
+static char **handle_switch(char *arg, char **next)
+{
+	switch (*arg) {
+	case 'a': return handle_switch_a(arg, next);
+	case 'D': return handle_switch_D(arg, next);
+	case 'd': return handle_switch_d(arg, next);
+	case 'E': return handle_switch_E(arg, next);
+	case 'f': return handle_switch_f(arg, next);
+	case 'g': return handle_switch_g(arg, next);
+	case 'G': return handle_switch_G(arg, next);
+	case 'I': return handle_switch_I(arg, next);
+	case 'i': return handle_switch_i(arg, next);
+	case 'M': return handle_switch_M(arg, next);
+	case 'm': return handle_switch_m(arg, next);
+	case 'n': return handle_switch_n(arg, next);
+	case 'o': return handle_switch_o(arg, next);
+	case 'O': return handle_switch_O(arg, next);
+	case 's': return handle_switch_s(arg, next);
+	case 'U': return handle_switch_U(arg, next);
+	case 'v': return handle_switch_v(arg, next);
+	case 'W': return handle_switch_W(arg, next);
+	case '-': return handle_long_options(arg + 1, next);
+	default:
+		break;
+	}
+
+	/*
+	 * Ignore unknown command line options:
+	 * they're probably gcc switches
+	 */
+	return next;
+}
+
+static void predefined_sizeof(const char *name, unsigned bits)
+{
+	add_pre_buffer("#weak_define __SIZEOF_%s__ %d\n", name, bits/8);
+}
+
+static void predefined_max(const char *name, const char *suffix, unsigned bits)
+{
+	unsigned long long max = (1ULL << (bits - 1 )) - 1;
+
+	add_pre_buffer("#weak_define __%s_MAX__ %#llx%s\n", name, max, suffix);
+}
+
+static void predefined_type_size(const char *name, const char *suffix, unsigned bits)
+{
+	predefined_max(name, suffix, bits);
+	predefined_sizeof(name, bits);
+}
+
+static void predefined_macros(void)
+{
+	add_pre_buffer("#define __CHECKER__ 1\n");
+
+	predefined_sizeof("SHORT", bits_in_short);
+	predefined_max("SHRT", "", bits_in_short);
+	predefined_max("SCHAR", "", bits_in_char);
+	predefined_max("WCHAR", "", bits_in_wchar);
+	add_pre_buffer("#weak_define __CHAR_BIT__ %d\n", bits_in_char);
+
+	predefined_type_size("INT", "", bits_in_int);
+	predefined_type_size("LONG", "L", bits_in_long);
+	predefined_type_size("LONG_LONG", "LL", bits_in_longlong);
+
+	predefined_sizeof("INT128", 128);
+
+	predefined_sizeof("SIZE_T", bits_in_pointer);
+	predefined_sizeof("PTRDIFF_T", bits_in_pointer);
+	predefined_sizeof("POINTER", bits_in_pointer);
+
+	predefined_sizeof("FLOAT", bits_in_float);
+	predefined_sizeof("DOUBLE", bits_in_double);
+	predefined_sizeof("LONG_DOUBLE", bits_in_longdouble);
+
+	add_pre_buffer("#weak_define __%s_ENDIAN__ 1\n",
+		arch_big_endian ? "BIG" : "LITTLE");
+
+	add_pre_buffer("#weak_define __ORDER_LITTLE_ENDIAN__ 1234\n");
+	add_pre_buffer("#weak_define __ORDER_BIG_ENDIAN__ 4321\n");
+	add_pre_buffer("#weak_define __ORDER_PDP_ENDIAN__ 3412\n");
+	add_pre_buffer("#weak_define __BYTE_ORDER__ __ORDER_%s_ENDIAN__\n",
+		arch_big_endian ? "BIG" : "LITTLE");
+
+	add_pre_buffer("#weak_define __PRAGMA_REDEFINE_EXTNAME 1\n");
+
+	/*
+	 * This is far from perfect...
+	 */
+#ifdef	__sun
+	add_pre_buffer("#weak_define __unix__ 1\n");
+	add_pre_buffer("#weak_define __unix 1\n");
+	add_pre_buffer("#weak_define unix 1\n");
+	add_pre_buffer("#weak_define __sun__ 1\n");
+	add_pre_buffer("#weak_define __sun 1\n");
+	add_pre_buffer("#weak_define sun 1\n");
+	add_pre_buffer("#weak_define __svr4__ 1\n");
+#endif
+}
+
+void declare_builtin_functions(void)
+{
+	/* Gaah. gcc knows tons of builtin <string.h> functions */
+	add_pre_buffer("extern void *__builtin_memchr(const void *, int, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern void *__builtin_memcpy(void *, const void *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern void *__builtin_mempcpy(void *, const void *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern void *__builtin_memmove(void *, const void *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern void *__builtin_memset(void *, int, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern int __builtin_memcmp(const void *, const void *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern char *__builtin_strcat(char *, const char *);\n");
+	add_pre_buffer("extern char *__builtin_strncat(char *, const char *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern int __builtin_strcmp(const char *, const char *);\n");
+	add_pre_buffer("extern int __builtin_strncmp(const char *, const char *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern int __builtin_strcasecmp(const char *, const char *);\n");
+	add_pre_buffer("extern int __builtin_strncasecmp(const char *, const char *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern char *__builtin_strchr(const char *, int);\n");
+	add_pre_buffer("extern char *__builtin_strrchr(const char *, int);\n");
+	add_pre_buffer("extern char *__builtin_strcpy(char *, const char *);\n");
+	add_pre_buffer("extern char *__builtin_strncpy(char *, const char *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern char *__builtin_strdup(const char *);\n");
+	add_pre_buffer("extern char *__builtin_strndup(const char *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern __SIZE_TYPE__ __builtin_strspn(const char *, const char *);\n");
+	add_pre_buffer("extern __SIZE_TYPE__ __builtin_strcspn(const char *, const char *);\n");
+	add_pre_buffer("extern char * __builtin_strpbrk(const char *, const char *);\n");
+	add_pre_buffer("extern char* __builtin_stpcpy(const char *, const char*);\n");
+	add_pre_buffer("extern char* __builtin_stpncpy(const char *, const char*, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern __SIZE_TYPE__ __builtin_strlen(const char *);\n");
+	add_pre_buffer("extern char *__builtin_strstr(const char *, const char *);\n");
+	add_pre_buffer("extern char *__builtin_strcasestr(const char *, const char *);\n");
+	add_pre_buffer("extern char *__builtin_strnstr(const char *, const char *, __SIZE_TYPE__);\n");
+
+	/* And even some from <strings.h> */
+	add_pre_buffer("extern int  __builtin_bcmp(const void *, const void *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern void __builtin_bcopy(const void *, void *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern void __builtin_bzero(void *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern char*__builtin_index(const char *, int);\n");
+	add_pre_buffer("extern char*__builtin_rindex(const char *, int);\n");
+
+	/* And bitwise operations.. */
+	add_pre_buffer("extern int __builtin_clrsb(int);\n");
+	add_pre_buffer("extern int __builtin_clrsbl(long);\n");
+	add_pre_buffer("extern int __builtin_clrsbll(long long);\n");
+	add_pre_buffer("extern int __builtin_clz(int);\n");
+	add_pre_buffer("extern int __builtin_clzl(long);\n");
+	add_pre_buffer("extern int __builtin_clzll(long long);\n");
+	add_pre_buffer("extern int __builtin_ctz(int);\n");
+	add_pre_buffer("extern int __builtin_ctzl(long);\n");
+	add_pre_buffer("extern int __builtin_ctzll(long long);\n");
+	add_pre_buffer("extern int __builtin_ffs(int);\n");
+	add_pre_buffer("extern int __builtin_ffsl(long);\n");
+	add_pre_buffer("extern int __builtin_ffsll(long long);\n");
+	add_pre_buffer("extern int __builtin_parity(unsigned int);\n");
+	add_pre_buffer("extern int __builtin_parityl(unsigned long);\n");
+	add_pre_buffer("extern int __builtin_parityll(unsigned long long);\n");
+	add_pre_buffer("extern int __builtin_popcount(unsigned int);\n");
+	add_pre_buffer("extern int __builtin_popcountl(unsigned long);\n");
+	add_pre_buffer("extern int __builtin_popcountll(unsigned long long);\n");
+
+	/* And byte swaps.. */
+	add_pre_buffer("extern unsigned short __builtin_bswap16(unsigned short);\n");
+	add_pre_buffer("extern unsigned int __builtin_bswap32(unsigned int);\n");
+	add_pre_buffer("extern unsigned long long __builtin_bswap64(unsigned long long);\n");
+
+	/* And atomic memory access functions.. */
+	add_pre_buffer("extern int __sync_fetch_and_add(void *, ...);\n");
+	add_pre_buffer("extern int __sync_fetch_and_sub(void *, ...);\n");
+	add_pre_buffer("extern int __sync_fetch_and_or(void *, ...);\n");
+	add_pre_buffer("extern int __sync_fetch_and_and(void *, ...);\n");
+	add_pre_buffer("extern int __sync_fetch_and_xor(void *, ...);\n");
+	add_pre_buffer("extern int __sync_fetch_and_nand(void *, ...);\n");
+	add_pre_buffer("extern int __sync_add_and_fetch(void *, ...);\n");
+	add_pre_buffer("extern int __sync_sub_and_fetch(void *, ...);\n");
+	add_pre_buffer("extern int __sync_or_and_fetch(void *, ...);\n");
+	add_pre_buffer("extern int __sync_and_and_fetch(void *, ...);\n");
+	add_pre_buffer("extern int __sync_xor_and_fetch(void *, ...);\n");
+	add_pre_buffer("extern int __sync_nand_and_fetch(void *, ...);\n");
+	add_pre_buffer("extern int __sync_bool_compare_and_swap(void *, ...);\n");
+	add_pre_buffer("extern int __sync_val_compare_and_swap(void *, ...);\n");
+	add_pre_buffer("extern void __sync_synchronize();\n");
+	add_pre_buffer("extern int __sync_lock_test_and_set(void *, ...);\n");
+	add_pre_buffer("extern void __sync_lock_release(void *, ...);\n");
+
+	/* And some random ones.. */
+	add_pre_buffer("extern void *__builtin_return_address(unsigned int);\n");
+	add_pre_buffer("extern void *__builtin_extract_return_addr(void *);\n");
+	add_pre_buffer("extern void *__builtin_frame_address(unsigned int);\n");
+	add_pre_buffer("extern void __builtin_trap(void);\n");
+	add_pre_buffer("extern void *__builtin_alloca(__SIZE_TYPE__);\n");
+	add_pre_buffer("extern void __builtin_prefetch (const void *, ...);\n");
+	add_pre_buffer("extern long __builtin_alpha_extbl(long, long);\n");
+	add_pre_buffer("extern long __builtin_alpha_extwl(long, long);\n");
+	add_pre_buffer("extern long __builtin_alpha_insbl(long, long);\n");
+	add_pre_buffer("extern long __builtin_alpha_inswl(long, long);\n");
+	add_pre_buffer("extern long __builtin_alpha_insql(long, long);\n");
+	add_pre_buffer("extern long __builtin_alpha_inslh(long, long);\n");
+	add_pre_buffer("extern long __builtin_alpha_cmpbge(long, long);\n");
+	add_pre_buffer("extern int  __builtin_abs(int);\n");
+	add_pre_buffer("extern long __builtin_labs(long);\n");
+	add_pre_buffer("extern long long __builtin_llabs(long long);\n");
+	add_pre_buffer("extern double __builtin_fabs(double);\n");
+	add_pre_buffer("extern __SIZE_TYPE__ __builtin_va_arg_pack_len(void);\n");
+
+	/* Add Blackfin-specific stuff */
+	add_pre_buffer(
+		"#ifdef __bfin__\n"
+		"extern void __builtin_bfin_csync(void);\n"
+		"extern void __builtin_bfin_ssync(void);\n"
+		"extern int __builtin_bfin_norm_fr1x32(int);\n"
+		"#endif\n"
+	);
+
+	/* And some floating point stuff.. */
+	add_pre_buffer("extern int __builtin_isgreater(float, float);\n");
+	add_pre_buffer("extern int __builtin_isgreaterequal(float, float);\n");
+	add_pre_buffer("extern int __builtin_isless(float, float);\n");
+	add_pre_buffer("extern int __builtin_islessequal(float, float);\n");
+	add_pre_buffer("extern int __builtin_islessgreater(float, float);\n");
+	add_pre_buffer("extern int __builtin_isunordered(float, float);\n");
+
+	/* And some INFINITY / NAN stuff.. */
+	add_pre_buffer("extern double __builtin_huge_val(void);\n");
+	add_pre_buffer("extern float __builtin_huge_valf(void);\n");
+	add_pre_buffer("extern long double __builtin_huge_vall(void);\n");
+	add_pre_buffer("extern double __builtin_inf(void);\n");
+	add_pre_buffer("extern float __builtin_inff(void);\n");
+	add_pre_buffer("extern long double __builtin_infl(void);\n");
+	add_pre_buffer("extern double __builtin_nan(const char *);\n");
+	add_pre_buffer("extern float __builtin_nanf(const char *);\n");
+	add_pre_buffer("extern long double __builtin_nanl(const char *);\n");
+	add_pre_buffer("extern int __builtin_isinf_sign(float);\n");
+	add_pre_buffer("extern int __builtin_isfinite(float);\n");
+	add_pre_buffer("extern int __builtin_isnan(float);\n");
+
+	/* And some __FORTIFY_SOURCE ones.. */
+	add_pre_buffer ("extern __SIZE_TYPE__ __builtin_object_size(const void *, int);\n");
+	add_pre_buffer ("extern void * __builtin___memcpy_chk(void *, const void *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
+	add_pre_buffer ("extern void * __builtin___memmove_chk(void *, const void *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
+	add_pre_buffer ("extern void * __builtin___mempcpy_chk(void *, const void *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
+	add_pre_buffer ("extern void * __builtin___memset_chk(void *, int, __SIZE_TYPE__, __SIZE_TYPE__);\n");
+	add_pre_buffer ("extern int __builtin___sprintf_chk(char *, int, __SIZE_TYPE__, const char *, ...);\n");
+	add_pre_buffer ("extern int __builtin___snprintf_chk(char *, __SIZE_TYPE__, int , __SIZE_TYPE__, const char *, ...);\n");
+	add_pre_buffer ("extern char * __builtin___stpcpy_chk(char *, const char *, __SIZE_TYPE__);\n");
+	add_pre_buffer ("extern char * __builtin___strcat_chk(char *, const char *, __SIZE_TYPE__);\n");
+	add_pre_buffer ("extern char * __builtin___strcpy_chk(char *, const char *, __SIZE_TYPE__);\n");
+	add_pre_buffer ("extern char * __builtin___strncat_chk(char *, const char *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
+	add_pre_buffer ("extern char * __builtin___strncpy_chk(char *, const char *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
+	add_pre_buffer ("extern int __builtin___vsprintf_chk(char *, int, __SIZE_TYPE__, const char *, __builtin_va_list);\n");
+	add_pre_buffer ("extern int __builtin___vsnprintf_chk(char *, __SIZE_TYPE__, int, __SIZE_TYPE__, const char *, __builtin_va_list ap);\n");
+	add_pre_buffer ("extern void __builtin_unreachable(void);\n");
+
+	/* And some from <stdlib.h> */
+	add_pre_buffer("extern void __builtin_abort(void);\n");
+	add_pre_buffer("extern void *__builtin_calloc(__SIZE_TYPE__, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern void __builtin_exit(int);\n");
+	add_pre_buffer("extern void *__builtin_malloc(__SIZE_TYPE__);\n");
+	add_pre_buffer("extern void *__builtin_realloc(void *, __SIZE_TYPE__);\n");
+	add_pre_buffer("extern void __builtin_free(void *);\n");
+
+	/* And some from <stdio.h> */
+	add_pre_buffer("extern int __builtin_printf(const char *, ...);\n");
+	add_pre_buffer("extern int __builtin_sprintf(char *, const char *, ...);\n");
+	add_pre_buffer("extern int __builtin_snprintf(char *, __SIZE_TYPE__, const char *, ...);\n");
+	add_pre_buffer("extern int __builtin_puts(const char *);\n");
+	add_pre_buffer("extern int __builtin_vprintf(const char *, __builtin_va_list);\n");
+	add_pre_buffer("extern int __builtin_vsprintf(char *, const char *, __builtin_va_list);\n");
+	add_pre_buffer("extern int __builtin_vsnprintf(char *, __SIZE_TYPE__, const char *, __builtin_va_list ap);\n");
+}
+
+void create_builtin_stream(void)
+{
+	add_pre_buffer("#weak_define __GNUC__ %d\n", gcc_major);
+	add_pre_buffer("#weak_define __GNUC_MINOR__ %d\n", gcc_minor);
+	add_pre_buffer("#weak_define __GNUC_PATCHLEVEL__ %d\n", gcc_patchlevel);
+
+	/* add the multiarch include directories, if any */
+	if (multiarch_dir && *multiarch_dir) {
+		add_pre_buffer("#add_system \"/usr/include/%s\"\n", multiarch_dir);
+		add_pre_buffer("#add_system \"/usr/local/include/%s\"\n", multiarch_dir);
+	}
+
+	/* We add compiler headers path here because we have to parse
+	 * the arguments to get it, falling back to default. */
+	add_pre_buffer("#add_system \"%s/include\"\n", gcc_base_dir);
+	add_pre_buffer("#add_system \"%s/include-fixed\"\n", gcc_base_dir);
+
+	add_pre_buffer("#define __extension__\n");
+	add_pre_buffer("#define __pragma__\n");
+	add_pre_buffer("#define _Pragma(x)\n");
+
+	// gcc defines __SIZE_TYPE__ to be size_t.  For linux/i86 and
+	// solaris/sparc that is really "unsigned int" and for linux/x86_64
+	// it is "long unsigned int".  In either case we can probably
+	// get away with this.  We need the #weak_define as cgcc will define
+	// the right __SIZE_TYPE__.
+	if (size_t_ctype == &ulong_ctype)
+		add_pre_buffer("#weak_define __SIZE_TYPE__ long unsigned int\n");
+	else
+		add_pre_buffer("#weak_define __SIZE_TYPE__ unsigned int\n");
+	add_pre_buffer("#weak_define __STDC__ 1\n");
+
+	switch (standard)
+	{
+		case STANDARD_C89:
+			add_pre_buffer("#weak_define __STRICT_ANSI__\n");
+			break;
+
+		case STANDARD_C94:
+			add_pre_buffer("#weak_define __STDC_VERSION__ 199409L\n");
+			add_pre_buffer("#weak_define __STRICT_ANSI__\n");
+			break;
+
+		case STANDARD_C99:
+			add_pre_buffer("#weak_define __STDC_VERSION__ 199901L\n");
+			add_pre_buffer("#weak_define __STRICT_ANSI__\n");
+			break;
+
+		case STANDARD_GNU89:
+			break;
+
+		case STANDARD_GNU99:
+			add_pre_buffer("#weak_define __STDC_VERSION__ 199901L\n");
+			break;
+
+		case STANDARD_C11:
+			add_pre_buffer("#weak_define __STRICT_ANSI__ 1\n");
+		case STANDARD_GNU11:
+			add_pre_buffer("#weak_define __STDC_NO_ATOMICS__ 1\n");
+			add_pre_buffer("#weak_define __STDC_NO_COMPLEX__ 1\n");
+			add_pre_buffer("#weak_define __STDC_NO_THREADS__ 1\n");
+			add_pre_buffer("#weak_define __STDC_VERSION__ 201112L\n");
+			break;
+
+		default:
+			assert (0);
+	}
+
+	add_pre_buffer("#define __builtin_stdarg_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
+	add_pre_buffer("#define __builtin_va_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
+	add_pre_buffer("#define __builtin_ms_va_start(a,b) ((a) = (__builtin_ms_va_list)(&(b)))\n");
+	add_pre_buffer("#define __builtin_va_arg(arg,type)  ({ type __va_arg_ret = *(type *)(arg); arg += sizeof(type); __va_arg_ret; })\n");
+	add_pre_buffer("#define __builtin_va_alist (*(void *)0)\n");
+	add_pre_buffer("#define __builtin_va_arg_incr(x) ((x) + 1)\n");
+	add_pre_buffer("#define __builtin_va_copy(dest, src) ({ dest = src; (void)0; })\n");
+	add_pre_buffer("#define __builtin_ms_va_copy(dest, src) ({ dest = src; (void)0; })\n");
+	add_pre_buffer("#define __builtin_va_end(arg)\n");
+	add_pre_buffer("#define __builtin_ms_va_end(arg)\n");
+	add_pre_buffer("#define __builtin_va_arg_pack()\n");
+
+	/* FIXME! We need to do these as special magic macros at expansion time! */
+	add_pre_buffer("#define __BASE_FILE__ \"base_file.c\"\n");
+
+	if (optimize)
+		add_pre_buffer("#define __OPTIMIZE__ 1\n");
+	if (optimize_size)
+		add_pre_buffer("#define __OPTIMIZE_SIZE__ 1\n");
+}
+
+static struct symbol_list *sparse_tokenstream(struct token *token)
+{
+	int builtin = token && !token->pos.stream;
+
+	// Preprocess the stream
+	token = preprocess(token);
+
+	if (dump_macro_defs && !builtin)
+		dump_macro_definitions();
+
+	if (preprocess_only) {
+		while (!eof_token(token)) {
+			int prec = 1;
+			struct token *next = token->next;
+			const char *separator = "";
+			if (next->pos.whitespace)
+				separator = " ";
+			if (next->pos.newline) {
+				separator = "\n\t\t\t\t\t";
+				prec = next->pos.pos;
+				if (prec > 4)
+					prec = 4;
+			}
+			printf("%s%.*s", show_token(token), prec, separator);
+			token = next;
+		}
+		putchar('\n');
+
+		return NULL;
+	}
+
+	// Parse the resulting C code
+	while (!eof_token(token))
+		token = external_declaration(token, &translation_unit_used_list, NULL);
+	return translation_unit_used_list;
+}
+
+static struct symbol_list *sparse_file(const char *filename)
+{
+	int fd;
+	struct token *token;
+
+	if (strcmp (filename, "-") == 0) {
+		fd = 0;
+	} else {
+		fd = open(filename, O_RDONLY);
+		if (fd < 0)
+			die("No such file: %s", filename);
+	}
+
+	// Tokenize the input stream
+	token = tokenize(filename, fd, NULL, includepath);
+	store_all_tokens(token);
+	close(fd);
+
+	return sparse_tokenstream(token);
+}
+
+static int endswith(const char *str, const char *suffix)
+{
+	const char *found = strstr(str, suffix);
+	return (found && strcmp(found, suffix) == 0);
+}
+
+/*
+ * This handles the "-include" directive etc: we're in global
+ * scope, and all types/macros etc will affect all the following
+ * files.
+ *
+ * NOTE NOTE NOTE! "#undef" of anything in this stage will
+ * affect all subsequent files too, i.e. we can have non-local
+ * behaviour between files!
+ */
+static struct symbol_list *sparse_initial(void)
+{
+	int i;
+
+	// Prepend any "include" file to the stream.
+	// We're in global scope, it will affect all files!
+	for (i = 0; i < cmdline_include_nr; i++)
+		add_pre_buffer("#argv_include \"%s\"\n", cmdline_include[i]);
+
+	return sparse_tokenstream(pre_buffer_begin);
+}
+
+struct symbol_list *sparse_initialize(int argc, char **argv, struct string_list **filelist)
+{
+	char **args;
+	struct symbol_list *list;
+
+	// Initialize symbol stream first, so that we can add defines etc
+	init_symbols();
+	init_include_path();
+
+	progname = argv[0];
+
+	args = argv;
+	for (;;) {
+		char *arg = *++args;
+		if (!arg)
+			break;
+
+		if (arg[0] == '-' && arg[1]) {
+			args = handle_switch(arg+1, args);
+			continue;
+		}
+
+		if (endswith(arg, ".a") || endswith(arg, ".so") ||
+		    endswith(arg, ".so.1") || endswith(arg, ".o"))
+			continue;
+
+		add_ptr_list_notag(filelist, arg);
+	}
+	handle_switch_W_finalize();
+	handle_switch_v_finalize();
+
+	handle_arch_finalize();
+
+	list = NULL;
+	if (!ptr_list_empty(filelist)) {
+		// Initialize type system
+		init_ctype();
+		handle_funsigned_char();
+
+		create_builtin_stream();
+		predefined_macros();
+		if (!preprocess_only)
+			declare_builtin_functions();
+
+		list = sparse_initial();
+
+		/*
+		 * Protect the initial token allocations, since
+		 * they need to survive all the others
+		 */
+		protect_token_alloc();
+	}
+	/*
+	 * Evaluate the complete symbol list
+	 * Note: This is not needed for normal cases.
+	 *	 These symbols should only be predefined defines and
+	 *	 declaratons which will be evaluated later, when needed.
+	 *	 This is also the case when a file is directly included via
+	 *	 '-include <file>' on the command line *AND* the file only
+	 *	 contains defines, declarations and inline definitions.
+	 *	 However, in the rare cases where the given file should
+	 *	 contain some definitions, these will never be evaluated
+	 *	 and thus won't be able to be linearized correctly.
+	 *	 Hence the evaluate_symbol_list() here under.
+	 */
+	evaluate_symbol_list(list);
+	return list;
+}
+
+struct symbol_list * sparse_keep_tokens(char *filename)
+{
+	struct symbol_list *res;
+
+	/* Clear previous symbol list */
+	translation_unit_used_list = NULL;
+
+	new_file_scope();
+	res = sparse_file(filename);
+
+	/* And return it */
+	return res;
+}
+
+
+struct symbol_list * __sparse(char *filename)
+{
+	struct symbol_list *res;
+
+	res = sparse_keep_tokens(filename);
+
+	/* Drop the tokens for this file after parsing */
+	clear_token_alloc();
+
+	/* And return it */
+	return res;
+}
+
+struct symbol_list * sparse(char *filename)
+{
+	struct symbol_list *res = __sparse(filename);
+
+	if (has_error & ERROR_CURR_PHASE)
+		has_error = ERROR_PREV_PHASE;
+	/* Evaluate the complete symbol list */
+	evaluate_symbol_list(res);
+
+	return res;
+}
diff --git a/usr/src/tools/smatch/src/lib.h b/usr/src/tools/smatch/src/lib.h
new file mode 100644
index 0000000000..9d9a6ee187
--- /dev/null
+++ b/usr/src/tools/smatch/src/lib.h
@@ -0,0 +1,284 @@
+#ifndef LIB_H
+#define LIB_H
+
+#include <stdlib.h>
+#include <stddef.h>
+
+/*
+ * Basic helper routine descriptions for 'sparse'.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *               2004 Christopher Li
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "compat.h"
+#include "ptrlist.h"
+
+#define DO_STRINGIFY(x) #x
+#define STRINGIFY(x) DO_STRINGIFY(x)
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
+#endif
+
+extern int verbose, optimize, optimize_size, preprocessing;
+extern int die_if_error;
+extern int parse_error;
+extern int repeat_phase, merge_phi_sources;
+extern int gcc_major, gcc_minor, gcc_patchlevel;
+
+extern unsigned int hexval(unsigned int c);
+
+struct position {
+	unsigned int type:6,
+		     stream:14,
+		     newline:1,
+		     whitespace:1,
+		     pos:10;
+	unsigned int line:31,
+		     noexpand:1;
+};
+
+struct ident;
+struct token;
+struct symbol;
+struct statement;
+struct expression;
+struct basic_block;
+struct entrypoint;
+struct instruction;
+struct multijmp;
+struct pseudo;
+
+DECLARE_PTR_LIST(symbol_list, struct symbol);
+DECLARE_PTR_LIST(statement_list, struct statement);
+DECLARE_PTR_LIST(expression_list, struct expression);
+DECLARE_PTR_LIST(basic_block_list, struct basic_block);
+DECLARE_PTR_LIST(instruction_list, struct instruction);
+DECLARE_PTR_LIST(multijmp_list, struct multijmp);
+DECLARE_PTR_LIST(pseudo_list, struct pseudo);
+DECLARE_PTR_LIST(ident_list, struct ident);
+DECLARE_PTR_LIST(string_list, char);
+
+typedef struct pseudo *pseudo_t;
+
+struct token *skip_to(struct token *, int);
+struct token *expect(struct token *, int, const char *);
+#ifdef __GNUC__
+#define FORMAT_ATTR(pos) __attribute__ ((__format__ (__printf__, pos, pos+1)))
+#define NORETURN_ATTR __attribute__ ((__noreturn__))
+#define SENTINEL_ATTR __attribute__ ((__sentinel__))
+#else
+#define FORMAT_ATTR(pos)
+#define NORETURN_ATTR
+#define SENTINEL_ATTR
+#endif
+
+FORMAT_ATTR(1) NORETURN_ATTR
+extern void die(const char *, ...);
+
+FORMAT_ATTR(2) NORETURN_ATTR
+extern void error_die(struct position, const char *, ...);
+
+extern void info(struct position, const char *, ...) FORMAT_ATTR(2);
+extern void warning(struct position, const char *, ...) FORMAT_ATTR(2);
+extern void sparse_error(struct position, const char *, ...) FORMAT_ATTR(2);
+extern void expression_error(struct expression *, const char *, ...) FORMAT_ATTR(2);
+
+#define	ERROR_CURR_PHASE	(1 << 0)
+#define	ERROR_PREV_PHASE	(1 << 1)
+extern int has_error;
+
+extern void add_pre_buffer(const char *fmt, ...) FORMAT_ATTR(1);
+
+extern int preprocess_only;
+
+extern int Waddress;
+extern int Waddress_space;
+extern int Wbitwise;
+extern int Wcast_to_as;
+extern int Wcast_truncate;
+extern int Wconstant_suffix;
+extern int Wconstexpr_not_const;
+extern int Wcontext;
+extern int Wdecl;
+extern int Wdeclarationafterstatement;
+extern int Wdefault_bitfield_sign;
+extern int Wdesignated_init;
+extern int Wdo_while;
+extern int Wenum_mismatch;
+extern int Wexternal_function_has_definition;
+extern int Wsparse_error;
+extern int Wimplicit_int;
+extern int Winit_cstring;
+extern int Wmemcpy_max_count;
+extern int Wnon_pointer_null;
+extern int Wold_initializer;
+extern int Wold_style_definition;
+extern int Wone_bit_signed_bitfield;
+extern int Woverride_init;
+extern int Woverride_init_all;
+extern int Woverride_init_whole_range;
+extern int Wparen_string;
+extern int Wpointer_arith;
+extern int Wptr_subtraction_blows;
+extern int Wreturn_void;
+extern int Wshadow;
+extern int Wsizeof_bool;
+extern int Wstrict_prototypes;
+extern int Wtautological_compare;
+extern int Wtransparent_union;
+extern int Wtypesign;
+extern int Wundef;
+extern int Wuninitialized;
+extern int Wunknown_attribute;
+extern int Wvla;
+
+extern int dump_macro_defs;
+
+extern int dbg_entry;
+extern int dbg_dead;
+
+extern int fmem_report;
+extern int fdump_linearize;
+extern unsigned long long fmemcpy_max_count;
+
+extern int arch_m64;
+extern int arch_msize_long;
+extern int arch_big_endian;
+
+extern void declare_builtin_functions(void);
+extern void create_builtin_stream(void);
+extern void dump_macro_definitions(void);
+extern struct symbol_list *sparse_initialize(int argc, char **argv, struct string_list **files);
+extern struct symbol_list *__sparse(char *filename);
+extern struct symbol_list *sparse_keep_tokens(char *filename);
+extern struct symbol_list *sparse(char *filename);
+extern void report_stats(void);
+
+static inline int symbol_list_size(struct symbol_list *list)
+{
+	return ptr_list_size((struct ptr_list *)(list));
+}
+
+static inline int statement_list_size(struct statement_list *list)
+{
+	return ptr_list_size((struct ptr_list *)(list));
+}
+
+static inline int expression_list_size(struct expression_list *list)
+{
+	return ptr_list_size((struct ptr_list *)(list));
+}
+
+static inline int instruction_list_size(struct instruction_list *list)
+{
+	return ptr_list_size((struct ptr_list *)(list));
+}
+
+static inline int pseudo_list_size(struct pseudo_list *list)
+{
+	return ptr_list_size((struct ptr_list *)(list));
+}
+
+static inline int bb_list_size(struct basic_block_list *list)
+{
+	return ptr_list_size((struct ptr_list *)(list));
+}
+
+static inline void free_instruction_list(struct instruction_list **head)
+{
+	free_ptr_list((struct ptr_list **)head);
+}
+
+static inline struct instruction * delete_last_instruction(struct instruction_list **head)
+{
+	return undo_ptr_list_last((struct ptr_list **)head);
+}
+
+static inline struct basic_block * delete_last_basic_block(struct basic_block_list **head)
+{
+	return delete_ptr_list_last((struct ptr_list **)head);
+}
+
+static inline struct basic_block *first_basic_block(struct basic_block_list *head)
+{
+	return first_ptr_list((struct ptr_list *)head);
+}
+static inline struct instruction *last_instruction(struct instruction_list *head)
+{
+	return last_ptr_list((struct ptr_list *)head);
+}
+
+static inline struct instruction *first_instruction(struct instruction_list *head)
+{
+	return first_ptr_list((struct ptr_list *)head);
+}
+
+static inline struct expression *first_expression(struct expression_list *head)
+{
+	return first_ptr_list((struct ptr_list *)head);
+}
+
+static inline pseudo_t first_pseudo(struct pseudo_list *head)
+{
+	return first_ptr_list((struct ptr_list *)head);
+}
+
+static inline void concat_symbol_list(struct symbol_list *from, struct symbol_list **to)
+{
+	concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
+}
+
+static inline void concat_basic_block_list(struct basic_block_list *from, struct basic_block_list **to)
+{
+	concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
+}
+
+static inline void concat_instruction_list(struct instruction_list *from, struct instruction_list **to)
+{
+	concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
+}
+
+static inline void add_symbol(struct symbol_list **list, struct symbol *sym)
+{
+	add_ptr_list(list, sym);
+}
+
+static inline void add_statement(struct statement_list **list, struct statement *stmt)
+{
+	add_ptr_list(list, stmt);
+}
+
+static inline void add_expression(struct expression_list **list, struct expression *expr)
+{
+	add_ptr_list(list, expr);
+}
+
+static inline void add_ident(struct ident_list **list, struct ident *ident)
+{
+	add_ptr_list(list, ident);
+}
+
+#define hashval(x) ((unsigned long)(x))
+
+#endif
diff --git a/usr/src/tools/smatch/src/linearize.c b/usr/src/tools/smatch/src/linearize.c
new file mode 100644
index 0000000000..2aa3acb2c1
--- /dev/null
+++ b/usr/src/tools/smatch/src/linearize.c
@@ -0,0 +1,2293 @@
+/*
+ * Linearize - walk the statement tree (but _not_ the expressions)
+ * to generate a linear version of it and the basic blocks. 
+ *
+ * NOTE! We're not interested in the actual sub-expressions yet,
+ * even though they can generate conditional branches and
+ * subroutine calls. That's all "local" behaviour.
+ *
+ * Copyright (C) 2004 Linus Torvalds
+ * Copyright (C) 2004 Christopher Li
+ */
+
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+
+#include "parse.h"
+#include "expression.h"
+#include "linearize.h"
+#include "flow.h"
+#include "target.h"
+
+pseudo_t linearize_statement(struct entrypoint *ep, struct statement *stmt);
+pseudo_t linearize_expression(struct entrypoint *ep, struct expression *expr);
+
+static pseudo_t add_binary_op(struct entrypoint *ep, struct symbol *ctype, int op, pseudo_t left, pseudo_t right);
+static pseudo_t add_setval(struct entrypoint *ep, struct symbol *ctype, struct expression *val);
+static pseudo_t linearize_one_symbol(struct entrypoint *ep, struct symbol *sym);
+
+struct access_data;
+static pseudo_t add_load(struct entrypoint *ep, struct access_data *);
+static pseudo_t linearize_initializer(struct entrypoint *ep, struct expression *initializer, struct access_data *);
+static pseudo_t cast_pseudo(struct entrypoint *ep, pseudo_t src, struct symbol *from, struct symbol *to);
+
+struct pseudo void_pseudo = {};
+
+static struct position current_pos;
+
+ALLOCATOR(pseudo_user, "pseudo_user");
+
+static struct instruction *alloc_instruction(int opcode, int size)
+{
+	struct instruction * insn = __alloc_instruction(0);
+	insn->opcode = opcode;
+	insn->size = size;
+	insn->pos = current_pos;
+	return insn;
+}
+
+static inline int type_size(struct symbol *type)
+{
+	return type ? type->bit_size > 0 ? type->bit_size : 0 : 0;
+}
+
+static struct instruction *alloc_typed_instruction(int opcode, struct symbol *type)
+{
+	struct instruction *insn = alloc_instruction(opcode, type_size(type));
+	insn->type = type;
+	return insn;
+}
+
+static struct entrypoint *alloc_entrypoint(void)
+{
+	return __alloc_entrypoint(0);
+}
+
+static struct basic_block *alloc_basic_block(struct entrypoint *ep, struct position pos)
+{
+	static int nr;
+	struct basic_block *bb = __alloc_basic_block(0);
+	bb->context = -1;
+	bb->pos = pos;
+	bb->ep = ep;
+	bb->nr = nr++;
+	return bb;
+}
+
+static struct multijmp *alloc_multijmp(struct basic_block *target, int begin, int end)
+{
+	struct multijmp *multijmp = __alloc_multijmp(0);
+	multijmp->target = target;
+	multijmp->begin = begin;
+	multijmp->end = end;
+	return multijmp;
+}
+
+static inline int regno(pseudo_t n)
+{
+	int retval = -1;
+	if (n && n->type == PSEUDO_REG)
+		retval = n->nr;
+	return retval;
+}
+
+const char *show_pseudo(pseudo_t pseudo)
+{
+	static int n;
+	static char buffer[4][64];
+	char *buf;
+	int i;
+
+	if (!pseudo)
+		return "no pseudo";
+	if (pseudo == VOID)
+		return "VOID";
+	buf = buffer[3 & ++n];
+	switch(pseudo->type) {
+	case PSEUDO_SYM: {
+		struct symbol *sym = pseudo->sym;
+		struct expression *expr;
+
+		if (sym->bb_target) {
+			snprintf(buf, 64, ".L%u", sym->bb_target->nr);
+			break;
+		}
+		if (sym->ident) {
+			snprintf(buf, 64, "%s", show_ident(sym->ident));
+			break;
+		}
+		expr = sym->initializer;
+		snprintf(buf, 64, "<anon symbol:%p>", sym);
+		if (expr) {
+			switch (expr->type) {
+			case EXPR_VALUE:
+				snprintf(buf, 64, "<symbol value: %lld>", expr->value);
+				break;
+			case EXPR_STRING:
+				return show_string(expr->string);
+			default:
+				break;
+			}
+		}
+		break;
+	}
+	case PSEUDO_REG:
+		i = snprintf(buf, 64, "%%r%d", pseudo->nr);
+		if (pseudo->ident)
+			sprintf(buf+i, "(%s)", show_ident(pseudo->ident));
+		break;
+	case PSEUDO_VAL: {
+		long long value = pseudo->value;
+		if (value > 1000 || value < -1000)
+			snprintf(buf, 64, "$%#llx", value);
+		else
+			snprintf(buf, 64, "$%lld", value);
+		break;
+	}
+	case PSEUDO_ARG:
+		snprintf(buf, 64, "%%arg%d", pseudo->nr);
+		break;
+	case PSEUDO_PHI:
+		i = snprintf(buf, 64, "%%phi%d", pseudo->nr);
+		if (pseudo->ident)
+			sprintf(buf+i, "(%s)", show_ident(pseudo->ident));
+		break;
+	default:
+		snprintf(buf, 64, "<bad pseudo type %d>", pseudo->type);
+	}
+	return buf;
+}
+
+static const char *opcodes[] = {
+	[OP_BADOP] = "bad_op",
+
+	/* Fn entrypoint */
+	[OP_ENTRY] = "<entry-point>",
+
+	/* Terminator */
+	[OP_RET] = "ret",
+	[OP_BR] = "br",
+	[OP_CBR] = "cbr",
+	[OP_SWITCH] = "switch",
+	[OP_INVOKE] = "invoke",
+	[OP_COMPUTEDGOTO] = "jmp *",
+	[OP_UNWIND] = "unwind",
+	
+	/* Binary */
+	[OP_ADD] = "add",
+	[OP_SUB] = "sub",
+	[OP_MULU] = "mulu",
+	[OP_MULS] = "muls",
+	[OP_DIVU] = "divu",
+	[OP_DIVS] = "divs",
+	[OP_MODU] = "modu",
+	[OP_MODS] = "mods",
+	[OP_SHL] = "shl",
+	[OP_LSR] = "lsr",
+	[OP_ASR] = "asr",
+	
+	/* Logical */
+	[OP_AND] = "and",
+	[OP_OR] = "or",
+	[OP_XOR] = "xor",
+	[OP_AND_BOOL] = "and-bool",
+	[OP_OR_BOOL] = "or-bool",
+
+	/* Binary comparison */
+	[OP_SET_EQ] = "seteq",
+	[OP_SET_NE] = "setne",
+	[OP_SET_LE] = "setle",
+	[OP_SET_GE] = "setge",
+	[OP_SET_LT] = "setlt",
+	[OP_SET_GT] = "setgt",
+	[OP_SET_B] = "setb",
+	[OP_SET_A] = "seta",
+	[OP_SET_BE] = "setbe",
+	[OP_SET_AE] = "setae",
+
+	/* Uni */
+	[OP_NOT] = "not",
+	[OP_NEG] = "neg",
+
+	/* Special three-input */
+	[OP_SEL] = "select",
+	
+	/* Memory */
+	[OP_MALLOC] = "malloc",
+	[OP_FREE] = "free",
+	[OP_ALLOCA] = "alloca",
+	[OP_LOAD] = "load",
+	[OP_STORE] = "store",
+	[OP_SETVAL] = "set",
+	[OP_SYMADDR] = "symaddr",
+	[OP_GET_ELEMENT_PTR] = "getelem",
+
+	/* Other */
+	[OP_PHI] = "phi",
+	[OP_PHISOURCE] = "phisrc",
+	[OP_CAST] = "cast",
+	[OP_SCAST] = "scast",
+	[OP_FPCAST] = "fpcast",
+	[OP_PTRCAST] = "ptrcast",
+	[OP_INLINED_CALL] = "# call",
+	[OP_CALL] = "call",
+	[OP_VANEXT] = "va_next",
+	[OP_VAARG] = "va_arg",
+	[OP_SLICE] = "slice",
+	[OP_SNOP] = "snop",
+	[OP_LNOP] = "lnop",
+	[OP_NOP] = "nop",
+	[OP_DEATHNOTE] = "dead",
+	[OP_ASM] = "asm",
+
+	/* Sparse tagging (line numbers, context, whatever) */
+	[OP_CONTEXT] = "context",
+	[OP_RANGE] = "range-check",
+
+	[OP_COPY] = "copy",
+};
+
+static char *show_asm_constraints(char *buf, const char *sep, struct asm_constraint_list *list)
+{
+	struct asm_constraint *entry;
+
+	FOR_EACH_PTR(list, entry) {
+		buf += sprintf(buf, "%s\"%s\"", sep, entry->constraint);
+		if (entry->pseudo)
+			buf += sprintf(buf, " (%s)", show_pseudo(entry->pseudo));
+		if (entry->ident)
+			buf += sprintf(buf, " [%s]", show_ident(entry->ident));
+		sep = ", ";		
+	} END_FOR_EACH_PTR(entry);
+	return buf;
+}
+
+static char *show_asm(char *buf, struct instruction *insn)
+{
+	struct asm_rules *rules = insn->asm_rules;
+
+	buf += sprintf(buf, "\"%s\"", insn->string);
+	buf = show_asm_constraints(buf, "\n\t\tout: ", rules->outputs);
+	buf = show_asm_constraints(buf, "\n\t\tin: ", rules->inputs);
+	buf = show_asm_constraints(buf, "\n\t\tclobber: ", rules->clobbers);
+	return buf;
+}
+
+const char *show_instruction(struct instruction *insn)
+{
+	int opcode = insn->opcode;
+	static char buffer[4096];
+	char *buf;
+
+	buf = buffer;
+	if (!insn->bb)
+		buf += sprintf(buf, "# ");
+
+	if (opcode < ARRAY_SIZE(opcodes)) {
+		const char *op = opcodes[opcode];
+		if (!op)
+			buf += sprintf(buf, "opcode:%d", opcode);
+		else
+			buf += sprintf(buf, "%s", op);
+		if (insn->size)
+			buf += sprintf(buf, ".%d", insn->size);
+		memset(buf, ' ', 20);
+		buf++;
+	}
+
+	if (buf < buffer + 12)
+		buf = buffer + 12;
+	switch (opcode) {
+	case OP_RET:
+		if (insn->src && insn->src != VOID)
+			buf += sprintf(buf, "%s", show_pseudo(insn->src));
+		break;
+
+	case OP_CBR:
+		buf += sprintf(buf, "%s, .L%u, .L%u", show_pseudo(insn->cond), insn->bb_true->nr, insn->bb_false->nr);
+		break;
+
+	case OP_BR:
+		buf += sprintf(buf, ".L%u", insn->bb_true->nr);
+		break;
+
+	case OP_SYMADDR: {
+		struct symbol *sym = insn->symbol->sym;
+		buf += sprintf(buf, "%s <- ", show_pseudo(insn->target));
+
+		if (!insn->bb && !sym)
+			break;
+		if (sym->bb_target) {
+			buf += sprintf(buf, ".L%u", sym->bb_target->nr);
+			break;
+		}
+		if (sym->ident) {
+			buf += sprintf(buf, "%s", show_ident(sym->ident));
+			break;
+		}
+		buf += sprintf(buf, "<anon symbol:%p>", sym);
+		break;
+	}
+		
+	case OP_SETVAL: {
+		struct expression *expr = insn->val;
+		struct symbol *sym;
+		buf += sprintf(buf, "%s <- ", show_pseudo(insn->target));
+
+		if (!expr) {
+			buf += sprintf(buf, "%s", "<none>");
+			break;
+		}
+			
+		switch (expr->type) {
+		case EXPR_VALUE:
+			buf += sprintf(buf, "%lld", expr->value);
+			break;
+		case EXPR_FVALUE:
+			buf += sprintf(buf, "%Lf", expr->fvalue);
+			break;
+		case EXPR_STRING:
+			buf += sprintf(buf, "%.40s", show_string(expr->string));
+			break;
+		case EXPR_SYMBOL:
+			buf += sprintf(buf, "%s", show_ident(expr->symbol->ident));
+			break;
+		case EXPR_LABEL:
+			sym = expr->symbol;
+			if (sym->bb_target)
+				buf += sprintf(buf, ".L%u", sym->bb_target->nr);
+			break;
+		default:
+			buf += sprintf(buf, "SETVAL EXPR TYPE %d", expr->type);
+		}
+		break;
+	}
+	case OP_SWITCH: {
+		struct multijmp *jmp;
+		buf += sprintf(buf, "%s", show_pseudo(insn->cond));
+		FOR_EACH_PTR(insn->multijmp_list, jmp) {
+			if (jmp->begin == jmp->end)
+				buf += sprintf(buf, ", %d -> .L%u", jmp->begin, jmp->target->nr);
+			else if (jmp->begin < jmp->end)
+				buf += sprintf(buf, ", %d ... %d -> .L%u", jmp->begin, jmp->end, jmp->target->nr);
+			else
+				buf += sprintf(buf, ", default -> .L%u", jmp->target->nr);
+		} END_FOR_EACH_PTR(jmp);
+		break;
+	}
+	case OP_COMPUTEDGOTO: {
+		struct multijmp *jmp;
+		buf += sprintf(buf, "%s", show_pseudo(insn->target));
+		FOR_EACH_PTR(insn->multijmp_list, jmp) {
+			buf += sprintf(buf, ", .L%u", jmp->target->nr);
+		} END_FOR_EACH_PTR(jmp);
+		break;
+	}
+
+	case OP_PHISOURCE: {
+		struct instruction *phi;
+		buf += sprintf(buf, "%s <- %s    ", show_pseudo(insn->target), show_pseudo(insn->phi_src));
+		FOR_EACH_PTR(insn->phi_users, phi) {
+			buf += sprintf(buf, " (%s)", show_pseudo(phi->target));
+		} END_FOR_EACH_PTR(phi);
+		break;
+	}
+
+	case OP_PHI: {
+		pseudo_t phi;
+		const char *s = " <-";
+		buf += sprintf(buf, "%s", show_pseudo(insn->target));
+		FOR_EACH_PTR(insn->phi_list, phi) {
+			buf += sprintf(buf, "%s %s", s, show_pseudo(phi));
+			s = ",";
+		} END_FOR_EACH_PTR(phi);
+		break;
+	}	
+	case OP_LOAD: case OP_LNOP:
+		buf += sprintf(buf, "%s <- %d[%s]", show_pseudo(insn->target), insn->offset, show_pseudo(insn->src));
+		break;
+	case OP_STORE: case OP_SNOP:
+		buf += sprintf(buf, "%s -> %d[%s]", show_pseudo(insn->target), insn->offset, show_pseudo(insn->src));
+		break;
+	case OP_INLINED_CALL:
+	case OP_CALL: {
+		struct pseudo *arg;
+		if (insn->target && insn->target != VOID)
+			buf += sprintf(buf, "%s <- ", show_pseudo(insn->target));
+		buf += sprintf(buf, "%s", show_pseudo(insn->func));
+		FOR_EACH_PTR(insn->arguments, arg) {
+			buf += sprintf(buf, ", %s", show_pseudo(arg));
+		} END_FOR_EACH_PTR(arg);
+		break;
+	}
+	case OP_CAST:
+	case OP_SCAST:
+	case OP_FPCAST:
+	case OP_PTRCAST:
+		buf += sprintf(buf, "%s <- (%d) %s",
+			show_pseudo(insn->target),
+			type_size(insn->orig_type),
+			show_pseudo(insn->src));
+		break;
+	case OP_BINARY ... OP_BINARY_END:
+	case OP_BINCMP ... OP_BINCMP_END:
+		buf += sprintf(buf, "%s <- %s, %s", show_pseudo(insn->target), show_pseudo(insn->src1), show_pseudo(insn->src2));
+		break;
+
+	case OP_SEL:
+		buf += sprintf(buf, "%s <- %s, %s, %s", show_pseudo(insn->target),
+			show_pseudo(insn->src1), show_pseudo(insn->src2), show_pseudo(insn->src3));
+		break;
+
+	case OP_SLICE:
+		buf += sprintf(buf, "%s <- %s, %d, %d", show_pseudo(insn->target), show_pseudo(insn->base), insn->from, insn->len);
+		break;
+
+	case OP_NOT: case OP_NEG:
+		buf += sprintf(buf, "%s <- %s", show_pseudo(insn->target), show_pseudo(insn->src1));
+		break;
+
+	case OP_CONTEXT:
+		buf += sprintf(buf, "%s%d", insn->check ? "check: " : "", insn->increment);
+		break;
+	case OP_RANGE:
+		buf += sprintf(buf, "%s between %s..%s", show_pseudo(insn->src1), show_pseudo(insn->src2), show_pseudo(insn->src3));
+		break;
+	case OP_NOP:
+		buf += sprintf(buf, "%s <- %s", show_pseudo(insn->target), show_pseudo(insn->src1));
+		break;
+	case OP_DEATHNOTE:
+		buf += sprintf(buf, "%s", show_pseudo(insn->target));
+		break;
+	case OP_ASM:
+		buf = show_asm(buf, insn);
+		break;
+	case OP_COPY:
+		buf += sprintf(buf, "%s <- %s", show_pseudo(insn->target), show_pseudo(insn->src));
+		break;
+	default:
+		break;
+	}
+
+	if (buf >= buffer + sizeof(buffer))
+		die("instruction buffer overflowed %td\n", buf - buffer);
+	do { --buf; } while (*buf == ' ');
+	*++buf = 0;
+	return buffer;
+}
+
+void show_bb(struct basic_block *bb)
+{
+	struct instruction *insn;
+
+	printf(".L%u:\n", bb->nr);
+	if (verbose) {
+		pseudo_t needs, defines;
+		printf("%s:%d\n", stream_name(bb->pos.stream), bb->pos.line);
+
+		FOR_EACH_PTR(bb->needs, needs) {
+			struct instruction *def = needs->def;
+			if (def->opcode != OP_PHI) {
+				printf("  **uses %s (from .L%u)**\n", show_pseudo(needs), def->bb->nr);
+			} else {
+				pseudo_t phi;
+				const char *sep = " ";
+				printf("  **uses %s (from", show_pseudo(needs));
+				FOR_EACH_PTR(def->phi_list, phi) {
+					if (phi == VOID)
+						continue;
+					printf("%s(%s:.L%u)", sep, show_pseudo(phi), phi->def->bb->nr);
+					sep = ", ";
+				} END_FOR_EACH_PTR(phi);		
+				printf(")**\n");
+			}
+		} END_FOR_EACH_PTR(needs);
+
+		FOR_EACH_PTR(bb->defines, defines) {
+			printf("  **defines %s **\n", show_pseudo(defines));
+		} END_FOR_EACH_PTR(defines);
+
+		if (bb->parents) {
+			struct basic_block *from;
+			FOR_EACH_PTR(bb->parents, from) {
+				printf("  **from .L%u (%s:%d:%d)**\n", from->nr,
+					stream_name(from->pos.stream), from->pos.line, from->pos.pos);
+			} END_FOR_EACH_PTR(from);
+		}
+
+		if (bb->children) {
+			struct basic_block *to;
+			FOR_EACH_PTR(bb->children, to) {
+				printf("  **to .L%u (%s:%d:%d)**\n", to->nr,
+					stream_name(to->pos.stream), to->pos.line, to->pos.pos);
+			} END_FOR_EACH_PTR(to);
+		}
+	}
+
+	FOR_EACH_PTR(bb->insns, insn) {
+		if (!insn->bb && verbose < 2)
+			continue;
+		printf("\t%s\n", show_instruction(insn));
+	} END_FOR_EACH_PTR(insn);
+	if (!bb_terminated(bb))
+		printf("\tEND\n");
+}
+
+static void show_symbol_usage(pseudo_t pseudo)
+{
+	struct pseudo_user *pu;
+
+	if (pseudo) {
+		FOR_EACH_PTR(pseudo->users, pu) {
+			printf("\t%s\n", show_instruction(pu->insn));
+		} END_FOR_EACH_PTR(pu);
+	}
+}
+
+void show_entry(struct entrypoint *ep)
+{
+	struct symbol *sym;
+	struct basic_block *bb;
+
+	printf("%s:\n", show_ident(ep->name->ident));
+
+	if (verbose) {
+		printf("ep %p: %s\n", ep, show_ident(ep->name->ident));
+
+		FOR_EACH_PTR(ep->syms, sym) {
+			if (!sym->pseudo)
+				continue;
+			if (!sym->pseudo->users)
+				continue;
+			printf("   sym: %p %s\n", sym, show_ident(sym->ident));
+			if (sym->ctype.modifiers & (MOD_EXTERN | MOD_STATIC | MOD_ADDRESSABLE))
+				printf("\texternal visibility\n");
+			show_symbol_usage(sym->pseudo);
+		} END_FOR_EACH_PTR(sym);
+
+		printf("\n");
+	}
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		if (!bb)
+			continue;
+		if (!bb->parents && !bb->children && !bb->insns && verbose < 2)
+			continue;
+		show_bb(bb);
+		printf("\n");
+	} END_FOR_EACH_PTR(bb);
+
+	printf("\n");
+}
+
+static void bind_label(struct symbol *label, struct basic_block *bb, struct position pos)
+{
+	if (label->bb_target)
+		warning(pos, "label '%s' already bound", show_ident(label->ident));
+	label->bb_target = bb;
+}
+
+static struct basic_block * get_bound_block(struct entrypoint *ep, struct symbol *label)
+{
+	struct basic_block *bb = label->bb_target;
+
+	if (!bb) {
+		bb = alloc_basic_block(ep, label->pos);
+		label->bb_target = bb;
+	}
+	return bb;
+}
+
+static void finish_block(struct entrypoint *ep)
+{
+	struct basic_block *src = ep->active;
+	if (bb_reachable(src))
+		ep->active = NULL;
+}
+
+static void add_goto(struct entrypoint *ep, struct basic_block *dst)
+{
+	struct basic_block *src = ep->active;
+	if (bb_reachable(src)) {
+		struct instruction *br = alloc_instruction(OP_BR, 0);
+		br->bb_true = dst;
+		add_bb(&dst->parents, src);
+		add_bb(&src->children, dst);
+		br->bb = src;
+		add_instruction(&src->insns, br);
+		ep->active = NULL;
+	}
+}
+
+static void add_one_insn(struct entrypoint *ep, struct instruction *insn)
+{
+	struct basic_block *bb = ep->active;    
+
+	if (bb_reachable(bb)) {
+		insn->bb = bb;
+		add_instruction(&bb->insns, insn);
+	}
+}
+
+static void set_activeblock(struct entrypoint *ep, struct basic_block *bb)
+{
+	if (!bb_terminated(ep->active))
+		add_goto(ep, bb);
+
+	ep->active = bb;
+	if (bb_reachable(bb))
+		add_bb(&ep->bbs, bb);
+}
+
+static void remove_parent(struct basic_block *child, struct basic_block *parent)
+{
+	remove_bb_from_list(&child->parents, parent, 1);
+	if (!child->parents)
+		repeat_phase |= REPEAT_CFG_CLEANUP;
+}
+
+/* Change a "switch" or a conditional branch into a branch */
+void insert_branch(struct basic_block *bb, struct instruction *jmp, struct basic_block *target)
+{
+	struct instruction *br, *old;
+	struct basic_block *child;
+
+	/* Remove the switch */
+	old = delete_last_instruction(&bb->insns);
+	assert(old == jmp);
+	kill_instruction(old);
+
+	br = alloc_instruction(OP_BR, 0);
+	br->bb = bb;
+	br->bb_true = target;
+	add_instruction(&bb->insns, br);
+
+	FOR_EACH_PTR(bb->children, child) {
+		if (child == target) {
+			target = NULL;	/* Trigger just once */
+			continue;
+		}
+		DELETE_CURRENT_PTR(child);
+		remove_parent(child, bb);
+	} END_FOR_EACH_PTR(child);
+	PACK_PTR_LIST(&bb->children);
+}
+	
+
+void insert_select(struct basic_block *bb, struct instruction *br, struct instruction *phi_node, pseudo_t if_true, pseudo_t if_false)
+{
+	pseudo_t target;
+	struct instruction *select;
+
+	/* Remove the 'br' */
+	delete_last_instruction(&bb->insns);
+
+	select = alloc_instruction(OP_SEL, phi_node->size);
+	select->bb = bb;
+
+	assert(br->cond);
+	use_pseudo(select, br->cond, &select->src1);
+
+	target = phi_node->target;
+	assert(target->def == phi_node);
+	select->target = target;
+	target->def = select;
+
+	use_pseudo(select, if_true, &select->src2);
+	use_pseudo(select, if_false, &select->src3);
+
+	add_instruction(&bb->insns, select);
+	add_instruction(&bb->insns, br);
+}
+
+static inline int bb_empty(struct basic_block *bb)
+{
+	return !bb->insns;
+}
+
+/* Add a label to the currently active block, return new active block */
+static struct basic_block * add_label(struct entrypoint *ep, struct symbol *label)
+{
+	struct basic_block *bb = label->bb_target;
+
+	if (bb) {
+		set_activeblock(ep, bb);
+		return bb;
+	}
+	bb = ep->active;
+	if (!bb_reachable(bb) || !bb_empty(bb)) {
+		bb = alloc_basic_block(ep, label->pos);
+		set_activeblock(ep, bb);
+	}
+	label->bb_target = bb;
+	return bb;
+}
+
+static void add_branch(struct entrypoint *ep, struct expression *expr, pseudo_t cond, struct basic_block *bb_true, struct basic_block *bb_false)
+{
+	struct basic_block *bb = ep->active;
+	struct instruction *br;
+
+	if (bb_reachable(bb)) {
+		br = alloc_instruction(OP_CBR, 0);
+		use_pseudo(br, cond, &br->cond);
+		br->bb_true = bb_true;
+		br->bb_false = bb_false;
+		add_bb(&bb_true->parents, bb);
+		add_bb(&bb_false->parents, bb);
+		add_bb(&bb->children, bb_true);
+		add_bb(&bb->children, bb_false);
+		add_one_insn(ep, br);
+	}
+}
+
+/* Dummy pseudo allocator */
+pseudo_t alloc_pseudo(struct instruction *def)
+{
+	static int nr = 0;
+	struct pseudo * pseudo = __alloc_pseudo(0);
+	pseudo->type = PSEUDO_REG;
+	pseudo->nr = ++nr;
+	pseudo->def = def;
+	return pseudo;
+}
+
+static void clear_symbol_pseudos(struct entrypoint *ep)
+{
+	pseudo_t pseudo;
+
+	FOR_EACH_PTR(ep->accesses, pseudo) {
+		pseudo->sym->pseudo = NULL;
+	} END_FOR_EACH_PTR(pseudo);
+}
+
+static pseudo_t symbol_pseudo(struct entrypoint *ep, struct symbol *sym)
+{
+	pseudo_t pseudo;
+
+	if (!sym)
+		return VOID;
+
+	pseudo = sym->pseudo;
+	if (!pseudo) {
+		pseudo = __alloc_pseudo(0);
+		pseudo->nr = -1;
+		pseudo->type = PSEUDO_SYM;
+		pseudo->sym = sym;
+		pseudo->ident = sym->ident;
+		sym->pseudo = pseudo;
+		add_pseudo(&ep->accesses, pseudo);
+	}
+	/* Symbol pseudos have neither nr, usage nor def */
+	return pseudo;
+}
+
+pseudo_t value_pseudo(struct symbol *type, long long val)
+{
+#define MAX_VAL_HASH 64
+	static struct pseudo_list *prev[MAX_VAL_HASH];
+	int hash = val & (MAX_VAL_HASH-1);
+	struct pseudo_list **list = prev + hash;
+	int size = type ? type->bit_size : value_size(val);
+	pseudo_t pseudo;
+
+
+	FOR_EACH_PTR(*list, pseudo) {
+		if (pseudo->value == val && pseudo->size == size)
+			return pseudo;
+	} END_FOR_EACH_PTR(pseudo);
+
+	pseudo = __alloc_pseudo(0);
+	pseudo->type = PSEUDO_VAL;
+	pseudo->value = val;
+	pseudo->size = size;
+	add_pseudo(list, pseudo);
+
+	/* Value pseudos have neither nr, usage nor def */
+	return pseudo;
+}
+
+static pseudo_t argument_pseudo(struct entrypoint *ep, int nr)
+{
+	pseudo_t pseudo = __alloc_pseudo(0);
+	struct instruction *entry = ep->entry;
+
+	pseudo->type = PSEUDO_ARG;
+	pseudo->nr = nr;
+	pseudo->def = entry;
+	add_pseudo(&entry->arg_list, pseudo);
+
+	/* Argument pseudos have neither usage nor def */
+	return pseudo;
+}
+
+pseudo_t alloc_phi(struct basic_block *source, pseudo_t pseudo, int size)
+{
+	struct instruction *insn;
+	pseudo_t phi;
+	static int nr = 0;
+
+	if (!source)
+		return VOID;
+
+	insn = alloc_instruction(OP_PHISOURCE, size);
+	phi = __alloc_pseudo(0);
+	phi->type = PSEUDO_PHI;
+	phi->nr = ++nr;
+	phi->def = insn;
+
+	use_pseudo(insn, pseudo, &insn->phi_src);
+	insn->bb = source;
+	insn->target = phi;
+	add_instruction(&source->insns, insn);
+	return phi;
+}
+
+/*
+ * We carry the "access_data" structure around for any accesses,
+ * which simplifies things a lot. It contains all the access
+ * information in one place.
+ */
+struct access_data {
+	struct symbol *result_type;	// result ctype
+	struct symbol *source_type;	// source ctype
+	pseudo_t address;		// pseudo containing address ..
+	unsigned int offset;		// byte offset
+	struct position pos;
+};
+
+static void finish_address_gen(struct entrypoint *ep, struct access_data *ad)
+{
+}
+
+static int linearize_simple_address(struct entrypoint *ep,
+	struct expression *addr,
+	struct access_data *ad)
+{
+	if (addr->type == EXPR_SYMBOL) {
+		linearize_one_symbol(ep, addr->symbol);
+		ad->address = symbol_pseudo(ep, addr->symbol);
+		return 1;
+	}
+	if (addr->type == EXPR_BINOP) {
+		if (addr->right->type == EXPR_VALUE) {
+			if (addr->op == '+') {
+				ad->offset += get_expression_value(addr->right);
+				return linearize_simple_address(ep, addr->left, ad);
+			}
+		}
+	}
+	ad->address = linearize_expression(ep, addr);
+	return 1;
+}
+
+static struct symbol *base_type(struct symbol *sym)
+{
+	struct symbol *base = sym;
+
+	if (sym) {
+		if (sym->type == SYM_NODE)
+			base = base->ctype.base_type;
+		if (base->type == SYM_BITFIELD)
+			return base->ctype.base_type;
+	}
+	return sym;
+}
+
+static int linearize_address_gen(struct entrypoint *ep,
+	struct expression *expr,
+	struct access_data *ad)
+{
+	struct symbol *ctype = expr->ctype;
+
+	if (!ctype)
+		return 0;
+	ad->pos = expr->pos;
+	ad->result_type = ctype;
+	ad->source_type = base_type(ctype);
+	if (expr->type == EXPR_PREOP && expr->op == '*')
+		return linearize_simple_address(ep, expr->unop, ad);
+
+	warning(expr->pos, "generating address of non-lvalue (%d)", expr->type);
+	return 0;
+}
+
+static pseudo_t add_load(struct entrypoint *ep, struct access_data *ad)
+{
+	struct instruction *insn;
+	pseudo_t new;
+
+	insn = alloc_typed_instruction(OP_LOAD, ad->source_type);
+	new = alloc_pseudo(insn);
+
+	insn->target = new;
+	insn->offset = ad->offset;
+	use_pseudo(insn, ad->address, &insn->src);
+	add_one_insn(ep, insn);
+	return new;
+}
+
+static void add_store(struct entrypoint *ep, struct access_data *ad, pseudo_t value)
+{
+	struct basic_block *bb = ep->active;
+
+	if (bb_reachable(bb)) {
+		struct instruction *store = alloc_typed_instruction(OP_STORE, ad->source_type);
+		store->offset = ad->offset;
+		use_pseudo(store, value, &store->target);
+		use_pseudo(store, ad->address, &store->src);
+		add_one_insn(ep, store);
+	}
+}
+
+static pseudo_t linearize_store_gen(struct entrypoint *ep,
+		pseudo_t value,
+		struct access_data *ad)
+{
+	pseudo_t store = value;
+
+	if (type_size(ad->source_type) != type_size(ad->result_type)) {
+		struct symbol *ctype = ad->result_type;
+		unsigned int shift = ctype->bit_offset;
+		unsigned int size = ctype->bit_size;
+		pseudo_t orig = add_load(ep, ad);
+		unsigned long long mask = (1ULL << size) - 1;
+
+		if (shift) {
+			store = add_binary_op(ep, ad->source_type, OP_SHL, value, value_pseudo(ctype, shift));
+			mask <<= shift;
+		}
+		orig = add_binary_op(ep, ad->source_type, OP_AND, orig, value_pseudo(ctype, ~mask));
+		store = add_binary_op(ep, ad->source_type, OP_OR, orig, store);
+	}
+	add_store(ep, ad, store);
+	return value;
+}
+
+static pseudo_t add_binary_op(struct entrypoint *ep, struct symbol *ctype, int op, pseudo_t left, pseudo_t right)
+{
+	struct instruction *insn = alloc_typed_instruction(op, ctype);
+	pseudo_t target = alloc_pseudo(insn);
+	insn->target = target;
+	use_pseudo(insn, left, &insn->src1);
+	use_pseudo(insn, right, &insn->src2);
+	add_one_insn(ep, insn);
+	return target;
+}
+
+static pseudo_t add_setval(struct entrypoint *ep, struct symbol *ctype, struct expression *val)
+{
+	struct instruction *insn = alloc_typed_instruction(OP_SETVAL, ctype);
+	pseudo_t target = alloc_pseudo(insn);
+	insn->target = target;
+	insn->val = val;
+	add_one_insn(ep, insn);
+	return target;
+}
+
+static pseudo_t add_symbol_address(struct entrypoint *ep, struct symbol *sym)
+{
+	struct instruction *insn = alloc_instruction(OP_SYMADDR, bits_in_pointer);
+	pseudo_t target = alloc_pseudo(insn);
+
+	insn->target = target;
+	use_pseudo(insn, symbol_pseudo(ep, sym), &insn->symbol);
+	add_one_insn(ep, insn);
+	return target;
+}
+
+static pseudo_t linearize_load_gen(struct entrypoint *ep, struct access_data *ad)
+{
+	struct symbol *ctype = ad->result_type;
+	pseudo_t new = add_load(ep, ad);
+
+	if (ctype->bit_offset) {
+		pseudo_t shift = value_pseudo(ctype, ctype->bit_offset);
+		pseudo_t newval = add_binary_op(ep, ad->source_type, OP_LSR, new, shift);
+		new = newval;
+	}
+	if (ctype->bit_size != type_size(ad->source_type))
+		new = cast_pseudo(ep, new, ad->source_type, ad->result_type);
+	return new;
+}
+
+static pseudo_t linearize_access(struct entrypoint *ep, struct expression *expr)
+{
+	struct access_data ad = { NULL, };
+	pseudo_t value;
+
+	if (!linearize_address_gen(ep, expr, &ad))
+		return VOID;
+	value = linearize_load_gen(ep, &ad);
+	finish_address_gen(ep, &ad);
+	return value;
+}
+
+/* FIXME: FP */
+static pseudo_t linearize_inc_dec(struct entrypoint *ep, struct expression *expr, int postop)
+{
+	struct access_data ad = { NULL, };
+		pseudo_t old, new, one;
+	int op = expr->op == SPECIAL_INCREMENT ? OP_ADD : OP_SUB;
+
+	if (!linearize_address_gen(ep, expr->unop, &ad))
+		return VOID;
+
+	old = linearize_load_gen(ep, &ad);
+	one = value_pseudo(expr->ctype, expr->op_value);
+	new = add_binary_op(ep, expr->ctype, op, old, one);
+	linearize_store_gen(ep, new, &ad);
+	finish_address_gen(ep, &ad);
+	return postop ? old : new;
+}
+
+static pseudo_t add_uniop(struct entrypoint *ep, struct expression *expr, int op, pseudo_t src)
+{
+	struct instruction *insn = alloc_typed_instruction(op, expr->ctype);
+	pseudo_t new = alloc_pseudo(insn);
+
+	insn->target = new;
+	use_pseudo(insn, src, &insn->src1);
+	add_one_insn(ep, insn);
+	return new;
+}
+
+static pseudo_t linearize_slice(struct entrypoint *ep, struct expression *expr)
+{
+	pseudo_t pre = linearize_expression(ep, expr->base);
+	struct instruction *insn = alloc_typed_instruction(OP_SLICE, expr->ctype);
+	pseudo_t new = alloc_pseudo(insn);
+
+	insn->target = new;
+	insn->from = expr->r_bitpos;
+	insn->len = expr->r_nrbits;
+	use_pseudo(insn, pre, &insn->base);
+	add_one_insn(ep, insn);
+	return new;
+}
+
+static pseudo_t linearize_regular_preop(struct entrypoint *ep, struct expression *expr)
+{
+	pseudo_t pre = linearize_expression(ep, expr->unop);
+	switch (expr->op) {
+	case '+':
+		return pre;
+	case '!': {
+		pseudo_t zero = value_pseudo(expr->ctype, 0);
+		return add_binary_op(ep, expr->ctype, OP_SET_EQ, pre, zero);
+	}
+	case '~':
+		return add_uniop(ep, expr, OP_NOT, pre);
+	case '-':
+		return add_uniop(ep, expr, OP_NEG, pre);
+	}
+	return VOID;
+}
+
+static pseudo_t linearize_preop(struct entrypoint *ep, struct expression *expr)
+{
+	/*
+	 * '*' is an lvalue access, and is fundamentally different
+	 * from an arithmetic operation. Maybe it should have an
+	 * expression type of its own..
+	 */
+	if (expr->op == '*')
+		return linearize_access(ep, expr);
+	if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
+		return linearize_inc_dec(ep, expr, 0);
+	return linearize_regular_preop(ep, expr);
+}
+
+static pseudo_t linearize_postop(struct entrypoint *ep, struct expression *expr)
+{
+	return linearize_inc_dec(ep, expr, 1);
+}	
+
+/*
+ * Casts to pointers are "less safe" than other casts, since
+ * they imply type-unsafe accesses. "void *" is a special
+ * case, since you can't access through it anyway without another
+ * cast.
+ */
+static struct instruction *alloc_cast_instruction(struct symbol *src, struct symbol *ctype)
+{
+	int opcode = OP_CAST;
+	struct symbol *base = ctype;
+
+	if (src->ctype.modifiers & MOD_SIGNED)
+		opcode = OP_SCAST;
+	if (base->type == SYM_NODE)
+		base = base->ctype.base_type;
+	if (base->type == SYM_PTR) {
+		base = base->ctype.base_type;
+		if (base != &void_ctype)
+			opcode = OP_PTRCAST;
+	} else if (base->ctype.base_type == &fp_type)
+		opcode = OP_FPCAST;
+	return alloc_typed_instruction(opcode, ctype);
+}
+
+static pseudo_t cast_pseudo(struct entrypoint *ep, pseudo_t src, struct symbol *from, struct symbol *to)
+{
+	pseudo_t result;
+	struct instruction *insn;
+
+	if (src == VOID)
+		return VOID;
+	if (!from || !to)
+		return VOID;
+	if (from->bit_size < 0 || to->bit_size < 0)
+		return VOID;
+	insn = alloc_cast_instruction(from, to);
+	result = alloc_pseudo(insn);
+	insn->target = result;
+	insn->orig_type = from;
+	use_pseudo(insn, src, &insn->src);
+	add_one_insn(ep, insn);
+	return result;
+}
+
+static int opcode_sign(int opcode, struct symbol *ctype)
+{
+	if (ctype && (ctype->ctype.modifiers & MOD_SIGNED)) {
+		switch(opcode) {
+		case OP_MULU: case OP_DIVU: case OP_MODU: case OP_LSR:
+			opcode++;
+		}
+	}
+	return opcode;
+}
+
+static inline pseudo_t add_convert_to_bool(struct entrypoint *ep, pseudo_t src, struct symbol *type)
+{
+	pseudo_t zero;
+	int op;
+
+	if (is_bool_type(type))
+		return src;
+	zero = value_pseudo(type, 0);
+	op = OP_SET_NE;
+	return add_binary_op(ep, &bool_ctype, op, src, zero);
+}
+
+static pseudo_t linearize_expression_to_bool(struct entrypoint *ep, struct expression *expr)
+{
+	pseudo_t dst;
+	dst = linearize_expression(ep, expr);
+	dst = add_convert_to_bool(ep, dst, expr->ctype);
+	return dst;
+}
+
+static pseudo_t linearize_assignment(struct entrypoint *ep, struct expression *expr)
+{
+	struct access_data ad = { NULL, };
+	struct expression *target = expr->left;
+	struct expression *src = expr->right;
+	struct symbol *ctype;
+	pseudo_t value;
+
+	value = linearize_expression(ep, src);
+	if (!target || !linearize_address_gen(ep, target, &ad))
+		return value;
+	if (expr->op != '=') {
+		pseudo_t oldvalue = linearize_load_gen(ep, &ad);
+		pseudo_t dst;
+		static const int op_trans[] = {
+			[SPECIAL_ADD_ASSIGN - SPECIAL_BASE] = OP_ADD,
+			[SPECIAL_SUB_ASSIGN - SPECIAL_BASE] = OP_SUB,
+			[SPECIAL_MUL_ASSIGN - SPECIAL_BASE] = OP_MULU,
+			[SPECIAL_DIV_ASSIGN - SPECIAL_BASE] = OP_DIVU,
+			[SPECIAL_MOD_ASSIGN - SPECIAL_BASE] = OP_MODU,
+			[SPECIAL_SHL_ASSIGN - SPECIAL_BASE] = OP_SHL,
+			[SPECIAL_SHR_ASSIGN - SPECIAL_BASE] = OP_LSR,
+			[SPECIAL_AND_ASSIGN - SPECIAL_BASE] = OP_AND,
+			[SPECIAL_OR_ASSIGN  - SPECIAL_BASE] = OP_OR,
+			[SPECIAL_XOR_ASSIGN - SPECIAL_BASE] = OP_XOR
+		};
+		int opcode;
+
+		if (!src)
+			return VOID;
+
+		ctype = src->ctype;
+		oldvalue = cast_pseudo(ep, oldvalue, target->ctype, ctype);
+		opcode = opcode_sign(op_trans[expr->op - SPECIAL_BASE], ctype);
+		dst = add_binary_op(ep, ctype, opcode, oldvalue, value);
+		value = cast_pseudo(ep, dst, ctype, expr->ctype);
+	}
+	value = linearize_store_gen(ep, value, &ad);
+	finish_address_gen(ep, &ad);
+	return value;
+}
+
+static pseudo_t linearize_call_expression(struct entrypoint *ep, struct expression *expr)
+{
+	struct expression *arg, *fn;
+	struct instruction *insn = alloc_typed_instruction(OP_CALL, expr->ctype);
+	pseudo_t retval, call;
+	struct ctype *ctype = NULL;
+	struct symbol *fntype;
+	struct context *context;
+
+	if (!expr->ctype) {
+		warning(expr->pos, "call with no type!");
+		return VOID;
+	}
+
+	FOR_EACH_PTR(expr->args, arg) {
+		pseudo_t new = linearize_expression(ep, arg);
+		use_pseudo(insn, new, add_pseudo(&insn->arguments, new));
+	} END_FOR_EACH_PTR(arg);
+
+	fn = expr->fn;
+
+	if (fn->ctype)
+		ctype = &fn->ctype->ctype;
+
+	fntype = fn->ctype;
+	if (fntype) {
+		if (fntype->type == SYM_NODE)
+			fntype = fntype->ctype.base_type;
+	}
+	insn->fntype = fntype;
+
+	if (fn->type == EXPR_PREOP) {
+		if (fn->unop->type == EXPR_SYMBOL) {
+			struct symbol *sym = fn->unop->symbol;
+			if (sym->ctype.base_type->type == SYM_FN)
+				fn = fn->unop;
+		}
+	}
+	if (fn->type == EXPR_SYMBOL) {
+		call = symbol_pseudo(ep, fn->symbol);
+	} else {
+		call = linearize_expression(ep, fn);
+	}
+	use_pseudo(insn, call, &insn->func);
+	retval = VOID;
+	if (expr->ctype != &void_ctype)
+		retval = alloc_pseudo(insn);
+	insn->target = retval;
+	add_one_insn(ep, insn);
+
+	if (ctype) {
+		FOR_EACH_PTR(ctype->contexts, context) {
+			int in = context->in;
+			int out = context->out;
+			int check = 0;
+			int context_diff;
+			if (in < 0) {
+				check = 1;
+				in = 0;
+			}
+			if (out < 0) {
+				check = 0;
+				out = 0;
+			}
+			context_diff = out - in;
+			if (check || context_diff) {
+				insn = alloc_instruction(OP_CONTEXT, 0);
+				insn->increment = context_diff;
+				insn->check = check;
+				insn->context_expr = context->context;
+				add_one_insn(ep, insn);
+			}
+		} END_FOR_EACH_PTR(context);
+	}
+
+	return retval;
+}
+
+static pseudo_t linearize_binop_bool(struct entrypoint *ep, struct expression *expr)
+{
+	pseudo_t src1, src2, dst;
+	int op = (expr->op == SPECIAL_LOGICAL_OR) ? OP_OR_BOOL : OP_AND_BOOL;
+
+	src1 = linearize_expression_to_bool(ep, expr->left);
+	src2 = linearize_expression_to_bool(ep, expr->right);
+	dst = add_binary_op(ep, &bool_ctype, op, src1, src2);
+	if (expr->ctype != &bool_ctype)
+		dst = cast_pseudo(ep, dst, &bool_ctype, expr->ctype);
+	return dst;
+}
+
+static pseudo_t linearize_binop(struct entrypoint *ep, struct expression *expr)
+{
+	pseudo_t src1, src2, dst;
+	static const int opcode[] = {
+		['+'] = OP_ADD, ['-'] = OP_SUB,
+		['*'] = OP_MULU, ['/'] = OP_DIVU,
+		['%'] = OP_MODU, ['&'] = OP_AND,
+		['|'] = OP_OR,  ['^'] = OP_XOR,
+		[SPECIAL_LEFTSHIFT] = OP_SHL,
+		[SPECIAL_RIGHTSHIFT] = OP_LSR,
+	};
+	int op;
+
+	src1 = linearize_expression(ep, expr->left);
+	src2 = linearize_expression(ep, expr->right);
+	op = opcode_sign(opcode[expr->op], expr->ctype);
+	dst = add_binary_op(ep, expr->ctype, op, src1, src2);
+	return dst;
+}
+
+static pseudo_t linearize_logical_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false);
+
+pseudo_t linearize_cond_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false);
+
+static pseudo_t linearize_select(struct entrypoint *ep, struct expression *expr)
+{
+	pseudo_t cond, true, false, res;
+	struct instruction *insn;
+
+	true = linearize_expression(ep, expr->cond_true);
+	false = linearize_expression(ep, expr->cond_false);
+	cond = linearize_expression(ep, expr->conditional);
+
+	insn = alloc_typed_instruction(OP_SEL, expr->ctype);
+	if (!expr->cond_true)
+		true = cond;
+	use_pseudo(insn, cond, &insn->src1);
+	use_pseudo(insn, true, &insn->src2);
+	use_pseudo(insn, false, &insn->src3);
+
+	res = alloc_pseudo(insn);
+	insn->target = res;
+	add_one_insn(ep, insn);
+	return res;
+}
+
+static pseudo_t add_join_conditional(struct entrypoint *ep, struct expression *expr,
+				     pseudo_t phi1, pseudo_t phi2)
+{
+	pseudo_t target;
+	struct instruction *phi_node;
+
+	if (phi1 == VOID)
+		return phi2;
+	if (phi2 == VOID)
+		return phi1;
+
+	phi_node = alloc_typed_instruction(OP_PHI, expr->ctype);
+	use_pseudo(phi_node, phi1, add_pseudo(&phi_node->phi_list, phi1));
+	use_pseudo(phi_node, phi2, add_pseudo(&phi_node->phi_list, phi2));
+	phi_node->target = target = alloc_pseudo(phi_node);
+	add_one_insn(ep, phi_node);
+	return target;
+}	
+
+static pseudo_t linearize_short_conditional(struct entrypoint *ep, struct expression *expr,
+					    struct expression *cond,
+					    struct expression *expr_false)
+{
+	pseudo_t src1, src2;
+	struct basic_block *bb_false;
+	struct basic_block *merge = alloc_basic_block(ep, expr->pos);
+	pseudo_t phi1, phi2;
+	int size = type_size(expr->ctype);
+
+	if (!expr_false || !ep->active)
+		return VOID;
+
+	bb_false = alloc_basic_block(ep, expr_false->pos);
+	src1 = linearize_expression(ep, cond);
+	phi1 = alloc_phi(ep->active, src1, size);
+	add_branch(ep, expr, src1, merge, bb_false);
+
+	set_activeblock(ep, bb_false);
+	src2 = linearize_expression(ep, expr_false);
+	phi2 = alloc_phi(ep->active, src2, size);
+	set_activeblock(ep, merge);
+
+	return add_join_conditional(ep, expr, phi1, phi2);
+}
+
+static pseudo_t linearize_conditional(struct entrypoint *ep, struct expression *expr,
+				      struct expression *cond,
+				      struct expression *expr_true,
+				      struct expression *expr_false)
+{
+	pseudo_t src1, src2;
+	pseudo_t phi1, phi2;
+	struct basic_block *bb_true, *bb_false, *merge;
+	int size = type_size(expr->ctype);
+
+	if (!cond || !expr_true || !expr_false || !ep->active)
+		return VOID;
+	bb_true = alloc_basic_block(ep, expr_true->pos);
+	bb_false = alloc_basic_block(ep, expr_false->pos);
+	merge = alloc_basic_block(ep, expr->pos);
+
+	linearize_cond_branch(ep, cond, bb_true, bb_false);
+
+	set_activeblock(ep, bb_true);
+	src1 = linearize_expression(ep, expr_true);
+	phi1 = alloc_phi(ep->active, src1, size);
+	add_goto(ep, merge); 
+
+	set_activeblock(ep, bb_false);
+	src2 = linearize_expression(ep, expr_false);
+	phi2 = alloc_phi(ep->active, src2, size);
+	set_activeblock(ep, merge);
+
+	return add_join_conditional(ep, expr, phi1, phi2);
+}
+
+static pseudo_t linearize_logical(struct entrypoint *ep, struct expression *expr)
+{
+	struct expression *shortcut;
+
+	shortcut = alloc_const_expression(expr->pos, expr->op == SPECIAL_LOGICAL_OR);
+	shortcut->ctype = expr->ctype;
+	if (expr->op == SPECIAL_LOGICAL_OR)
+		return linearize_conditional(ep, expr, expr->left, shortcut, expr->right);
+	return linearize_conditional(ep, expr, expr->left, expr->right, shortcut);
+}
+
+static pseudo_t linearize_compare(struct entrypoint *ep, struct expression *expr)
+{
+	static const int cmpop[] = {
+		['>'] = OP_SET_GT, ['<'] = OP_SET_LT,
+		[SPECIAL_EQUAL] = OP_SET_EQ,
+		[SPECIAL_NOTEQUAL] = OP_SET_NE,
+		[SPECIAL_GTE] = OP_SET_GE,
+		[SPECIAL_LTE] = OP_SET_LE,
+		[SPECIAL_UNSIGNED_LT] = OP_SET_B,
+		[SPECIAL_UNSIGNED_GT] = OP_SET_A,
+		[SPECIAL_UNSIGNED_LTE] = OP_SET_BE,
+		[SPECIAL_UNSIGNED_GTE] = OP_SET_AE,
+	};
+
+	pseudo_t src1 = linearize_expression(ep, expr->left);
+	pseudo_t src2 = linearize_expression(ep, expr->right);
+	pseudo_t dst = add_binary_op(ep, expr->ctype, cmpop[expr->op], src1, src2);
+	return dst;
+}
+
+
+pseudo_t linearize_cond_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false)
+{
+	pseudo_t cond;
+
+	if (!expr || !bb_reachable(ep->active))
+		return VOID;
+
+	switch (expr->type) {
+
+	case EXPR_STRING:
+	case EXPR_VALUE:
+		add_goto(ep, expr->value ? bb_true : bb_false);
+		return VOID;
+
+	case EXPR_FVALUE:
+		add_goto(ep, expr->fvalue ? bb_true : bb_false);
+		return VOID;
+		
+	case EXPR_LOGICAL:
+		linearize_logical_branch(ep, expr, bb_true, bb_false);
+		return VOID;
+
+	case EXPR_COMPARE:
+		cond = linearize_compare(ep, expr);
+		add_branch(ep, expr, cond, bb_true, bb_false);
+		break;
+		
+	case EXPR_PREOP:
+		if (expr->op == '!')
+			return linearize_cond_branch(ep, expr->unop, bb_false, bb_true);
+		/* fall through */
+	default: {
+		cond = linearize_expression(ep, expr);
+		add_branch(ep, expr, cond, bb_true, bb_false);
+
+		return VOID;
+	}
+	}
+	return VOID;
+}
+
+
+	
+static pseudo_t linearize_logical_branch(struct entrypoint *ep, struct expression *expr, struct basic_block *bb_true, struct basic_block *bb_false)
+{
+	struct basic_block *next = alloc_basic_block(ep, expr->pos);
+
+	if (expr->op == SPECIAL_LOGICAL_OR)
+		linearize_cond_branch(ep, expr->left, bb_true, next);
+	else
+		linearize_cond_branch(ep, expr->left, next, bb_false);
+	set_activeblock(ep, next);
+	linearize_cond_branch(ep, expr->right, bb_true, bb_false);
+	return VOID;
+}
+
+static pseudo_t linearize_cast(struct entrypoint *ep, struct expression *expr)
+{
+	pseudo_t src;
+	struct expression *orig = expr->cast_expression;
+
+	if (!orig)
+		return VOID;
+
+	src = linearize_expression(ep, orig);
+	return cast_pseudo(ep, src, orig->ctype, expr->ctype);
+}
+
+static pseudo_t linearize_position(struct entrypoint *ep, struct expression *pos, struct access_data *ad)
+{
+	struct expression *init_expr = pos->init_expr;
+
+	ad->offset = pos->init_offset;
+	ad->source_type = base_type(init_expr->ctype);
+	ad->result_type = init_expr->ctype;
+	return linearize_initializer(ep, init_expr, ad);
+}
+
+static pseudo_t linearize_initializer(struct entrypoint *ep, struct expression *initializer, struct access_data *ad)
+{
+	switch (initializer->type) {
+	case EXPR_INITIALIZER: {
+		struct expression *expr;
+		FOR_EACH_PTR(initializer->expr_list, expr) {
+			linearize_initializer(ep, expr, ad);
+		} END_FOR_EACH_PTR(expr);
+		break;
+	}
+	case EXPR_POS:
+		linearize_position(ep, initializer, ad);
+		break;
+	default: {
+		pseudo_t value = linearize_expression(ep, initializer);
+		ad->source_type = base_type(initializer->ctype);
+		ad->result_type = initializer->ctype;
+		linearize_store_gen(ep, value, ad);
+		return value;
+	}
+	}
+
+	return VOID;
+}
+
+static void linearize_argument(struct entrypoint *ep, struct symbol *arg, int nr)
+{
+	struct access_data ad = { NULL, };
+
+	ad.source_type = arg;
+	ad.result_type = arg;
+	ad.address = symbol_pseudo(ep, arg);
+	linearize_store_gen(ep, argument_pseudo(ep, nr), &ad);
+	finish_address_gen(ep, &ad);
+}
+
+pseudo_t linearize_expression(struct entrypoint *ep, struct expression *expr)
+{
+	if (!expr)
+		return VOID;
+
+	current_pos = expr->pos;
+	switch (expr->type) {
+	case EXPR_SYMBOL:
+		linearize_one_symbol(ep, expr->symbol);
+		return add_symbol_address(ep, expr->symbol);
+
+	case EXPR_VALUE:
+		return value_pseudo(expr->ctype, expr->value);
+
+	case EXPR_STRING: case EXPR_FVALUE: case EXPR_LABEL:
+		return add_setval(ep, expr->ctype, expr);
+
+	case EXPR_STATEMENT:
+		return linearize_statement(ep, expr->statement);
+
+	case EXPR_CALL:
+		return linearize_call_expression(ep, expr);
+
+	case EXPR_BINOP:
+		if (expr->op == SPECIAL_LOGICAL_AND || expr->op == SPECIAL_LOGICAL_OR)
+			return linearize_binop_bool(ep, expr);
+		return linearize_binop(ep, expr);
+
+	case EXPR_LOGICAL:
+		return linearize_logical(ep, expr);
+
+	case EXPR_COMPARE:
+		return  linearize_compare(ep, expr);
+
+	case EXPR_SELECT:
+		return	linearize_select(ep, expr);
+
+	case EXPR_CONDITIONAL:
+		if (!expr->cond_true)
+			return linearize_short_conditional(ep, expr, expr->conditional, expr->cond_false);
+
+		return  linearize_conditional(ep, expr, expr->conditional,
+					      expr->cond_true, expr->cond_false);
+
+	case EXPR_COMMA:
+		linearize_expression(ep, expr->left);
+		return linearize_expression(ep, expr->right);
+
+	case EXPR_ASSIGNMENT:
+		return linearize_assignment(ep, expr);
+
+	case EXPR_PREOP:
+		return linearize_preop(ep, expr);
+
+	case EXPR_POSTOP:
+		return linearize_postop(ep, expr);
+
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+	case EXPR_IMPLIED_CAST:
+		return linearize_cast(ep, expr);
+	
+	case EXPR_SLICE:
+		return linearize_slice(ep, expr);
+
+	case EXPR_INITIALIZER:
+	case EXPR_POS:
+		warning(expr->pos, "unexpected initializer expression (%d %d)", expr->type, expr->op);
+		return VOID;
+	default: 
+		warning(expr->pos, "unknown expression (%d %d)", expr->type, expr->op);
+		return VOID;
+	}
+	return VOID;
+}
+
+static pseudo_t linearize_one_symbol(struct entrypoint *ep, struct symbol *sym)
+{
+	struct access_data ad = { NULL, };
+	pseudo_t value;
+
+	if (!sym || !sym->initializer || sym->initialized)
+		return VOID;
+
+	/* We need to output these puppies some day too.. */
+	if (sym->ctype.modifiers & (MOD_STATIC | MOD_TOPLEVEL))
+		return VOID;
+
+	sym->initialized = 1;
+	ad.address = symbol_pseudo(ep, sym);
+
+	if (sym->initializer && !is_scalar_type(sym)) {
+		// default zero initialization [6.7.9.21]
+		// FIXME: this init the whole aggregate while
+		// only the existing fields need to be initialized.
+		// FIXME: this init the whole aggregate even if
+		// all fields arelater  explicitely initialized.
+		struct expression *expr = sym->initializer;
+		ad.pos = expr->pos;
+		ad.result_type = sym;
+		ad.source_type = base_type(sym);
+		ad.address = symbol_pseudo(ep, sym);
+		linearize_store_gen(ep, value_pseudo(sym, 0), &ad);
+	}
+
+	value = linearize_initializer(ep, sym->initializer, &ad);
+	finish_address_gen(ep, &ad);
+	return value;
+}
+
+static pseudo_t linearize_compound_statement(struct entrypoint *ep, struct statement *stmt)
+{
+	pseudo_t pseudo;
+	struct statement *s;
+	struct symbol *ret = stmt->ret;
+
+	pseudo = VOID;
+	FOR_EACH_PTR(stmt->stmts, s) {
+		pseudo = linearize_statement(ep, s);
+	} END_FOR_EACH_PTR(s);
+
+	if (ret) {
+		struct basic_block *bb = add_label(ep, ret);
+		struct instruction *phi_node = first_instruction(bb->insns);
+
+		if (!phi_node)
+			return pseudo;
+
+		if (pseudo_list_size(phi_node->phi_list)==1) {
+			pseudo = first_pseudo(phi_node->phi_list);
+			assert(pseudo->type == PSEUDO_PHI);
+			return pseudo->def->src1;
+		}
+		return phi_node->target;
+	}
+
+	return pseudo;
+}
+
+static pseudo_t linearize_inlined_call(struct entrypoint *ep, struct statement *stmt)
+{
+	struct instruction *insn = alloc_instruction(OP_INLINED_CALL, 0);
+	struct statement *args = stmt->args;
+	struct basic_block *bb;
+	pseudo_t pseudo;
+
+	if (args) {
+		struct symbol *sym;
+
+		concat_symbol_list(args->declaration, &ep->syms);
+		FOR_EACH_PTR(args->declaration, sym) {
+			pseudo_t value = linearize_one_symbol(ep, sym);
+			use_pseudo(insn, value, add_pseudo(&insn->arguments, value));
+		} END_FOR_EACH_PTR(sym);
+	}
+
+	insn->target = pseudo = linearize_compound_statement(ep, stmt);
+	use_pseudo(insn, symbol_pseudo(ep, stmt->inline_fn), &insn->func);
+	bb = ep->active;
+	if (bb && !bb->insns)
+		bb->pos = stmt->pos;
+	add_one_insn(ep, insn);
+	return pseudo;
+}
+
+static pseudo_t linearize_context(struct entrypoint *ep, struct statement *stmt)
+{
+	struct instruction *insn = alloc_instruction(OP_CONTEXT, 0);
+	struct expression *expr = stmt->expression;
+	int value = 0;
+
+	if (expr->type == EXPR_VALUE)
+		value = expr->value;
+
+	insn->increment = value;
+	insn->context_expr = stmt->context;
+	add_one_insn(ep, insn);
+	return VOID;
+}
+
+static pseudo_t linearize_range(struct entrypoint *ep, struct statement *stmt)
+{
+	struct instruction *insn = alloc_instruction(OP_RANGE, 0);
+
+	use_pseudo(insn, linearize_expression(ep, stmt->range_expression), &insn->src1);
+	use_pseudo(insn, linearize_expression(ep, stmt->range_low), &insn->src2);
+	use_pseudo(insn, linearize_expression(ep, stmt->range_high), &insn->src3);
+	add_one_insn(ep, insn);
+	return VOID;
+}
+
+ALLOCATOR(asm_rules, "asm rules");
+ALLOCATOR(asm_constraint, "asm constraints");
+
+static void add_asm_input(struct entrypoint *ep, struct instruction *insn, struct expression *expr,
+	const char *constraint, const struct ident *ident)
+{
+	pseudo_t pseudo = linearize_expression(ep, expr);
+	struct asm_constraint *rule = __alloc_asm_constraint(0);
+
+	rule->ident = ident;
+	rule->constraint = constraint;
+	use_pseudo(insn, pseudo, &rule->pseudo);
+	add_ptr_list(&insn->asm_rules->inputs, rule);
+}
+
+static void add_asm_output(struct entrypoint *ep, struct instruction *insn, struct expression *expr,
+	const char *constraint, const struct ident *ident)
+{
+	struct access_data ad = { NULL, };
+	pseudo_t pseudo = alloc_pseudo(insn);
+	struct asm_constraint *rule;
+
+	if (!expr || !linearize_address_gen(ep, expr, &ad))
+		return;
+	linearize_store_gen(ep, pseudo, &ad);
+	finish_address_gen(ep, &ad);
+	rule = __alloc_asm_constraint(0);
+	rule->ident = ident;
+	rule->constraint = constraint;
+	use_pseudo(insn, pseudo, &rule->pseudo);
+	add_ptr_list(&insn->asm_rules->outputs, rule);
+}
+
+static pseudo_t linearize_asm_statement(struct entrypoint *ep, struct statement *stmt)
+{
+	int state;
+	struct expression *expr;
+	struct instruction *insn;
+	struct asm_rules *rules;
+	const char *constraint;
+	struct ident *ident;
+
+	insn = alloc_instruction(OP_ASM, 0);
+	expr = stmt->asm_string;
+	if (!expr || expr->type != EXPR_STRING) {
+		warning(stmt->pos, "expected string in inline asm");
+		return VOID;
+	}
+	insn->string = expr->string->data;
+
+	rules = __alloc_asm_rules(0);
+	insn->asm_rules = rules;
+
+	/* Gather the inputs.. */
+	state = 0;
+	ident = NULL;
+	constraint = NULL;
+	FOR_EACH_PTR(stmt->asm_inputs, expr) {
+		switch (state) {
+		case 0:	/* Identifier */
+			state = 1;
+			ident = (struct ident *)expr;
+			continue;
+
+		case 1:	/* Constraint */
+			state = 2;
+			constraint = expr ? expr->string->data : "";
+			continue;
+
+		case 2:	/* Expression */
+			state = 0;
+			add_asm_input(ep, insn, expr, constraint, ident);
+		}
+	} END_FOR_EACH_PTR(expr);
+
+	add_one_insn(ep, insn);
+
+	/* Assign the outputs */
+	state = 0;
+	ident = NULL;
+	constraint = NULL;
+	FOR_EACH_PTR(stmt->asm_outputs, expr) {
+		switch (state) {
+		case 0:	/* Identifier */
+			state = 1;
+			ident = (struct ident *)expr;
+			continue;
+
+		case 1:	/* Constraint */
+			state = 2;
+			constraint = expr ? expr->string->data : "";
+			continue;
+
+		case 2:
+			state = 0;
+			add_asm_output(ep, insn, expr, constraint, ident);
+		}
+	} END_FOR_EACH_PTR(expr);
+
+	return VOID;
+}
+
+static int multijmp_cmp(const void *_a, const void *_b)
+{
+	const struct multijmp *a = _a;
+	const struct multijmp *b = _b;
+
+	// "default" case?
+	if (a->begin > a->end) {
+		if (b->begin > b->end)
+			return 0;
+		return 1;
+	}
+	if (b->begin > b->end)
+		return -1;
+	if (a->begin == b->begin) {
+		if (a->end == b->end)
+			return 0;
+		return (a->end < b->end) ? -1 : 1;
+	}
+	return a->begin < b->begin ? -1 : 1;
+}
+
+static void sort_switch_cases(struct instruction *insn)
+{
+	sort_list((struct ptr_list **)&insn->multijmp_list, multijmp_cmp);
+}
+
+static pseudo_t linearize_declaration(struct entrypoint *ep, struct statement *stmt)
+{
+	struct symbol *sym;
+
+	concat_symbol_list(stmt->declaration, &ep->syms);
+
+	FOR_EACH_PTR(stmt->declaration, sym) {
+		linearize_one_symbol(ep, sym);
+	} END_FOR_EACH_PTR(sym);
+	return VOID;
+}
+
+static pseudo_t linearize_return(struct entrypoint *ep, struct statement *stmt)
+{
+	struct expression *expr = stmt->expression;
+	struct basic_block *bb_return = get_bound_block(ep, stmt->ret_target);
+	struct basic_block *active;
+	pseudo_t src = linearize_expression(ep, expr);
+	active = ep->active;
+	if (active && src != VOID) {
+		struct instruction *phi_node = first_instruction(bb_return->insns);
+		pseudo_t phi;
+		if (!phi_node) {
+			phi_node = alloc_typed_instruction(OP_PHI, expr->ctype);
+			phi_node->target = alloc_pseudo(phi_node);
+			phi_node->bb = bb_return;
+			add_instruction(&bb_return->insns, phi_node);
+		}
+		phi = alloc_phi(active, src, type_size(expr->ctype));
+		phi->ident = &return_ident;
+		use_pseudo(phi_node, phi, add_pseudo(&phi_node->phi_list, phi));
+	}
+	add_goto(ep, bb_return);
+	return VOID;
+}
+
+static pseudo_t linearize_switch(struct entrypoint *ep, struct statement *stmt)
+{
+	struct symbol *sym;
+	struct instruction *switch_ins;
+	struct basic_block *switch_end = alloc_basic_block(ep, stmt->pos);
+	struct basic_block *active, *default_case;
+	struct multijmp *jmp;
+	pseudo_t pseudo;
+
+	pseudo = linearize_expression(ep, stmt->switch_expression);
+
+	active = ep->active;
+	if (!bb_reachable(active))
+		return VOID;
+
+	switch_ins = alloc_instruction(OP_SWITCH, 0);
+	use_pseudo(switch_ins, pseudo, &switch_ins->cond);
+	add_one_insn(ep, switch_ins);
+	finish_block(ep);
+
+	default_case = NULL;
+	FOR_EACH_PTR(stmt->switch_case->symbol_list, sym) {
+		struct statement *case_stmt = sym->stmt;
+		struct basic_block *bb_case = get_bound_block(ep, sym);
+
+		if (!case_stmt->case_expression) {
+			default_case = bb_case;
+			continue;
+		} else {
+			int begin, end;
+
+			begin = end = case_stmt->case_expression->value;
+			if (case_stmt->case_to)
+				end = case_stmt->case_to->value;
+			if (begin > end)
+				jmp = alloc_multijmp(bb_case, end, begin);
+			else
+				jmp = alloc_multijmp(bb_case, begin, end);
+
+		}
+		add_multijmp(&switch_ins->multijmp_list, jmp);
+		add_bb(&bb_case->parents, active);
+		add_bb(&active->children, bb_case);
+	} END_FOR_EACH_PTR(sym);
+
+	bind_label(stmt->switch_break, switch_end, stmt->pos);
+
+	/* And linearize the actual statement */
+	linearize_statement(ep, stmt->switch_statement);
+	set_activeblock(ep, switch_end);
+
+	if (!default_case)
+		default_case = switch_end;
+
+	jmp = alloc_multijmp(default_case, 1, 0);
+	add_multijmp(&switch_ins->multijmp_list, jmp);
+	add_bb(&default_case->parents, active);
+	add_bb(&active->children, default_case);
+	sort_switch_cases(switch_ins);
+
+	return VOID;
+}
+
+static pseudo_t linearize_iterator(struct entrypoint *ep, struct statement *stmt)
+{
+	struct statement  *pre_statement = stmt->iterator_pre_statement;
+	struct expression *pre_condition = stmt->iterator_pre_condition;
+	struct statement  *statement = stmt->iterator_statement;
+	struct statement  *post_statement = stmt->iterator_post_statement;
+	struct expression *post_condition = stmt->iterator_post_condition;
+	struct basic_block *loop_top, *loop_body, *loop_continue, *loop_end;
+	struct symbol *sym;
+
+	FOR_EACH_PTR(stmt->iterator_syms, sym) {
+		linearize_one_symbol(ep, sym);
+	} END_FOR_EACH_PTR(sym);
+	concat_symbol_list(stmt->iterator_syms, &ep->syms);
+	linearize_statement(ep, pre_statement);
+
+	loop_body = loop_top = alloc_basic_block(ep, stmt->pos);
+	loop_continue = alloc_basic_block(ep, stmt->pos);
+	loop_end = alloc_basic_block(ep, stmt->pos);
+
+	/* An empty post-condition means that it's the same as the pre-condition */
+	if (!post_condition) {
+		loop_top = alloc_basic_block(ep, stmt->pos);
+		set_activeblock(ep, loop_top);
+	}
+
+	if (pre_condition)
+			linearize_cond_branch(ep, pre_condition, loop_body, loop_end);
+
+	bind_label(stmt->iterator_continue, loop_continue, stmt->pos);
+	bind_label(stmt->iterator_break, loop_end, stmt->pos);
+
+	set_activeblock(ep, loop_body);
+	linearize_statement(ep, statement);
+	add_goto(ep, loop_continue);
+
+	set_activeblock(ep, loop_continue);
+	linearize_statement(ep, post_statement);
+	if (!post_condition)
+		add_goto(ep, loop_top);
+	else
+		linearize_cond_branch(ep, post_condition, loop_top, loop_end);
+	set_activeblock(ep, loop_end);
+
+	return VOID;
+}
+
+pseudo_t linearize_statement(struct entrypoint *ep, struct statement *stmt)
+{
+	struct basic_block *bb;
+
+	if (!stmt)
+		return VOID;
+
+	bb = ep->active;
+	if (bb && !bb->insns)
+		bb->pos = stmt->pos;
+	current_pos = stmt->pos;
+
+	switch (stmt->type) {
+	case STMT_NONE:
+		break;
+
+	case STMT_DECLARATION:
+		return linearize_declaration(ep, stmt);
+
+	case STMT_CONTEXT:
+		return linearize_context(ep, stmt);
+
+	case STMT_RANGE:
+		return linearize_range(ep, stmt);
+
+	case STMT_EXPRESSION:
+		return linearize_expression(ep, stmt->expression);
+
+	case STMT_ASM:
+		return linearize_asm_statement(ep, stmt);
+
+	case STMT_RETURN:
+		return linearize_return(ep, stmt);
+
+	case STMT_CASE: {
+		add_label(ep, stmt->case_label);
+		linearize_statement(ep, stmt->case_statement);
+		break;
+	}
+
+	case STMT_LABEL: {
+		struct symbol *label = stmt->label_identifier;
+
+		if (label->used) {
+			add_label(ep, label);
+		}
+		return linearize_statement(ep, stmt->label_statement);
+	}
+
+	case STMT_GOTO: {
+		struct symbol *sym;
+		struct expression *expr;
+		struct instruction *goto_ins;
+		struct basic_block *active;
+		pseudo_t pseudo;
+
+		active = ep->active;
+		if (!bb_reachable(active))
+			break;
+
+		if (stmt->goto_label) {
+			add_goto(ep, get_bound_block(ep, stmt->goto_label));
+			break;
+		}
+
+		expr = stmt->goto_expression;
+		if (!expr)
+			break;
+
+		/* This can happen as part of simplification */
+		if (expr->type == EXPR_LABEL) {
+			add_goto(ep, get_bound_block(ep, expr->label_symbol));
+			break;
+		}
+
+		pseudo = linearize_expression(ep, expr);
+		goto_ins = alloc_instruction(OP_COMPUTEDGOTO, 0);
+		use_pseudo(goto_ins, pseudo, &goto_ins->target);
+		add_one_insn(ep, goto_ins);
+
+		FOR_EACH_PTR(stmt->target_list, sym) {
+			struct basic_block *bb_computed = get_bound_block(ep, sym);
+			struct multijmp *jmp = alloc_multijmp(bb_computed, 1, 0);
+			add_multijmp(&goto_ins->multijmp_list, jmp);
+			add_bb(&bb_computed->parents, ep->active);
+			add_bb(&active->children, bb_computed);
+		} END_FOR_EACH_PTR(sym);
+
+		finish_block(ep);
+		break;
+	}
+
+	case STMT_COMPOUND:
+		if (stmt->inline_fn)
+			return linearize_inlined_call(ep, stmt);
+		return linearize_compound_statement(ep, stmt);
+
+	/*
+	 * This could take 'likely/unlikely' into account, and
+	 * switch the arms around appropriately..
+	 */
+	case STMT_IF: {
+		struct basic_block *bb_true, *bb_false, *endif;
+ 		struct expression *cond = stmt->if_conditional;
+
+		bb_true = alloc_basic_block(ep, stmt->pos);
+		bb_false = endif = alloc_basic_block(ep, stmt->pos);
+
+ 		linearize_cond_branch(ep, cond, bb_true, bb_false);
+
+		set_activeblock(ep, bb_true);
+ 		linearize_statement(ep, stmt->if_true);
+ 
+ 		if (stmt->if_false) {
+			endif = alloc_basic_block(ep, stmt->pos);
+			add_goto(ep, endif);
+			set_activeblock(ep, bb_false);
+ 			linearize_statement(ep, stmt->if_false);
+		}
+		set_activeblock(ep, endif);
+		break;
+	}
+
+	case STMT_SWITCH:
+		return linearize_switch(ep, stmt);
+
+	case STMT_ITERATOR:
+		return linearize_iterator(ep, stmt);
+
+	default:
+		break;
+	}
+	return VOID;
+}
+
+static struct entrypoint *linearize_fn(struct symbol *sym, struct symbol *base_type)
+{
+	struct entrypoint *ep;
+	struct basic_block *bb;
+	struct symbol *arg;
+	struct instruction *entry;
+	pseudo_t result;
+	int i;
+
+	if (!base_type->stmt)
+		return NULL;
+
+	ep = alloc_entrypoint();
+	bb = alloc_basic_block(ep, sym->pos);
+	
+	ep->name = sym;
+	sym->ep = ep;
+	set_activeblock(ep, bb);
+
+	entry = alloc_instruction(OP_ENTRY, 0);
+	add_one_insn(ep, entry);
+	ep->entry = entry;
+
+	concat_symbol_list(base_type->arguments, &ep->syms);
+
+	/* FIXME!! We should do something else about varargs.. */
+	i = 0;
+	FOR_EACH_PTR(base_type->arguments, arg) {
+		linearize_argument(ep, arg, ++i);
+	} END_FOR_EACH_PTR(arg);
+
+	result = linearize_statement(ep, base_type->stmt);
+	if (bb_reachable(ep->active) && !bb_terminated(ep->active)) {
+		struct symbol *ret_type = base_type->ctype.base_type;
+		struct instruction *insn = alloc_typed_instruction(OP_RET, ret_type);
+
+		if (type_size(ret_type) > 0)
+			use_pseudo(insn, result, &insn->src);
+		add_one_insn(ep, insn);
+	}
+
+	if (fdump_linearize) {
+		if (fdump_linearize == 2)
+			return ep;
+		show_entry(ep);
+	}
+
+	/*
+	 * Do trivial flow simplification - branches to
+	 * branches, kill dead basicblocks etc
+	 */
+	kill_unreachable_bbs(ep);
+
+	/*
+	 * Turn symbols into pseudos
+	 */
+	simplify_symbol_usage(ep);
+
+repeat:
+	/*
+	 * Remove trivial instructions, and try to CSE
+	 * the rest.
+	 */
+	do {
+		cleanup_and_cse(ep);
+		pack_basic_blocks(ep);
+	} while (repeat_phase & REPEAT_CSE);
+
+	kill_unreachable_bbs(ep);
+	vrfy_flow(ep);
+
+	/* Cleanup */
+	clear_symbol_pseudos(ep);
+
+	/* And track pseudo register usage */
+	track_pseudo_liveness(ep);
+
+	/*
+	 * Some flow optimizations can only effectively
+	 * be done when we've done liveness analysis. But
+	 * if they trigger, we need to start all over
+	 * again
+	 */
+	if (simplify_flow(ep)) {
+		clear_liveness(ep);
+		goto repeat;
+	}
+
+	/* Finally, add deathnotes to pseudos now that we have them */
+	if (dbg_dead)
+		track_pseudo_death(ep);
+
+	return ep;
+}
+
+struct entrypoint *linearize_symbol(struct symbol *sym)
+{
+	struct symbol *base_type;
+
+	if (!sym)
+		return NULL;
+	current_pos = sym->pos;
+	base_type = sym->ctype.base_type;
+	if (!base_type)
+		return NULL;
+	if (base_type->type == SYM_FN)
+		return linearize_fn(sym, base_type);
+	return NULL;
+}
diff --git a/usr/src/tools/smatch/src/linearize.h b/usr/src/tools/smatch/src/linearize.h
new file mode 100644
index 0000000000..f52eade85f
--- /dev/null
+++ b/usr/src/tools/smatch/src/linearize.h
@@ -0,0 +1,348 @@
+#ifndef LINEARIZE_H
+#define LINEARIZE_H
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+
+struct instruction;
+DECLARE_PTR_LIST(pseudo_ptr_list, pseudo_t);
+
+struct pseudo_user {
+	struct instruction *insn;
+	pseudo_t *userp;
+};
+
+DECLARE_ALLOCATOR(pseudo_user);
+DECLARE_PTR_LIST(pseudo_user_list, struct pseudo_user);
+
+
+enum pseudo_type {
+	PSEUDO_VOID,
+	PSEUDO_REG,
+	PSEUDO_SYM,
+	PSEUDO_VAL,
+	PSEUDO_ARG,
+	PSEUDO_PHI,
+};
+
+struct pseudo {
+	int nr;
+	int size:16;	/* OP_SETVAL only */
+	enum pseudo_type type:8;
+	struct pseudo_user_list *users;
+	struct ident *ident;
+	union {
+		struct symbol *sym;
+		struct instruction *def;
+		long long value;
+	};
+	void *priv;
+};
+
+extern struct pseudo void_pseudo;
+
+#define VOID (&void_pseudo)
+
+struct multijmp {
+	struct basic_block *target;
+	int begin, end;
+};
+
+struct asm_constraint {
+	pseudo_t pseudo;
+	const char *constraint;
+	const struct ident *ident;
+};
+
+DECLARE_ALLOCATOR(asm_constraint);
+DECLARE_PTR_LIST(asm_constraint_list, struct asm_constraint);
+
+struct asm_rules {
+	struct asm_constraint_list *inputs;
+	struct asm_constraint_list *outputs;
+	struct asm_constraint_list *clobbers;
+};
+
+DECLARE_ALLOCATOR(asm_rules);
+
+struct instruction {
+	unsigned opcode:8,
+		 size:24;
+	struct basic_block *bb;
+	struct position pos;
+	struct symbol *type;
+	union {
+		pseudo_t target;
+		pseudo_t cond;		/* for branch and switch */
+	};
+	union {
+		struct /* entrypoint */ {
+			struct pseudo_list *arg_list;
+		};
+		struct /* branch */ {
+			struct basic_block *bb_true, *bb_false;
+		};
+		struct /* switch */ {
+			struct multijmp_list *multijmp_list;
+		};
+		struct /* phi_node */ {
+			struct pseudo_list *phi_list;
+		};
+		struct /* phi source */ {
+			pseudo_t phi_src;
+			struct instruction_list *phi_users;
+		};
+		struct /* unops */ {
+			pseudo_t src;
+			struct symbol *orig_type;	/* casts */
+			unsigned int offset;		/* memops */
+		};
+		struct /* binops and sel */ {
+			pseudo_t src1, src2, src3;
+		};
+		struct /* slice */ {
+			pseudo_t base;
+			unsigned from, len;
+		};
+		struct /* setval */ {
+			pseudo_t symbol;		/* Subtle: same offset as "src" !! */
+			struct expression *val;
+		};
+		struct /* call */ {
+			pseudo_t func;
+			struct pseudo_list *arguments;
+			struct symbol *fntype;
+		};
+		struct /* context */ {
+			int increment;
+			int check;
+			struct expression *context_expr;
+		};
+		struct /* asm */ {
+			const char *string;
+			struct asm_rules *asm_rules;
+		};
+	};
+};
+
+enum opcode {
+	OP_BADOP,
+
+	/* Entry */
+	OP_ENTRY,
+
+	/* Terminator */
+	OP_TERMINATOR,
+	OP_RET = OP_TERMINATOR,
+	OP_BR,
+	OP_CBR,
+	OP_SWITCH,
+	OP_INVOKE,
+	OP_COMPUTEDGOTO,
+	OP_UNWIND,
+	OP_TERMINATOR_END = OP_UNWIND,
+	
+	/* Binary */
+	OP_BINARY,
+	OP_ADD = OP_BINARY,
+	OP_SUB,
+	OP_MULU, OP_MULS,
+	OP_DIVU, OP_DIVS,
+	OP_MODU, OP_MODS,
+	OP_SHL,
+	OP_LSR, OP_ASR,
+	
+	/* Logical */
+	OP_AND,
+	OP_OR,
+	OP_XOR,
+	OP_AND_BOOL,
+	OP_OR_BOOL,
+	OP_BINARY_END = OP_OR_BOOL,
+
+	/* Binary comparison */
+	OP_BINCMP,
+	OP_SET_EQ = OP_BINCMP,
+	OP_SET_NE,
+	OP_SET_LE,
+	OP_SET_GE,
+	OP_SET_LT,
+	OP_SET_GT,
+	OP_SET_B,
+	OP_SET_A,
+	OP_SET_BE,
+	OP_SET_AE,
+	OP_BINCMP_END = OP_SET_AE,
+
+	/* Uni */
+	OP_NOT,
+	OP_NEG,
+
+	/* Select - three input values */
+	OP_SEL,
+	
+	/* Memory */
+	OP_MALLOC,
+	OP_FREE,
+	OP_ALLOCA,
+	OP_LOAD,
+	OP_STORE,
+	OP_SETVAL,
+	OP_SYMADDR,
+	OP_GET_ELEMENT_PTR,
+
+	/* Other */
+	OP_PHI,
+	OP_PHISOURCE,
+	OP_CAST,
+	OP_SCAST,
+	OP_FPCAST,
+	OP_PTRCAST,
+	OP_INLINED_CALL,
+	OP_CALL,
+	OP_VANEXT,
+	OP_VAARG,
+	OP_SLICE,
+	OP_SNOP,
+	OP_LNOP,
+	OP_NOP,
+	OP_DEATHNOTE,
+	OP_ASM,
+
+	/* Sparse tagging (line numbers, context, whatever) */
+	OP_CONTEXT,
+	OP_RANGE,
+
+	/* Needed to translate SSA back to normal form */
+	OP_COPY,
+};
+
+struct basic_block_list;
+struct instruction_list;
+
+struct basic_block {
+	struct position pos;
+	unsigned long generation;
+	int context;
+	struct entrypoint *ep;
+	struct basic_block_list *parents; /* sources */
+	struct basic_block_list *children; /* destinations */
+	struct instruction_list *insns;	/* Linear list of instructions */
+	struct pseudo_list *needs, *defines;
+	union {
+		unsigned int nr;	/* unique id for label's names */
+		void *priv;
+	};
+};
+
+
+static inline void add_bb(struct basic_block_list **list, struct basic_block *bb)
+{
+	add_ptr_list(list, bb);
+}
+
+static inline void add_instruction(struct instruction_list **list, struct instruction *insn)
+{
+	add_ptr_list(list, insn);
+}
+
+static inline void add_multijmp(struct multijmp_list **list, struct multijmp *multijmp)
+{
+	add_ptr_list(list, multijmp);
+}
+
+static inline pseudo_t *add_pseudo(struct pseudo_list **list, pseudo_t pseudo)
+{
+	return add_ptr_list(list, pseudo);
+}
+
+static inline int remove_pseudo(struct pseudo_list **list, pseudo_t pseudo)
+{
+	return delete_ptr_list_entry((struct ptr_list **)list, pseudo, 0) != 0;
+}
+
+static inline int bb_terminated(struct basic_block *bb)
+{
+	struct instruction *insn;
+	if (!bb)
+		return 0;
+	insn = last_instruction(bb->insns);
+	return insn && insn->opcode >= OP_TERMINATOR
+	            && insn->opcode <= OP_TERMINATOR_END;
+}
+
+static inline int bb_reachable(struct basic_block *bb)
+{
+	return bb != NULL;
+}
+
+static inline void add_pseudo_ptr(pseudo_t *ptr, struct pseudo_ptr_list **list)
+{
+	add_ptr_list(list, ptr);
+}
+
+static inline void add_pseudo_user_ptr(struct pseudo_user *user, struct pseudo_user_list **list)
+{
+	add_ptr_list(list, user);
+}
+
+static inline int has_use_list(pseudo_t p)
+{
+	return (p && p->type != PSEUDO_VOID && p->type != PSEUDO_VAL);
+}
+
+static inline struct pseudo_user *alloc_pseudo_user(struct instruction *insn, pseudo_t *pp)
+{
+	struct pseudo_user *user = __alloc_pseudo_user(0);
+	user->userp = pp;
+	user->insn = insn;
+	return user;
+}
+
+static inline void use_pseudo(struct instruction *insn, pseudo_t p, pseudo_t *pp)
+{
+	*pp = p;
+	if (has_use_list(p))
+		add_pseudo_user_ptr(alloc_pseudo_user(insn, pp), &p->users);
+}
+
+static inline void remove_bb_from_list(struct basic_block_list **list, struct basic_block *entry, int count)
+{
+	delete_ptr_list_entry((struct ptr_list **)list, entry, count);
+}
+
+static inline void replace_bb_in_list(struct basic_block_list **list,
+	struct basic_block *old, struct basic_block *new, int count)
+{
+	replace_ptr_list_entry((struct ptr_list **)list, old, new, count);
+}
+
+struct entrypoint {
+	struct symbol *name;
+	struct symbol_list *syms;
+	struct pseudo_list *accesses;
+	struct basic_block_list *bbs;
+	struct basic_block *active;
+	struct instruction *entry;
+};
+
+extern void insert_select(struct basic_block *bb, struct instruction *br, struct instruction *phi, pseudo_t if_true, pseudo_t if_false);
+extern void insert_branch(struct basic_block *bb, struct instruction *br, struct basic_block *target);
+
+pseudo_t alloc_phi(struct basic_block *source, pseudo_t pseudo, int size);
+pseudo_t alloc_pseudo(struct instruction *def);
+pseudo_t value_pseudo(struct symbol *type, long long val);
+unsigned int value_size(long long value);
+
+struct entrypoint *linearize_symbol(struct symbol *sym);
+int unssa(struct entrypoint *ep);
+void show_entry(struct entrypoint *ep);
+const char *show_pseudo(pseudo_t pseudo);
+void show_bb(struct basic_block *bb);
+const char *show_instruction(struct instruction *insn);
+
+#endif /* LINEARIZE_H */
+
diff --git a/usr/src/tools/smatch/src/liveness.c b/usr/src/tools/smatch/src/liveness.c
new file mode 100644
index 0000000000..7461738b47
--- /dev/null
+++ b/usr/src/tools/smatch/src/liveness.c
@@ -0,0 +1,359 @@
+/*
+ * Register - track pseudo usage, maybe eventually try to do register
+ * allocation.
+ *
+ * Copyright (C) 2004 Linus Torvalds
+ */
+
+#include <assert.h>
+
+#include "parse.h"
+#include "expression.h"
+#include "linearize.h"
+#include "flow.h"
+
+static void phi_defines(struct instruction * phi_node, pseudo_t target,
+	void (*defines)(struct basic_block *, pseudo_t))
+{
+	pseudo_t phi;
+	FOR_EACH_PTR(phi_node->phi_list, phi) {
+		struct instruction *def;
+		if (phi == VOID)
+			continue;
+		def = phi->def;
+		if (!def || !def->bb)
+			continue;
+		defines(def->bb, target);
+	} END_FOR_EACH_PTR(phi);
+}
+
+static void asm_liveness(struct basic_block *bb, struct instruction *insn,
+	void (*def)(struct basic_block *, pseudo_t),
+	void (*use)(struct basic_block *, pseudo_t))
+{
+	struct asm_constraint *entry;
+
+	FOR_EACH_PTR(insn->asm_rules->inputs, entry) {
+		use(bb, entry->pseudo);
+	} END_FOR_EACH_PTR(entry);
+		
+	FOR_EACH_PTR(insn->asm_rules->outputs, entry) {
+		def(bb, entry->pseudo);
+	} END_FOR_EACH_PTR(entry);
+}
+
+static void track_instruction_usage(struct basic_block *bb, struct instruction *insn,
+	void (*def)(struct basic_block *, pseudo_t),
+	void (*use)(struct basic_block *, pseudo_t))
+{
+	pseudo_t pseudo;
+
+	#define USES(x)		use(bb, insn->x)
+	#define DEFINES(x)	def(bb, insn->x)
+
+	switch (insn->opcode) {
+	case OP_RET:
+		USES(src);
+		break;
+
+	case OP_CBR:
+	case OP_SWITCH:
+		USES(cond);
+		break;
+
+	case OP_COMPUTEDGOTO:
+		USES(target);
+		break;
+	
+	/* Binary */
+	case OP_BINARY ... OP_BINARY_END:
+	case OP_BINCMP ... OP_BINCMP_END:
+		USES(src1); USES(src2); DEFINES(target);
+		break;
+
+	/* Uni */
+	case OP_NOT: case OP_NEG:
+		USES(src1); DEFINES(target);
+		break;
+
+	case OP_SEL:
+		USES(src1); USES(src2); USES(src3); DEFINES(target);
+		break;
+	
+	/* Memory */
+	case OP_LOAD:
+		USES(src); DEFINES(target);
+		break;
+
+	case OP_STORE:
+		USES(src); USES(target);
+		break;
+
+	case OP_SETVAL:
+		DEFINES(target);
+		break;
+
+	case OP_SYMADDR:
+		USES(symbol); DEFINES(target);
+		break;
+
+	/* Other */
+	case OP_PHI:
+		/* Phi-nodes are "backwards" nodes. Their def doesn't matter */
+		phi_defines(insn, insn->target, def);
+		break;
+
+	case OP_PHISOURCE:
+		/*
+		 * We don't care about the phi-source define, they get set
+		 * up and expanded by the OP_PHI
+		 */
+		USES(phi_src);
+		break;
+
+	case OP_CAST:
+	case OP_SCAST:
+	case OP_FPCAST:
+	case OP_PTRCAST:
+		USES(src); DEFINES(target);
+		break;
+
+	case OP_CALL:
+		USES(func);
+		if (insn->target != VOID)
+			DEFINES(target);
+		FOR_EACH_PTR(insn->arguments, pseudo) {
+			use(bb, pseudo);
+		} END_FOR_EACH_PTR(pseudo);
+		break;
+
+	case OP_SLICE:
+		USES(base); DEFINES(target);
+		break;
+
+	case OP_ASM:
+		asm_liveness(bb, insn, def, use);
+		break;
+
+	case OP_RANGE:
+		USES(src1); USES(src2); USES(src3);
+		break;
+
+	case OP_BADOP:
+	case OP_INVOKE:
+	case OP_UNWIND:
+	case OP_MALLOC:
+	case OP_FREE:
+	case OP_ALLOCA:
+	case OP_GET_ELEMENT_PTR:
+	case OP_VANEXT:
+	case OP_VAARG:
+	case OP_SNOP:
+	case OP_LNOP:
+	case OP_NOP:
+	case OP_CONTEXT:
+		break;
+	}
+}
+
+int pseudo_in_list(struct pseudo_list *list, pseudo_t pseudo)
+{
+	pseudo_t old;
+	FOR_EACH_PTR(list,old) {
+		if (old == pseudo)
+			return 1;
+	} END_FOR_EACH_PTR(old);   
+	return 0;
+}
+
+static int liveness_changed;
+
+static void add_pseudo_exclusive(struct pseudo_list **list, pseudo_t pseudo)
+{
+	if (!pseudo_in_list(*list, pseudo)) {
+		liveness_changed = 1;
+		add_pseudo(list, pseudo);
+	}
+}
+
+static inline int trackable_pseudo(pseudo_t pseudo)
+{
+	return pseudo && (pseudo->type == PSEUDO_REG || pseudo->type == PSEUDO_ARG);
+}
+
+static void insn_uses(struct basic_block *bb, pseudo_t pseudo)
+{
+	if (trackable_pseudo(pseudo)) {
+		struct instruction *def = pseudo->def;
+		if (pseudo->type != PSEUDO_REG || def->bb != bb || def->opcode == OP_PHI)
+			add_pseudo_exclusive(&bb->needs, pseudo);
+	}
+}
+
+static void insn_defines(struct basic_block *bb, pseudo_t pseudo)
+{
+	assert(trackable_pseudo(pseudo));
+	add_pseudo(&bb->defines, pseudo);
+}
+
+static void track_bb_liveness(struct basic_block *bb)
+{
+	pseudo_t needs;
+
+	FOR_EACH_PTR(bb->needs, needs) {
+		struct basic_block *parent;
+		FOR_EACH_PTR(bb->parents, parent) {
+			if (!pseudo_in_list(parent->defines, needs)) {
+				add_pseudo_exclusive(&parent->needs, needs);
+			}
+		} END_FOR_EACH_PTR(parent);
+	} END_FOR_EACH_PTR(needs);
+}
+
+/*
+ * We need to clear the liveness information if we 
+ * are going to re-run it.
+ */
+void clear_liveness(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		free_ptr_list(&bb->needs);
+		free_ptr_list(&bb->defines);
+	} END_FOR_EACH_PTR(bb);
+}
+
+/*
+ * Track inter-bb pseudo liveness. The intra-bb case
+ * is purely local information.
+ */
+void track_pseudo_liveness(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+
+	/* Add all the bb pseudo usage */
+	FOR_EACH_PTR(ep->bbs, bb) {
+		struct instruction *insn;
+		FOR_EACH_PTR(bb->insns, insn) {
+			if (!insn->bb)
+				continue;
+			assert(insn->bb == bb);
+			track_instruction_usage(bb, insn, insn_defines, insn_uses);
+		} END_FOR_EACH_PTR(insn);
+	} END_FOR_EACH_PTR(bb);
+
+	/* Calculate liveness.. */
+	do {
+		liveness_changed = 0;
+		FOR_EACH_PTR_REVERSE(ep->bbs, bb) {
+			track_bb_liveness(bb);
+		} END_FOR_EACH_PTR_REVERSE(bb);
+	} while (liveness_changed);
+
+	/* Remove the pseudos from the "defines" list that are used internally */
+	FOR_EACH_PTR(ep->bbs, bb) {
+		pseudo_t def;
+		FOR_EACH_PTR(bb->defines, def) {
+			struct basic_block *child;
+			FOR_EACH_PTR(bb->children, child) {
+				if (pseudo_in_list(child->needs, def))
+					goto is_used;
+			} END_FOR_EACH_PTR(child);
+			DELETE_CURRENT_PTR(def);
+is_used:
+		;
+		} END_FOR_EACH_PTR(def);
+		PACK_PTR_LIST(&bb->defines);
+	} END_FOR_EACH_PTR(bb);
+}
+
+static void merge_pseudo_list(struct pseudo_list *src, struct pseudo_list **dest)
+{
+	pseudo_t pseudo;
+	FOR_EACH_PTR(src, pseudo) {
+		add_pseudo_exclusive(dest, pseudo);
+	} END_FOR_EACH_PTR(pseudo);
+}
+
+void track_phi_uses(struct instruction *insn)
+{
+	pseudo_t phi;
+	FOR_EACH_PTR(insn->phi_list, phi) {
+		struct instruction *def;
+		if (phi == VOID || !phi->def)
+			continue;
+		def = phi->def;
+		assert(def->opcode == OP_PHISOURCE);
+		add_ptr_list(&def->phi_users, insn);
+	} END_FOR_EACH_PTR(phi);
+}
+
+static void track_bb_phi_uses(struct basic_block *bb)
+{
+	struct instruction *insn;
+	FOR_EACH_PTR(bb->insns, insn) {
+		if (insn->bb && insn->opcode == OP_PHI)
+			track_phi_uses(insn);
+	} END_FOR_EACH_PTR(insn);
+}
+
+static struct pseudo_list **live_list;
+static struct pseudo_list *dead_list;
+
+static void death_def(struct basic_block *bb, pseudo_t pseudo)
+{
+}
+
+static void death_use(struct basic_block *bb, pseudo_t pseudo)
+{
+	if (trackable_pseudo(pseudo) && !pseudo_in_list(*live_list, pseudo)) {
+		add_pseudo(&dead_list, pseudo);
+		add_pseudo(live_list, pseudo);
+	}
+}
+
+static void track_pseudo_death_bb(struct basic_block *bb)
+{
+	struct pseudo_list *live = NULL;
+	struct basic_block *child;
+	struct instruction *insn;
+
+	FOR_EACH_PTR(bb->children, child) {
+		merge_pseudo_list(child->needs, &live);
+	} END_FOR_EACH_PTR(child);
+
+	live_list = &live;
+	FOR_EACH_PTR_REVERSE(bb->insns, insn) {
+		if (!insn->bb)
+			continue;
+
+		dead_list = NULL;
+		track_instruction_usage(bb, insn, death_def, death_use);
+		if (dead_list) {
+			pseudo_t dead;
+			FOR_EACH_PTR(dead_list, dead) {
+				struct instruction *deathnote = __alloc_instruction(0);
+				deathnote->bb = bb;
+				deathnote->opcode = OP_DEATHNOTE;
+				deathnote->target = dead;
+				INSERT_CURRENT(deathnote, insn);
+			} END_FOR_EACH_PTR(dead);
+			free_ptr_list(&dead_list);
+		}
+	} END_FOR_EACH_PTR_REVERSE(insn);
+	free_ptr_list(&live);
+}
+
+void track_pseudo_death(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		track_bb_phi_uses(bb);
+	} END_FOR_EACH_PTR(bb);
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		track_pseudo_death_bb(bb);
+	} END_FOR_EACH_PTR(bb);
+}
diff --git a/usr/src/tools/smatch/src/macro_table.c b/usr/src/tools/smatch/src/macro_table.c
new file mode 100644
index 0000000000..18c5538ed4
--- /dev/null
+++ b/usr/src/tools/smatch/src/macro_table.c
@@ -0,0 +1,67 @@
+/*
+ * sparse/macro_table.c
+ *
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "lib.h"
+#include "parse.h"
+#include "cwchash/hashtable.h"
+
+static struct hashtable *macro_table;
+
+static DEFINE_HASHTABLE_INSERT(do_insert_macro, struct position, char);
+static DEFINE_HASHTABLE_SEARCH(do_search_macro, struct position, char);
+
+static inline unsigned int position_hash(void *_pos)
+{
+	struct position *pos = _pos;
+
+	return pos->line | (pos->pos << 22) | (pos->stream << 18); 
+}
+
+static inline int equalkeys(void *_pos1, void *_pos2)
+{
+	struct position *pos1 = _pos1;
+	struct position *pos2 = _pos2;
+
+	return pos1->line == pos2->line && pos1->pos == pos2->pos &&
+		pos1->stream == pos2->stream;
+}
+
+void store_macro_pos(struct token *token)
+{
+	if (!macro_table)
+		macro_table = create_hashtable(5000, position_hash, equalkeys);
+
+	if (get_macro_name(token->pos))
+		return;
+
+	do_insert_macro(macro_table, &token->pos, token->ident->name);
+}
+
+char *get_macro_name(struct position pos)
+{
+	return do_search_macro(macro_table, &pos);
+}
diff --git a/usr/src/tools/smatch/src/memops.c b/usr/src/tools/smatch/src/memops.c
new file mode 100644
index 0000000000..6a795c19c4
--- /dev/null
+++ b/usr/src/tools/smatch/src/memops.c
@@ -0,0 +1,197 @@
+/*
+ * memops - try to combine memory ops.
+ *
+ * Copyright (C) 2004 Linus Torvalds
+ */
+
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <assert.h>
+
+#include "parse.h"
+#include "expression.h"
+#include "linearize.h"
+#include "flow.h"
+
+static int find_dominating_parents(pseudo_t pseudo, struct instruction *insn,
+	struct basic_block *bb, unsigned long generation, struct pseudo_list **dominators,
+	int local)
+{
+	struct basic_block *parent;
+
+	FOR_EACH_PTR(bb->parents, parent) {
+		struct instruction *one;
+		struct instruction *br;
+		pseudo_t phi;
+
+		FOR_EACH_PTR_REVERSE(parent->insns, one) {
+			int dominance;
+			if (!one->bb)
+				continue;
+			if (one == insn)
+				goto no_dominance;
+			dominance = dominates(pseudo, insn, one, local);
+			if (dominance < 0) {
+				if (one->opcode == OP_LOAD)
+					continue;
+				return 0;
+			}
+			if (!dominance)
+				continue;
+			goto found_dominator;
+		} END_FOR_EACH_PTR_REVERSE(one);
+no_dominance:
+		if (parent->generation == generation)
+			continue;
+		parent->generation = generation;
+
+		if (!find_dominating_parents(pseudo, insn, parent, generation, dominators, local))
+			return 0;
+		continue;
+
+found_dominator:
+		br = delete_last_instruction(&parent->insns);
+		phi = alloc_phi(parent, one->target, one->size);
+		phi->ident = phi->ident ? : one->target->ident;
+		add_instruction(&parent->insns, br);
+		use_pseudo(insn, phi, add_pseudo(dominators, phi));
+	} END_FOR_EACH_PTR(parent);
+	return 1;
+}		
+
+static int address_taken(pseudo_t pseudo)
+{
+	struct pseudo_user *pu;
+	FOR_EACH_PTR(pseudo->users, pu) {
+		struct instruction *insn = pu->insn;
+		if (insn->bb && (insn->opcode != OP_LOAD && insn->opcode != OP_STORE))
+			return 1;
+	} END_FOR_EACH_PTR(pu);
+	return 0;
+}
+
+static int local_pseudo(pseudo_t pseudo)
+{
+	return pseudo->type == PSEUDO_SYM
+		&& !(pseudo->sym->ctype.modifiers & (MOD_STATIC | MOD_NONLOCAL))
+		&& !address_taken(pseudo);
+}
+
+static void simplify_loads(struct basic_block *bb)
+{
+	struct instruction *insn;
+
+	FOR_EACH_PTR_REVERSE(bb->insns, insn) {
+		if (!insn->bb)
+			continue;
+		if (insn->opcode == OP_LOAD) {
+			struct instruction *dom;
+			pseudo_t pseudo = insn->src;
+			int local = local_pseudo(pseudo);
+			struct pseudo_list *dominators;
+			unsigned long generation;
+
+			/* Check for illegal offsets.. */
+			check_access(insn);
+
+			if (insn->type->ctype.modifiers & MOD_VOLATILE)
+				continue;
+
+			RECURSE_PTR_REVERSE(insn, dom) {
+				int dominance;
+				if (!dom->bb)
+					continue;
+				dominance = dominates(pseudo, insn, dom, local);
+				if (dominance) {
+					/* possible partial dominance? */
+					if (dominance < 0)  {
+						if (dom->opcode == OP_LOAD)
+							continue;
+						goto next_load;
+					}
+					/* Yeehaa! Found one! */
+					convert_load_instruction(insn, dom->target);
+					goto next_load;
+				}
+			} END_FOR_EACH_PTR_REVERSE(dom);
+
+			/* OK, go find the parents */
+			generation = ++bb_generation;
+			bb->generation = generation;
+			dominators = NULL;
+			if (find_dominating_parents(pseudo, insn, bb, generation, &dominators, local)) {
+				/* This happens with initial assignments to structures etc.. */
+				if (!dominators) {
+					if (local) {
+						assert(pseudo->type != PSEUDO_ARG);
+						convert_load_instruction(insn, value_pseudo(insn->type, 0));
+					}
+					goto next_load;
+				}
+				rewrite_load_instruction(insn, dominators);
+			}
+		}
+next_load:
+		/* Do the next one */;
+	} END_FOR_EACH_PTR_REVERSE(insn);
+}
+
+static void kill_store(struct instruction *insn)
+{
+	if (insn) {
+		insn->bb = NULL;
+		insn->opcode = OP_SNOP;
+		kill_use(&insn->target);
+	}
+}
+
+static void kill_dominated_stores(struct basic_block *bb)
+{
+	struct instruction *insn;
+
+	FOR_EACH_PTR_REVERSE(bb->insns, insn) {
+		if (!insn->bb)
+			continue;
+		if (insn->opcode == OP_STORE) {
+			struct instruction *dom;
+			pseudo_t pseudo = insn->src;
+			int local = local_pseudo(pseudo);
+
+			RECURSE_PTR_REVERSE(insn, dom) {
+				int dominance;
+				if (!dom->bb)
+					continue;
+				dominance = dominates(pseudo, insn, dom, local);
+				if (dominance) {
+					/* possible partial dominance? */
+					if (dominance < 0)
+						goto next_store;
+					if (dom->opcode == OP_LOAD)
+						goto next_store;
+					/* Yeehaa! Found one! */
+					kill_store(dom);
+				}
+			} END_FOR_EACH_PTR_REVERSE(dom);
+
+			/* OK, we should check the parents now */
+		}
+next_store:
+		/* Do the next one */;
+	} END_FOR_EACH_PTR_REVERSE(insn);
+}
+
+void simplify_memops(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+
+	FOR_EACH_PTR_REVERSE(ep->bbs, bb) {
+		simplify_loads(bb);
+	} END_FOR_EACH_PTR_REVERSE(bb);
+
+	FOR_EACH_PTR_REVERSE(ep->bbs, bb) {
+		kill_dominated_stores(bb);
+	} END_FOR_EACH_PTR_REVERSE(bb);
+}
diff --git a/usr/src/tools/smatch/src/obfuscate.c b/usr/src/tools/smatch/src/obfuscate.c
new file mode 100644
index 0000000000..18cbd0eef7
--- /dev/null
+++ b/usr/src/tools/smatch/src/obfuscate.c
@@ -0,0 +1,76 @@
+/*
+ * Example trivial client program that uses the sparse library
+ * to tokenize, preprocess and parse a C file, and prints out
+ * the results.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+#include "linearize.h"
+
+static void emit_entrypoint(struct entrypoint *ep)
+{
+	
+}
+
+static void emit_symbol(struct symbol *sym)
+{
+	struct entrypoint *ep;
+	ep = linearize_symbol(sym);
+	if (ep)
+		emit_entrypoint(ep);
+}
+
+static void emit_symbol_list(struct symbol_list *list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		expand_symbol(sym);
+		emit_symbol(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	char *file;
+
+	emit_symbol_list(sparse_initialize(argc, argv, &filelist));
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		emit_symbol_list(sparse(file));
+	} END_FOR_EACH_PTR_NOTAG(file);
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/parse.c b/usr/src/tools/smatch/src/parse.c
new file mode 100644
index 0000000000..ca4726b80a
--- /dev/null
+++ b/usr/src/tools/smatch/src/parse.c
@@ -0,0 +1,2986 @@
+/*
+ * Stupid C parser, version 1e-6.
+ *
+ * Let's see how hard this is to do.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ * Copyright (C) 2004 Christopher Li
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "scope.h"
+#include "expression.h"
+#include "target.h"
+
+static struct symbol_list **function_symbol_list;
+struct symbol_list *function_computed_target_list;
+struct statement_list *function_computed_goto_list;
+
+static struct token *statement(struct token *token, struct statement **tree);
+static struct token *handle_attributes(struct token *token, struct decl_state *ctx, unsigned int keywords);
+
+typedef struct token *declarator_t(struct token *, struct decl_state *);
+static declarator_t
+	struct_specifier, union_specifier, enum_specifier,
+	attribute_specifier, typeof_specifier, parse_asm_declarator,
+	typedef_specifier, inline_specifier, auto_specifier,
+	register_specifier, static_specifier, extern_specifier,
+	thread_specifier, const_qualifier, volatile_qualifier;
+
+static struct token *parse_if_statement(struct token *token, struct statement *stmt);
+static struct token *parse_return_statement(struct token *token, struct statement *stmt);
+static struct token *parse_loop_iterator(struct token *token, struct statement *stmt);
+static struct token *parse_default_statement(struct token *token, struct statement *stmt);
+static struct token *parse_case_statement(struct token *token, struct statement *stmt);
+static struct token *parse_switch_statement(struct token *token, struct statement *stmt);
+static struct token *parse_for_statement(struct token *token, struct statement *stmt);
+static struct token *parse_while_statement(struct token *token, struct statement *stmt);
+static struct token *parse_do_statement(struct token *token, struct statement *stmt);
+static struct token *parse_goto_statement(struct token *token, struct statement *stmt);
+static struct token *parse_context_statement(struct token *token, struct statement *stmt);
+static struct token *parse_range_statement(struct token *token, struct statement *stmt);
+static struct token *parse_asm_statement(struct token *token, struct statement *stmt);
+static struct token *toplevel_asm_declaration(struct token *token, struct symbol_list **list);
+static struct token *parse_static_assert(struct token *token, struct symbol_list **unused);
+
+typedef struct token *attr_t(struct token *, struct symbol *,
+			     struct decl_state *);
+
+static attr_t
+	attribute_packed, attribute_aligned, attribute_modifier,
+	attribute_bitwise,
+	attribute_address_space, attribute_context,
+	attribute_designated_init,
+	attribute_transparent_union, ignore_attribute,
+	attribute_mode, attribute_force;
+
+typedef struct symbol *to_mode_t(struct symbol *);
+
+static to_mode_t
+	to_QI_mode, to_HI_mode, to_SI_mode, to_DI_mode, to_TI_mode, to_word_mode;
+
+enum {
+	Set_T = 1,
+	Set_S = 2,
+	Set_Char = 4,
+	Set_Int = 8,
+	Set_Double = 16,
+	Set_Float = 32,
+	Set_Signed = 64,
+	Set_Unsigned = 128,
+	Set_Short = 256,
+	Set_Long = 512,
+	Set_Vlong = 1024,
+	Set_Int128 = 2048,
+	Set_Any = Set_T | Set_Short | Set_Long | Set_Signed | Set_Unsigned
+};
+
+enum {
+	CInt = 0, CSInt, CUInt, CReal, CChar, CSChar, CUChar,
+};
+
+enum {
+	SNone = 0, STypedef, SAuto, SRegister, SExtern, SStatic, SForced, SMax,
+};
+
+static struct symbol_op typedef_op = {
+	.type = KW_MODIFIER,
+	.declarator = typedef_specifier,
+};
+
+static struct symbol_op inline_op = {
+	.type = KW_MODIFIER,
+	.declarator = inline_specifier,
+};
+
+static declarator_t noreturn_specifier;
+static struct symbol_op noreturn_op = {
+	.type = KW_MODIFIER,
+	.declarator = noreturn_specifier,
+};
+
+static declarator_t alignas_specifier;
+static struct symbol_op alignas_op = {
+	.type = KW_MODIFIER,
+	.declarator = alignas_specifier,
+};
+
+static struct symbol_op auto_op = {
+	.type = KW_MODIFIER,
+	.declarator = auto_specifier,
+};
+
+static struct symbol_op register_op = {
+	.type = KW_MODIFIER,
+	.declarator = register_specifier,
+};
+
+static struct symbol_op static_op = {
+	.type = KW_MODIFIER,
+	.declarator = static_specifier,
+};
+
+static struct symbol_op extern_op = {
+	.type = KW_MODIFIER,
+	.declarator = extern_specifier,
+};
+
+static struct symbol_op thread_op = {
+	.type = KW_MODIFIER,
+	.declarator = thread_specifier,
+};
+
+static struct symbol_op const_op = {
+	.type = KW_QUALIFIER,
+	.declarator = const_qualifier,
+};
+
+static struct symbol_op volatile_op = {
+	.type = KW_QUALIFIER,
+	.declarator = volatile_qualifier,
+};
+
+static struct symbol_op restrict_op = {
+	.type = KW_QUALIFIER,
+};
+
+static struct symbol_op typeof_op = {
+	.type = KW_SPECIFIER,
+	.declarator = typeof_specifier,
+	.test = Set_Any,
+	.set = Set_S|Set_T,
+};
+
+static struct symbol_op attribute_op = {
+	.type = KW_ATTRIBUTE,
+	.declarator = attribute_specifier,
+};
+
+static struct symbol_op struct_op = {
+	.type = KW_SPECIFIER,
+	.declarator = struct_specifier,
+	.test = Set_Any,
+	.set = Set_S|Set_T,
+};
+
+static struct symbol_op union_op = {
+	.type = KW_SPECIFIER,
+	.declarator = union_specifier,
+	.test = Set_Any,
+	.set = Set_S|Set_T,
+};
+
+static struct symbol_op enum_op = {
+	.type = KW_SPECIFIER,
+	.declarator = enum_specifier,
+	.test = Set_Any,
+	.set = Set_S|Set_T,
+};
+
+static struct symbol_op spec_op = {
+	.type = KW_SPECIFIER | KW_EXACT,
+	.test = Set_Any,
+	.set = Set_S|Set_T,
+};
+
+static struct symbol_op char_op = {
+	.type = KW_SPECIFIER,
+	.test = Set_T|Set_Long|Set_Short,
+	.set = Set_T|Set_Char,
+	.class = CChar,
+};
+
+static struct symbol_op int_op = {
+	.type = KW_SPECIFIER,
+	.test = Set_T,
+	.set = Set_T|Set_Int,
+};
+
+static struct symbol_op double_op = {
+	.type = KW_SPECIFIER,
+	.test = Set_T|Set_Signed|Set_Unsigned|Set_Short|Set_Vlong,
+	.set = Set_T|Set_Double,
+	.class = CReal,
+};
+
+/* FIXME: this is not even slightly right. */
+static struct symbol_op complex_op = {
+	.type = KW_SPECIFIER,
+	.test = 0, //Set_T|Set_Signed|Set_Unsigned|Set_Short|Set_Vlong,
+	.set = 0, //Set_Double, //Set_T,Set_Double,
+	.class = CReal,
+};
+
+static struct symbol_op float_op = {
+	.type = KW_SPECIFIER | KW_SHORT,
+	.test = Set_T|Set_Signed|Set_Unsigned|Set_Short|Set_Long,
+	.set = Set_T|Set_Float,
+	.class = CReal,
+};
+
+static struct symbol_op short_op = {
+	.type = KW_SPECIFIER | KW_SHORT,
+	.test = Set_S|Set_Char|Set_Float|Set_Double|Set_Long|Set_Short,
+	.set = Set_Short,
+};
+
+static struct symbol_op signed_op = {
+	.type = KW_SPECIFIER,
+	.test = Set_S|Set_Float|Set_Double|Set_Signed|Set_Unsigned,
+	.set = Set_Signed,
+	.class = CSInt,
+};
+
+static struct symbol_op unsigned_op = {
+	.type = KW_SPECIFIER,
+	.test = Set_S|Set_Float|Set_Double|Set_Signed|Set_Unsigned,
+	.set = Set_Unsigned,
+	.class = CUInt,
+};
+
+static struct symbol_op long_op = {
+	.type = KW_SPECIFIER | KW_LONG,
+	.test = Set_S|Set_Char|Set_Float|Set_Short|Set_Vlong,
+	.set = Set_Long,
+};
+
+static struct symbol_op int128_op = {
+	.type = KW_SPECIFIER | KW_LONG,
+	.test = Set_S|Set_T|Set_Char|Set_Short|Set_Int|Set_Float|Set_Double|Set_Long|Set_Vlong|Set_Int128,
+	.set =  Set_T|Set_Int128,
+};
+
+static struct symbol_op if_op = {
+	.statement = parse_if_statement,
+};
+
+static struct symbol_op return_op = {
+	.statement = parse_return_statement,
+};
+
+static struct symbol_op loop_iter_op = {
+	.statement = parse_loop_iterator,
+};
+
+static struct symbol_op default_op = {
+	.statement = parse_default_statement,
+};
+
+static struct symbol_op case_op = {
+	.statement = parse_case_statement,
+};
+
+static struct symbol_op switch_op = {
+	.statement = parse_switch_statement,
+};
+
+static struct symbol_op for_op = {
+	.statement = parse_for_statement,
+};
+
+static struct symbol_op while_op = {
+	.statement = parse_while_statement,
+};
+
+static struct symbol_op do_op = {
+	.statement = parse_do_statement,
+};
+
+static struct symbol_op goto_op = {
+	.statement = parse_goto_statement,
+};
+
+static struct symbol_op __context___op = {
+	.statement = parse_context_statement,
+};
+
+static struct symbol_op range_op = {
+	.statement = parse_range_statement,
+};
+
+static struct symbol_op asm_op = {
+	.type = KW_ASM,
+	.declarator = parse_asm_declarator,
+	.statement = parse_asm_statement,
+	.toplevel = toplevel_asm_declaration,
+};
+
+static struct symbol_op static_assert_op = {
+	.toplevel = parse_static_assert,
+};
+
+static struct symbol_op packed_op = {
+	.attribute = attribute_packed,
+};
+
+static struct symbol_op aligned_op = {
+	.attribute = attribute_aligned,
+};
+
+static struct symbol_op attr_mod_op = {
+	.attribute = attribute_modifier,
+};
+
+static struct symbol_op attr_bitwise_op = {
+	.attribute = attribute_bitwise,
+};
+
+static struct symbol_op attr_force_op = {
+	.attribute = attribute_force,
+};
+
+static struct symbol_op address_space_op = {
+	.attribute = attribute_address_space,
+};
+
+static struct symbol_op mode_op = {
+	.attribute = attribute_mode,
+};
+
+static struct symbol_op context_op = {
+	.attribute = attribute_context,
+};
+
+static struct symbol_op designated_init_op = {
+	.attribute = attribute_designated_init,
+};
+
+static struct symbol_op transparent_union_op = {
+	.attribute = attribute_transparent_union,
+};
+
+static struct symbol_op ignore_attr_op = {
+	.attribute = ignore_attribute,
+};
+
+static struct symbol_op mode_QI_op = {
+	.type = KW_MODE,
+	.to_mode = to_QI_mode
+};
+
+static struct symbol_op mode_HI_op = {
+	.type = KW_MODE,
+	.to_mode = to_HI_mode
+};
+
+static struct symbol_op mode_SI_op = {
+	.type = KW_MODE,
+	.to_mode = to_SI_mode
+};
+
+static struct symbol_op mode_DI_op = {
+	.type = KW_MODE,
+	.to_mode = to_DI_mode
+};
+
+static struct symbol_op mode_TI_op = {
+	.type = KW_MODE,
+	.to_mode = to_TI_mode
+};
+
+static struct symbol_op mode_word_op = {
+	.type = KW_MODE,
+	.to_mode = to_word_mode
+};
+
+/* Using NS_TYPEDEF will also make the keyword a reserved one */
+static struct init_keyword {
+	const char *name;
+	enum namespace ns;
+	unsigned long modifiers;
+	struct symbol_op *op;
+	struct symbol *type;
+} keyword_table[] = {
+	/* Type qualifiers */
+	{ "const",	NS_TYPEDEF, .op = &const_op },
+	{ "__const",	NS_TYPEDEF, .op = &const_op },
+	{ "__const__",	NS_TYPEDEF, .op = &const_op },
+	{ "volatile",	NS_TYPEDEF, .op = &volatile_op },
+	{ "__volatile",		NS_TYPEDEF, .op = &volatile_op },
+	{ "__volatile__", 	NS_TYPEDEF, .op = &volatile_op },
+
+	/* Typedef.. */
+	{ "typedef",	NS_TYPEDEF, .op = &typedef_op },
+
+	/* Type specifiers */
+	{ "void",	NS_TYPEDEF, .type = &void_ctype, .op = &spec_op},
+	{ "char",	NS_TYPEDEF, .op = &char_op },
+	{ "short",	NS_TYPEDEF, .op = &short_op },
+	{ "int",	NS_TYPEDEF, .op = &int_op },
+	{ "long",	NS_TYPEDEF, .op = &long_op },
+	{ "float",	NS_TYPEDEF, .op = &float_op },
+	{ "double",	NS_TYPEDEF, .op = &double_op },
+	{ "signed",	NS_TYPEDEF, .op = &signed_op },
+	{ "__signed",	NS_TYPEDEF, .op = &signed_op },
+	{ "__signed__",	NS_TYPEDEF, .op = &signed_op },
+	{ "unsigned",	NS_TYPEDEF, .op = &unsigned_op },
+	{ "__int128",	NS_TYPEDEF, .op = &int128_op },
+	{ "_Bool",	NS_TYPEDEF, .type = &bool_ctype, .op = &spec_op },
+	{ "_Complex",   NS_TYPEDEF, .op = &complex_op },
+
+	/* Predeclared types */
+	{ "__builtin_va_list", NS_TYPEDEF, .type = &ptr_ctype, .op = &spec_op },
+	{ "__builtin_ms_va_list", NS_TYPEDEF, .type = &ptr_ctype, .op = &spec_op },
+	{ "__int128_t",	NS_TYPEDEF, .type = &lllong_ctype, .op = &spec_op },
+	{ "__uint128_t",NS_TYPEDEF, .type = &ulllong_ctype, .op = &spec_op },
+
+	/* Extended types */
+	{ "typeof", 	NS_TYPEDEF, .op = &typeof_op },
+	{ "__typeof", 	NS_TYPEDEF, .op = &typeof_op },
+	{ "__typeof__",	NS_TYPEDEF, .op = &typeof_op },
+
+	{ "__attribute",   NS_TYPEDEF, .op = &attribute_op },
+	{ "__attribute__", NS_TYPEDEF, .op = &attribute_op },
+
+	{ "struct",	NS_TYPEDEF, .op = &struct_op },
+	{ "union", 	NS_TYPEDEF, .op = &union_op },
+	{ "enum", 	NS_TYPEDEF, .op = &enum_op },
+
+	{ "inline",	NS_TYPEDEF, .op = &inline_op },
+	{ "__inline",	NS_TYPEDEF, .op = &inline_op },
+	{ "__inline__",	NS_TYPEDEF, .op = &inline_op },
+
+	{ "_Noreturn",	NS_TYPEDEF, .op = &noreturn_op },
+
+	{ "_Alignas",	NS_TYPEDEF, .op = &alignas_op },
+
+	/* Ignored for now.. */
+	{ "restrict",	NS_TYPEDEF, .op = &restrict_op},
+	{ "__restrict",	NS_TYPEDEF, .op = &restrict_op},
+	{ "__restrict__",	NS_TYPEDEF, .op = &restrict_op},
+
+	/* Static assertion */
+	{ "_Static_assert", NS_KEYWORD, .op = &static_assert_op },
+
+	/* Storage class */
+	{ "auto",	NS_TYPEDEF, .op = &auto_op },
+	{ "register",	NS_TYPEDEF, .op = &register_op },
+	{ "static",	NS_TYPEDEF, .op = &static_op },
+	{ "extern",	NS_TYPEDEF, .op = &extern_op },
+	{ "__thread",	NS_TYPEDEF, .op = &thread_op },
+	{ "_Thread_local",	NS_TYPEDEF, .op = &thread_op },
+
+	/* Statement */
+	{ "if",		NS_KEYWORD, .op = &if_op },
+	{ "return",	NS_KEYWORD, .op = &return_op },
+	{ "break",	NS_KEYWORD, .op = &loop_iter_op },
+	{ "continue",	NS_KEYWORD, .op = &loop_iter_op },
+	{ "default",	NS_KEYWORD, .op = &default_op },
+	{ "case",	NS_KEYWORD, .op = &case_op },
+	{ "switch",	NS_KEYWORD, .op = &switch_op },
+	{ "for",	NS_KEYWORD, .op = &for_op },
+	{ "while",	NS_KEYWORD, .op = &while_op },
+	{ "do",		NS_KEYWORD, .op = &do_op },
+	{ "goto",	NS_KEYWORD, .op = &goto_op },
+	{ "__context__",NS_KEYWORD, .op = &__context___op },
+	{ "__range__",	NS_KEYWORD, .op = &range_op },
+	{ "asm",	NS_KEYWORD, .op = &asm_op },
+	{ "__asm",	NS_KEYWORD, .op = &asm_op },
+	{ "__asm__",	NS_KEYWORD, .op = &asm_op },
+
+	/* Attribute */
+	{ "packed",	NS_KEYWORD, .op = &packed_op },
+	{ "__packed__",	NS_KEYWORD, .op = &packed_op },
+	{ "aligned",	NS_KEYWORD, .op = &aligned_op },
+	{ "__aligned__",NS_KEYWORD, .op = &aligned_op },
+	{ "nocast",	NS_KEYWORD,	MOD_NOCAST,	.op = &attr_mod_op },
+	{ "noderef",	NS_KEYWORD,	MOD_NODEREF,	.op = &attr_mod_op },
+	{ "safe",	NS_KEYWORD,	MOD_SAFE, 	.op = &attr_mod_op },
+	{ "force",	NS_KEYWORD,	.op = &attr_force_op },
+	{ "bitwise",	NS_KEYWORD,	MOD_BITWISE,	.op = &attr_bitwise_op },
+	{ "__bitwise__",NS_KEYWORD,	MOD_BITWISE,	.op = &attr_bitwise_op },
+	{ "address_space",NS_KEYWORD,	.op = &address_space_op },
+	{ "mode",	NS_KEYWORD,	.op = &mode_op },
+	{ "context",	NS_KEYWORD,	.op = &context_op },
+	{ "designated_init",	NS_KEYWORD,	.op = &designated_init_op },
+	{ "__transparent_union__",	NS_KEYWORD,	.op = &transparent_union_op },
+	{ "noreturn",	NS_KEYWORD,	MOD_NORETURN,	.op = &attr_mod_op },
+	{ "__noreturn__",	NS_KEYWORD,	MOD_NORETURN,	.op = &attr_mod_op },
+	{ "pure",	NS_KEYWORD,	MOD_PURE,	.op = &attr_mod_op },
+	{"__pure__",	NS_KEYWORD,	MOD_PURE,	.op = &attr_mod_op },
+	{"const",	NS_KEYWORD,	MOD_PURE,	.op = &attr_mod_op },
+	{"__const",	NS_KEYWORD,	MOD_PURE,	.op = &attr_mod_op },
+	{"__const__",	NS_KEYWORD,	MOD_PURE,	.op = &attr_mod_op },
+
+	{ "__mode__",	NS_KEYWORD,	.op = &mode_op },
+	{ "QI",		NS_KEYWORD,	MOD_CHAR,	.op = &mode_QI_op },
+	{ "__QI__",	NS_KEYWORD,	MOD_CHAR,	.op = &mode_QI_op },
+	{ "HI",		NS_KEYWORD,	MOD_SHORT,	.op = &mode_HI_op },
+	{ "__HI__",	NS_KEYWORD,	MOD_SHORT,	.op = &mode_HI_op },
+	{ "SI",		NS_KEYWORD,			.op = &mode_SI_op },
+	{ "__SI__",	NS_KEYWORD,			.op = &mode_SI_op },
+	{ "DI",		NS_KEYWORD,	MOD_LONGLONG,	.op = &mode_DI_op },
+	{ "__DI__",	NS_KEYWORD,	MOD_LONGLONG,	.op = &mode_DI_op },
+	{ "TI",		NS_KEYWORD,	MOD_LONGLONGLONG,	.op = &mode_TI_op },
+	{ "__TI__",	NS_KEYWORD,	MOD_LONGLONGLONG,	.op = &mode_TI_op },
+	{ "word",	NS_KEYWORD,	MOD_LONG,	.op = &mode_word_op },
+	{ "__word__",	NS_KEYWORD,	MOD_LONG,	.op = &mode_word_op },
+};
+
+
+static const char *ignored_attributes[] = {
+
+#define GCC_ATTR(x)		\
+	STRINGIFY(x), 		\
+	STRINGIFY(__##x##__),
+
+#include "gcc-attr-list.h"
+
+#undef GCC_ATTR
+
+	"bounded",
+	"__bounded__",
+	"__noclone",
+	"__nonnull",
+	"__nothrow",
+};
+
+
+void init_parser(int stream)
+{
+	int i;
+	for (i = 0; i < ARRAY_SIZE(keyword_table); i++) {
+		struct init_keyword *ptr = keyword_table + i;
+		struct symbol *sym = create_symbol(stream, ptr->name, SYM_KEYWORD, ptr->ns);
+		sym->ident->keyword = 1;
+		if (ptr->ns == NS_TYPEDEF)
+			sym->ident->reserved = 1;
+		sym->ctype.modifiers = ptr->modifiers;
+		sym->ctype.base_type = ptr->type;
+		sym->op = ptr->op;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(ignored_attributes); i++) {
+		const char * name = ignored_attributes[i];
+		struct symbol *sym = create_symbol(stream, name, SYM_KEYWORD,
+						   NS_KEYWORD);
+		if (!sym->op) {
+			sym->ident->keyword = 1;
+			sym->op = &ignore_attr_op;
+		}
+	}
+}
+
+
+// Add a symbol to the list of function-local symbols
+static void fn_local_symbol(struct symbol *sym)
+{
+	if (function_symbol_list)
+		add_symbol(function_symbol_list, sym);
+}
+
+static int SENTINEL_ATTR match_idents(struct token *token, ...)
+{
+	va_list args;
+	struct ident * next;
+
+	if (token_type(token) != TOKEN_IDENT)
+		return 0;
+
+	va_start(args, token);
+	do {
+		next = va_arg(args, struct ident *);
+	} while (next && token->ident != next);
+	va_end(args);
+
+	return next && token->ident == next;
+}
+
+
+struct statement *alloc_statement(struct position pos, int type)
+{
+	struct statement *stmt = __alloc_statement(0);
+	stmt->type = type;
+	stmt->pos = pos;
+	return stmt;
+}
+
+static struct token *struct_declaration_list(struct token *token, struct symbol_list **list);
+
+static void apply_ctype(struct position pos, struct ctype *thistype, struct ctype *ctype);
+
+static void apply_modifiers(struct position pos, struct decl_state *ctx)
+{
+	struct symbol *ctype;
+	if (!ctx->mode)
+		return;
+	ctype = ctx->mode->to_mode(ctx->ctype.base_type);
+	if (!ctype)
+		sparse_error(pos, "don't know how to apply mode to %s",
+				show_typename(ctx->ctype.base_type));
+	else
+		ctx->ctype.base_type = ctype;
+	
+}
+
+static struct symbol * alloc_indirect_symbol(struct position pos, struct ctype *ctype, int type)
+{
+	struct symbol *sym = alloc_symbol(pos, type);
+
+	sym->ctype.base_type = ctype->base_type;
+	sym->ctype.modifiers = ctype->modifiers;
+
+	ctype->base_type = sym;
+	ctype->modifiers = 0;
+	return sym;
+}
+
+/*
+ * NOTE! NS_LABEL is not just a different namespace,
+ * it also ends up using function scope instead of the
+ * regular symbol scope.
+ */
+struct symbol *label_symbol(struct token *token)
+{
+	struct symbol *sym = lookup_symbol(token->ident, NS_LABEL);
+	if (!sym) {
+		sym = alloc_symbol(token->pos, SYM_LABEL);
+		bind_symbol(sym, token->ident, NS_LABEL);
+		fn_local_symbol(sym);
+	}
+	return sym;
+}
+
+static struct token *struct_union_enum_specifier(enum type type,
+	struct token *token, struct decl_state *ctx,
+	struct token *(*parse)(struct token *, struct symbol *))
+{
+	struct symbol *sym;
+	struct position *repos;
+
+	token = handle_attributes(token, ctx, KW_ATTRIBUTE);
+	if (token_type(token) == TOKEN_IDENT) {
+		sym = lookup_symbol(token->ident, NS_STRUCT);
+		if (!sym ||
+		    (is_outer_scope(sym->scope) &&
+		     (match_op(token->next,';') || match_op(token->next,'{')))) {
+			// Either a new symbol, or else an out-of-scope
+			// symbol being redefined.
+			sym = alloc_symbol(token->pos, type);
+			bind_symbol(sym, token->ident, NS_STRUCT);
+		}
+		if (sym->type != type)
+			error_die(token->pos, "invalid tag applied to %s", show_typename (sym));
+		ctx->ctype.base_type = sym;
+		repos = &token->pos;
+		token = token->next;
+		if (match_op(token, '{')) {
+			struct decl_state attr = { .ctype.base_type = sym, };
+
+			// The following test is actually wrong for empty
+			// structs, but (1) they are not C99, (2) gcc does
+			// the same thing, and (3) it's easier.
+			if (sym->symbol_list)
+				error_die(token->pos, "redefinition of %s", show_typename (sym));
+			sym->pos = *repos;
+			token = parse(token->next, sym);
+			token = expect(token, '}', "at end of struct-union-enum-specifier");
+
+			token = handle_attributes(token, &attr, KW_ATTRIBUTE);
+			apply_ctype(token->pos, &attr.ctype, &sym->ctype);
+
+			// Mark the structure as needing re-examination
+			sym->examined = 0;
+			sym->endpos = token->pos;
+		}
+		return token;
+	}
+
+	// private struct/union/enum type
+	if (!match_op(token, '{')) {
+		sparse_error(token->pos, "expected declaration");
+		ctx->ctype.base_type = &bad_ctype;
+		return token;
+	}
+
+	sym = alloc_symbol(token->pos, type);
+	token = parse(token->next, sym);
+	ctx->ctype.base_type = sym;
+	token =  expect(token, '}', "at end of specifier");
+	sym->endpos = token->pos;
+
+	return token;
+}
+
+static struct token *parse_struct_declaration(struct token *token, struct symbol *sym)
+{
+	struct symbol *field, *last = NULL;
+	struct token *res;
+	res = struct_declaration_list(token, &sym->symbol_list);
+	FOR_EACH_PTR(sym->symbol_list, field) {
+		if (!field->ident) {
+			struct symbol *base = field->ctype.base_type;
+			if (base && base->type == SYM_BITFIELD)
+				continue;
+		}
+		if (last)
+			last->next_subobject = field;
+		last = field;
+	} END_FOR_EACH_PTR(field);
+	return res;
+}
+
+static struct token *parse_union_declaration(struct token *token, struct symbol *sym)
+{
+	return struct_declaration_list(token, &sym->symbol_list);
+}
+
+static struct token *struct_specifier(struct token *token, struct decl_state *ctx)
+{
+	return struct_union_enum_specifier(SYM_STRUCT, token, ctx, parse_struct_declaration);
+}
+
+static struct token *union_specifier(struct token *token, struct decl_state *ctx)
+{
+	return struct_union_enum_specifier(SYM_UNION, token, ctx, parse_union_declaration);
+}
+
+
+typedef struct {
+	int x;
+	unsigned long long y;
+} Num;
+
+static void upper_boundary(Num *n, Num *v)
+{
+	if (n->x > v->x)
+		return;
+	if (n->x < v->x) {
+		*n = *v;
+		return;
+	}
+	if (n->y < v->y)
+		n->y = v->y;
+}
+
+static void lower_boundary(Num *n, Num *v)
+{
+	if (n->x < v->x)
+		return;
+	if (n->x > v->x) {
+		*n = *v;
+		return;
+	}
+	if (n->y > v->y)
+		n->y = v->y;
+}
+
+static int type_is_ok(struct symbol *type, Num *upper, Num *lower)
+{
+	int shift = type->bit_size;
+	int is_unsigned = type->ctype.modifiers & MOD_UNSIGNED;
+
+	if (!is_unsigned)
+		shift--;
+	if (upper->x == 0 && upper->y >> shift)
+		return 0;
+	if (lower->x == 0 || (!is_unsigned && (~lower->y >> shift) == 0))
+		return 1;
+	return 0;
+}
+
+static struct symbol *bigger_enum_type(struct symbol *s1, struct symbol *s2)
+{
+	if (s1->bit_size < s2->bit_size) {
+		s1 = s2;
+	} else if (s1->bit_size == s2->bit_size) {
+		if (s2->ctype.modifiers & MOD_UNSIGNED)
+			s1 = s2;
+	}
+	if (s1->bit_size < bits_in_int)
+		return &int_ctype;
+	return s1;
+}
+
+static void cast_enum_list(struct symbol_list *list, struct symbol *base_type)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		struct expression *expr = sym->initializer;
+		struct symbol *ctype;
+		if (expr->type != EXPR_VALUE)
+			continue;
+		ctype = expr->ctype;
+		if (ctype->bit_size == base_type->bit_size)
+			continue;
+		cast_value(expr, base_type, expr, ctype);
+	} END_FOR_EACH_PTR(sym);
+}
+
+static struct token *parse_enum_declaration(struct token *token, struct symbol *parent)
+{
+	unsigned long long lastval = 0;
+	struct symbol *ctype = NULL, *base_type = NULL;
+	Num upper = {-1, 0}, lower = {1, 0};
+
+	parent->examined = 1;
+	parent->ctype.base_type = &int_ctype;
+	while (token_type(token) == TOKEN_IDENT) {
+		struct expression *expr = NULL;
+		struct token *next = token->next;
+		struct symbol *sym;
+
+		if (match_op(next, '=')) {
+			next = constant_expression(next->next, &expr);
+			lastval = get_expression_value(expr);
+			ctype = &void_ctype;
+			if (expr && expr->ctype)
+				ctype = expr->ctype;
+		} else if (!ctype) {
+			ctype = &int_ctype;
+		} else if (is_int_type(ctype)) {
+			lastval++;
+		} else {
+			error_die(token->pos, "can't increment the last enum member");
+		}
+
+		if (!expr) {
+			expr = alloc_expression(token->pos, EXPR_VALUE);
+			expr->value = lastval;
+			expr->ctype = ctype;
+		}
+
+		sym = alloc_symbol(token->pos, SYM_NODE);
+		bind_symbol(sym, token->ident, NS_SYMBOL);
+		sym->ctype.modifiers &= ~MOD_ADDRESSABLE;
+		sym->initializer = expr;
+		sym->enum_member = 1;
+		sym->ctype.base_type = parent;
+		add_ptr_list(&parent->symbol_list, sym);
+
+		if (base_type != &bad_ctype) {
+			if (ctype->type == SYM_NODE)
+				ctype = ctype->ctype.base_type;
+			if (ctype->type == SYM_ENUM) {
+				if (ctype == parent)
+					ctype = base_type;
+				else 
+					ctype = ctype->ctype.base_type;
+			}
+			/*
+			 * base_type rules:
+			 *  - if all enums are of the same type, then
+			 *    the base_type is that type (two first
+			 *    cases)
+			 *  - if enums are of different types, they
+			 *    all have to be integer types, and the
+			 *    base type is at least "int_ctype".
+			 *  - otherwise the base_type is "bad_ctype".
+			 */
+			if (!base_type) {
+				base_type = ctype;
+			} else if (ctype == base_type) {
+				/* nothing */
+			} else if (is_int_type(base_type) && is_int_type(ctype)) {
+				base_type = bigger_enum_type(base_type, ctype);
+			} else
+				base_type = &bad_ctype;
+			parent->ctype.base_type = base_type;
+		}
+		if (is_int_type(base_type)) {
+			Num v = {.y = lastval};
+			if (ctype->ctype.modifiers & MOD_UNSIGNED)
+				v.x = 0;
+			else if ((long long)lastval >= 0)
+				v.x = 0;
+			else
+				v.x = -1;
+			upper_boundary(&upper, &v);
+			lower_boundary(&lower, &v);
+		}
+		token = next;
+
+		sym->endpos = token->pos;
+
+		if (!match_op(token, ','))
+			break;
+		token = token->next;
+	}
+	if (!base_type) {
+		sparse_error(token->pos, "bad enum definition");
+		base_type = &bad_ctype;
+	}
+	else if (!is_int_type(base_type))
+		base_type = base_type;
+	else if (type_is_ok(base_type, &upper, &lower))
+		base_type = base_type;
+	else if (type_is_ok(&int_ctype, &upper, &lower))
+		base_type = &int_ctype;
+	else if (type_is_ok(&uint_ctype, &upper, &lower))
+		base_type = &uint_ctype;
+	else if (type_is_ok(&long_ctype, &upper, &lower))
+		base_type = &long_ctype;
+	else if (type_is_ok(&ulong_ctype, &upper, &lower))
+		base_type = &ulong_ctype;
+	else if (type_is_ok(&llong_ctype, &upper, &lower))
+		base_type = &llong_ctype;
+	else if (type_is_ok(&ullong_ctype, &upper, &lower))
+		base_type = &ullong_ctype;
+	else
+		base_type = &bad_ctype;
+	parent->ctype.base_type = base_type;
+	parent->ctype.modifiers |= (base_type->ctype.modifiers & MOD_UNSIGNED);
+	parent->examined = 0;
+
+	cast_enum_list(parent->symbol_list, base_type);
+
+	return token;
+}
+
+static struct token *enum_specifier(struct token *token, struct decl_state *ctx)
+{
+	struct token *ret = struct_union_enum_specifier(SYM_ENUM, token, ctx, parse_enum_declaration);
+	struct ctype *ctype = &ctx->ctype.base_type->ctype;
+
+	if (!ctype->base_type)
+		ctype->base_type = &incomplete_ctype;
+
+	return ret;
+}
+
+static struct token *typeof_specifier(struct token *token, struct decl_state *ctx)
+{
+	struct symbol *sym;
+
+	if (!match_op(token, '(')) {
+		sparse_error(token->pos, "expected '(' after typeof");
+		return token;
+	}
+	if (lookup_type(token->next)) {
+		token = typename(token->next, &sym, NULL);
+		ctx->ctype.base_type = sym->ctype.base_type;
+		apply_ctype(token->pos, &sym->ctype, &ctx->ctype);
+	} else {
+		struct symbol *typeof_sym = alloc_symbol(token->pos, SYM_TYPEOF);
+		token = parse_expression(token->next, &typeof_sym->initializer);
+
+		typeof_sym->endpos = token->pos;
+		if (!typeof_sym->initializer) {
+			sparse_error(token->pos, "expected expression after the '(' token");
+			typeof_sym = &bad_ctype;
+		}
+		ctx->ctype.base_type = typeof_sym;
+	}
+	return expect(token, ')', "after typeof");
+}
+
+static struct token *ignore_attribute(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	struct expression *expr = NULL;
+	if (match_op(token, '('))
+		token = parens_expression(token, &expr, "in attribute");
+	return token;
+}
+
+static struct token *attribute_packed(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	if (!ctx->ctype.alignment)
+		ctx->ctype.alignment = 1;
+	return token;
+}
+
+static struct token *attribute_aligned(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	int alignment = max_alignment;
+	struct expression *expr = NULL;
+
+	if (match_op(token, '(')) {
+		token = parens_expression(token, &expr, "in attribute");
+		if (expr)
+			alignment = const_expression_value(expr);
+	}
+	if (alignment & (alignment-1)) {
+		warning(token->pos, "I don't like non-power-of-2 alignments");
+		return token;
+	} else if (alignment > ctx->ctype.alignment)
+		ctx->ctype.alignment = alignment;
+	return token;
+}
+
+static void apply_qualifier(struct position *pos, struct ctype *ctx, unsigned long qual)
+{
+	if (ctx->modifiers & qual)
+		warning(*pos, "duplicate %s", modifier_string(qual));
+	ctx->modifiers |= qual;
+}
+
+static struct token *attribute_modifier(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	apply_qualifier(&token->pos, &ctx->ctype, attr->ctype.modifiers);
+	return token;
+}
+
+static struct token *attribute_bitwise(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	if (Wbitwise)
+		attribute_modifier(token, attr, ctx);
+	return token;
+}
+
+static struct token *attribute_address_space(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	struct expression *expr = NULL;
+	int as;
+	token = expect(token, '(', "after address_space attribute");
+	token = conditional_expression(token, &expr);
+	if (expr) {
+		as = const_expression_value(expr);
+		if (Waddress_space && as)
+			ctx->ctype.as = as;
+	}
+	token = expect(token, ')', "after address_space attribute");
+	return token;
+}
+
+static struct symbol *to_QI_mode(struct symbol *ctype)
+{
+	if (ctype->ctype.base_type != &int_type)
+		return NULL;
+	if (ctype == &char_ctype)
+		return ctype;
+	return ctype->ctype.modifiers & MOD_UNSIGNED ? &uchar_ctype
+						     : &schar_ctype;
+}
+
+static struct symbol *to_HI_mode(struct symbol *ctype)
+{
+	if (ctype->ctype.base_type != &int_type)
+		return NULL;
+	return ctype->ctype.modifiers & MOD_UNSIGNED ? &ushort_ctype
+						     : &sshort_ctype;
+}
+
+static struct symbol *to_SI_mode(struct symbol *ctype)
+{
+	if (ctype->ctype.base_type != &int_type)
+		return NULL;
+	return ctype->ctype.modifiers & MOD_UNSIGNED ? &uint_ctype
+						     : &sint_ctype;
+}
+
+static struct symbol *to_DI_mode(struct symbol *ctype)
+{
+	if (ctype->ctype.base_type != &int_type)
+		return NULL;
+	return ctype->ctype.modifiers & MOD_UNSIGNED ? &ullong_ctype
+						     : &sllong_ctype;
+}
+
+static struct symbol *to_TI_mode(struct symbol *ctype)
+{
+	if (ctype->ctype.base_type != &int_type)
+		return NULL;
+	return ctype->ctype.modifiers & MOD_UNSIGNED ? &ulllong_ctype
+						     : &slllong_ctype;
+}
+
+static struct symbol *to_word_mode(struct symbol *ctype)
+{
+	if (ctype->ctype.base_type != &int_type)
+		return NULL;
+	return ctype->ctype.modifiers & MOD_UNSIGNED ? &ulong_ctype
+						     : &slong_ctype;
+}
+
+static struct token *attribute_mode(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	token = expect(token, '(', "after mode attribute");
+	if (token_type(token) == TOKEN_IDENT) {
+		struct symbol *mode = lookup_keyword(token->ident, NS_KEYWORD);
+		if (mode && mode->op->type == KW_MODE)
+			ctx->mode = mode->op;
+		else
+			sparse_error(token->pos, "unknown mode attribute %s\n", show_ident(token->ident));
+		token = token->next;
+	} else
+		sparse_error(token->pos, "expect attribute mode symbol\n");
+	token = expect(token, ')', "after mode attribute");
+	return token;
+}
+
+static struct token *attribute_context(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	struct context *context = alloc_context();
+	struct expression *args[3];
+	int argc = 0;
+
+	token = expect(token, '(', "after context attribute");
+	while (!match_op(token, ')')) {
+		struct expression *expr = NULL;
+		token = conditional_expression(token, &expr);
+		if (!expr)
+			break;
+		if (argc < 3)
+			args[argc++] = expr;
+		if (!match_op(token, ','))
+			break;
+		token = token->next;
+	}
+
+	switch(argc) {
+	case 0:
+		sparse_error(token->pos, "expected context input/output values");
+		break;
+	case 1:
+		context->in = get_expression_value(args[0]);
+		break;
+	case 2:
+		context->in = get_expression_value(args[0]);
+		context->out = get_expression_value(args[1]);
+		break;
+	case 3:
+		context->context = args[0];
+		context->in = get_expression_value(args[1]);
+		context->out = get_expression_value(args[2]);
+		break;
+	}
+
+	if (argc)
+		add_ptr_list(&ctx->ctype.contexts, context);
+
+	token = expect(token, ')', "after context attribute");
+	return token;
+}
+
+static struct token *attribute_designated_init(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	if (ctx->ctype.base_type && ctx->ctype.base_type->type == SYM_STRUCT)
+		ctx->ctype.base_type->designated_init = 1;
+	else
+		warning(token->pos, "attribute designated_init applied to non-structure type");
+	return token;
+}
+
+static struct token *attribute_transparent_union(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	if (Wtransparent_union)
+		warning(token->pos, "attribute __transparent_union__");
+
+	if (ctx->ctype.base_type && ctx->ctype.base_type->type == SYM_UNION)
+		ctx->ctype.base_type->transparent_union = 1;
+	else
+		warning(token->pos, "attribute __transparent_union__ applied to non-union type");
+	return token;
+}
+
+static struct token *recover_unknown_attribute(struct token *token)
+{
+	struct expression *expr = NULL;
+
+	if (Wunknown_attribute)
+		warning(token->pos, "attribute '%s': unknown attribute", show_ident(token->ident));
+	token = token->next;
+	if (match_op(token, '('))
+		token = parens_expression(token, &expr, "in attribute");
+	return token;
+}
+
+static struct token *attribute_specifier(struct token *token, struct decl_state *ctx)
+{
+	token = expect(token, '(', "after attribute");
+	token = expect(token, '(', "after attribute");
+
+	for (;;) {
+		struct ident *attribute_name;
+		struct symbol *attr;
+
+		if (eof_token(token))
+			break;
+		if (match_op(token, ';'))
+			break;
+		if (token_type(token) != TOKEN_IDENT)
+			break;
+		attribute_name = token->ident;
+		attr = lookup_keyword(attribute_name, NS_KEYWORD);
+		if (attr && attr->op->attribute)
+			token = attr->op->attribute(token->next, attr, ctx);
+		else
+			token = recover_unknown_attribute(token);
+
+		if (!match_op(token, ','))
+			break;
+		token = token->next;
+	}
+
+	token = expect(token, ')', "after attribute");
+	token = expect(token, ')', "after attribute");
+	return token;
+}
+
+static const char *storage_class[] = 
+{
+	[STypedef] = "typedef",
+	[SAuto] = "auto",
+	[SExtern] = "extern",
+	[SStatic] = "static",
+	[SRegister] = "register",
+	[SForced] = "[force]"
+};
+
+static unsigned long storage_modifiers(struct decl_state *ctx)
+{
+	static unsigned long mod[SMax] =
+	{
+		[SAuto] = MOD_AUTO,
+		[SExtern] = MOD_EXTERN,
+		[SStatic] = MOD_STATIC,
+		[SRegister] = MOD_REGISTER
+	};
+	return mod[ctx->storage_class] | (ctx->is_inline ? MOD_INLINE : 0)
+		| (ctx->is_tls ? MOD_TLS : 0);
+}
+
+static void set_storage_class(struct position *pos, struct decl_state *ctx, int class)
+{
+	/* __thread can be used alone, or with extern or static */
+	if (ctx->is_tls && (class != SStatic && class != SExtern)) {
+		sparse_error(*pos, "__thread can only be used alone, or with "
+				"extern or static");
+		return;
+	}
+
+	if (!ctx->storage_class) {
+		ctx->storage_class = class;
+		return;
+	}
+	if (ctx->storage_class == class)
+		sparse_error(*pos, "duplicate %s", storage_class[class]);
+	else
+		sparse_error(*pos, "multiple storage classes");
+}
+
+static struct token *typedef_specifier(struct token *next, struct decl_state *ctx)
+{
+	set_storage_class(&next->pos, ctx, STypedef);
+	return next;
+}
+
+static struct token *auto_specifier(struct token *next, struct decl_state *ctx)
+{
+	set_storage_class(&next->pos, ctx, SAuto);
+	return next;
+}
+
+static struct token *register_specifier(struct token *next, struct decl_state *ctx)
+{
+	set_storage_class(&next->pos, ctx, SRegister);
+	return next;
+}
+
+static struct token *static_specifier(struct token *next, struct decl_state *ctx)
+{
+	set_storage_class(&next->pos, ctx, SStatic);
+	return next;
+}
+
+static struct token *extern_specifier(struct token *next, struct decl_state *ctx)
+{
+	set_storage_class(&next->pos, ctx, SExtern);
+	return next;
+}
+
+static struct token *thread_specifier(struct token *next, struct decl_state *ctx)
+{
+	/* This GCC extension can be used alone, or with extern or static */
+	if (!ctx->storage_class || ctx->storage_class == SStatic
+			|| ctx->storage_class == SExtern) {
+		ctx->is_tls = 1;
+	} else {
+		sparse_error(next->pos, "__thread can only be used alone, or "
+				"with extern or static");
+	}
+
+	return next;
+}
+
+static struct token *attribute_force(struct token *token, struct symbol *attr, struct decl_state *ctx)
+{
+	set_storage_class(&token->pos, ctx, SForced);
+	return token;
+}
+
+static struct token *inline_specifier(struct token *next, struct decl_state *ctx)
+{
+	ctx->is_inline = 1;
+	return next;
+}
+
+static struct token *noreturn_specifier(struct token *next, struct decl_state *ctx)
+{
+	apply_qualifier(&next->pos, &ctx->ctype, MOD_NORETURN);
+	return next;
+}
+
+static struct token *alignas_specifier(struct token *token, struct decl_state *ctx)
+{
+	int alignment = 0;
+
+	if (!match_op(token, '(')) {
+		sparse_error(token->pos, "expected '(' after _Alignas");
+		return token;
+	}
+	if (lookup_type(token->next)) {
+		struct symbol *sym = NULL;
+		token = typename(token->next, &sym, NULL);
+		sym = examine_symbol_type(sym);
+		alignment = sym->ctype.alignment;
+		token = expect(token, ')', "after _Alignas(...");
+	} else {
+		struct expression *expr = NULL;
+		token = parens_expression(token, &expr, "after _Alignas");
+		if (!expr)
+			return token;
+		alignment = const_expression_value(expr);
+	}
+
+	if (alignment < 0) {
+		warning(token->pos, "non-positive alignment");
+		return token;
+	}
+	if (alignment & (alignment-1)) {
+		warning(token->pos, "non-power-of-2 alignment");
+		return token;
+	}
+	if (alignment > ctx->ctype.alignment)
+		ctx->ctype.alignment = alignment;
+	return token;
+}
+
+static struct token *const_qualifier(struct token *next, struct decl_state *ctx)
+{
+	apply_qualifier(&next->pos, &ctx->ctype, MOD_CONST);
+	return next;
+}
+
+static struct token *volatile_qualifier(struct token *next, struct decl_state *ctx)
+{
+	apply_qualifier(&next->pos, &ctx->ctype, MOD_VOLATILE);
+	return next;
+}
+
+static void apply_ctype(struct position pos, struct ctype *thistype, struct ctype *ctype)
+{
+	unsigned long mod = thistype->modifiers;
+
+	if (mod)
+		apply_qualifier(&pos, ctype, mod);
+
+	/* Context */
+	concat_ptr_list((struct ptr_list *)thistype->contexts,
+	                (struct ptr_list **)&ctype->contexts);
+
+	/* Alignment */
+	if (thistype->alignment > ctype->alignment)
+		ctype->alignment = thistype->alignment;
+
+	/* Address space */
+	if (thistype->as)
+		ctype->as = thistype->as;
+}
+
+static void specifier_conflict(struct position pos, int what, struct ident *new)
+{
+	const char *old;
+	if (what & (Set_S | Set_T))
+		goto Catch_all;
+	if (what & Set_Char)
+		old = "char";
+	else if (what & Set_Double)
+		old = "double";
+	else if (what & Set_Float)
+		old = "float";
+	else if (what & Set_Signed)
+		old = "signed";
+	else if (what & Set_Unsigned)
+		old = "unsigned";
+	else if (what & Set_Short)
+		old = "short";
+	else if (what & Set_Long)
+		old = "long";
+	else
+		old = "long long";
+	sparse_error(pos, "impossible combination of type specifiers: %s %s",
+			old, show_ident(new));
+	return;
+
+Catch_all:
+	sparse_error(pos, "two or more data types in declaration specifiers");
+}
+
+static struct symbol * const int_types[] =
+	{&short_ctype, &int_ctype, &long_ctype, &llong_ctype, &lllong_ctype};
+static struct symbol * const signed_types[] =
+	{&sshort_ctype, &sint_ctype, &slong_ctype, &sllong_ctype,
+	 &slllong_ctype};
+static struct symbol * const unsigned_types[] =
+	{&ushort_ctype, &uint_ctype, &ulong_ctype, &ullong_ctype,
+	 &ulllong_ctype};
+static struct symbol * const real_types[] =
+	{&float_ctype, &double_ctype, &ldouble_ctype};
+static struct symbol * const char_types[] =
+	{&char_ctype, &schar_ctype, &uchar_ctype};
+static struct symbol * const * const types[] = {
+	int_types + 1, signed_types + 1, unsigned_types + 1,
+	real_types + 1, char_types, char_types + 1, char_types + 2
+};
+
+struct symbol *ctype_integer(int size, int want_unsigned)
+{
+	return types[want_unsigned ? CUInt : CInt][size];
+}
+
+static struct token *handle_qualifiers(struct token *t, struct decl_state *ctx)
+{
+	while (token_type(t) == TOKEN_IDENT) {
+		struct symbol *s = lookup_symbol(t->ident, NS_TYPEDEF);
+		if (!s)
+			break;
+		if (s->type != SYM_KEYWORD)
+			break;
+		if (!(s->op->type & (KW_ATTRIBUTE | KW_QUALIFIER)))
+			break;
+		t = t->next;
+		if (s->op->declarator)
+			t = s->op->declarator(t, ctx);
+	}
+	return t;
+}
+
+static struct token *declaration_specifiers(struct token *token, struct decl_state *ctx)
+{
+	int seen = 0;
+	int class = CInt;
+	int size = 0;
+
+	while (token_type(token) == TOKEN_IDENT) {
+		struct symbol *s = lookup_symbol(token->ident,
+						 NS_TYPEDEF | NS_SYMBOL);
+		if (!s || !(s->namespace & NS_TYPEDEF))
+			break;
+		if (s->type != SYM_KEYWORD) {
+			if (seen & Set_Any)
+				break;
+			seen |= Set_S | Set_T;
+			ctx->ctype.base_type = s->ctype.base_type;
+			apply_ctype(token->pos, &s->ctype, &ctx->ctype);
+			token = token->next;
+			continue;
+		}
+		if (s->op->type & KW_SPECIFIER) {
+			if (seen & s->op->test) {
+				specifier_conflict(token->pos,
+						   seen & s->op->test,
+						   token->ident);
+				break;
+			}
+			seen |= s->op->set;
+			class += s->op->class;
+			if (s->op->set & Set_Int128)
+				size = 2;
+			if (s->op->type & KW_SHORT) {
+				size = -1;
+			} else if (s->op->type & KW_LONG && size++) {
+				if (class == CReal) {
+					specifier_conflict(token->pos,
+							   Set_Vlong,
+							   &double_ident);
+					break;
+				}
+				seen |= Set_Vlong;
+			}
+		}
+		token = token->next;
+		if (s->op->declarator)
+			token = s->op->declarator(token, ctx);
+		if (s->op->type & KW_EXACT) {
+			ctx->ctype.base_type = s->ctype.base_type;
+			ctx->ctype.modifiers |= s->ctype.modifiers;
+		}
+	}
+
+	if (!(seen & Set_S)) {	/* not set explicitly? */
+		struct symbol *base = &incomplete_ctype;
+		if (seen & Set_Any)
+			base = types[class][size];
+		ctx->ctype.base_type = base;
+	}
+
+	if (ctx->ctype.modifiers & MOD_BITWISE) {
+		struct symbol *type;
+		ctx->ctype.modifiers &= ~MOD_BITWISE;
+		if (!is_int_type(ctx->ctype.base_type)) {
+			sparse_error(token->pos, "invalid modifier");
+			return token;
+		}
+		type = alloc_symbol(token->pos, SYM_BASETYPE);
+		*type = *ctx->ctype.base_type;
+		type->ctype.modifiers &= ~MOD_SPECIFIER;
+		type->ctype.base_type = ctx->ctype.base_type;
+		type->type = SYM_RESTRICT;
+		ctx->ctype.base_type = type;
+		create_fouled(type);
+	}
+	return token;
+}
+
+static struct token *abstract_array_static_declarator(struct token *token, int *has_static)
+{
+	while (token->ident == &static_ident) {
+		if (*has_static)
+			sparse_error(token->pos, "duplicate array static declarator");
+
+		*has_static = 1;
+		token = token->next;
+	}
+	return token;
+
+}
+
+static struct token *abstract_array_declarator(struct token *token, struct symbol *sym)
+{
+	struct expression *expr = NULL;
+	int has_static = 0;
+
+	token = abstract_array_static_declarator(token, &has_static);
+
+	if (match_idents(token, &restrict_ident, &__restrict_ident, &__restrict___ident, NULL))
+		token = abstract_array_static_declarator(token->next, &has_static);
+	token = parse_expression(token, &expr);
+	sym->array_size = expr;
+	return token;
+}
+
+static struct token *parameter_type_list(struct token *, struct symbol *);
+static struct token *identifier_list(struct token *, struct symbol *);
+static struct token *declarator(struct token *token, struct decl_state *ctx);
+
+static struct token *skip_attribute(struct token *token)
+{
+	token = token->next;
+	if (match_op(token, '(')) {
+		int depth = 1;
+		token = token->next;
+		while (depth && !eof_token(token)) {
+			if (token_type(token) == TOKEN_SPECIAL) {
+				if (token->special == '(')
+					depth++;
+				else if (token->special == ')')
+					depth--;
+			}
+			token = token->next;
+		}
+	}
+	return token;
+}
+
+static struct token *skip_attributes(struct token *token)
+{
+	struct symbol *keyword;
+	for (;;) {
+		if (token_type(token) != TOKEN_IDENT)
+			break;
+		keyword = lookup_keyword(token->ident, NS_KEYWORD | NS_TYPEDEF);
+		if (!keyword || keyword->type != SYM_KEYWORD)
+			break;
+		if (!(keyword->op->type & KW_ATTRIBUTE))
+			break;
+		token = expect(token->next, '(', "after attribute");
+		token = expect(token, '(', "after attribute");
+		for (;;) {
+			if (eof_token(token))
+				break;
+			if (match_op(token, ';'))
+				break;
+			if (token_type(token) != TOKEN_IDENT)
+				break;
+			token = skip_attribute(token);
+			if (!match_op(token, ','))
+				break;
+			token = token->next;
+		}
+		token = expect(token, ')', "after attribute");
+		token = expect(token, ')', "after attribute");
+	}
+	return token;
+}
+
+static struct token *handle_attributes(struct token *token, struct decl_state *ctx, unsigned int keywords)
+{
+	struct symbol *keyword;
+	for (;;) {
+		if (token_type(token) != TOKEN_IDENT)
+			break;
+		keyword = lookup_keyword(token->ident, NS_KEYWORD | NS_TYPEDEF);
+		if (!keyword || keyword->type != SYM_KEYWORD)
+			break;
+		if (!(keyword->op->type & keywords))
+			break;
+		token = keyword->op->declarator(token->next, ctx);
+		keywords &= KW_ATTRIBUTE;
+	}
+	return token;
+}
+
+static int is_nested(struct token *token, struct token **p,
+		    int prefer_abstract)
+{
+	/*
+	 * This can be either a parameter list or a grouping.
+	 * For the direct (non-abstract) case, we know if must be
+	 * a parameter list if we already saw the identifier.
+	 * For the abstract case, we know if must be a parameter
+	 * list if it is empty or starts with a type.
+	 */
+	struct token *next = token->next;
+
+	*p = next = skip_attributes(next);
+
+	if (token_type(next) == TOKEN_IDENT) {
+		if (lookup_type(next))
+			return !prefer_abstract;
+		return 1;
+	}
+
+	if (match_op(next, ')') || match_op(next, SPECIAL_ELLIPSIS))
+		return 0;
+
+	return 1;
+}
+
+enum kind {
+	Empty, K_R, Proto, Bad_Func,
+};
+
+static enum kind which_func(struct token *token,
+			    struct ident **n,
+			    int prefer_abstract)
+{
+	struct token *next = token->next;
+
+	if (token_type(next) == TOKEN_IDENT) {
+		if (lookup_type(next))
+			return Proto;
+		/* identifier list not in definition; complain */
+		if (prefer_abstract)
+			warning(token->pos,
+				"identifier list not in definition");
+		return K_R;
+	}
+
+	if (token_type(next) != TOKEN_SPECIAL)
+		return Bad_Func;
+
+	if (next->special == ')') {
+		/* don't complain about those */
+		if (!n || match_op(next->next, ';'))
+		if (!n || match_op(next->next, ';') || match_op(next->next, ','))
+			return Empty;
+		if (Wstrict_prototypes)
+			warning(next->pos,
+				"non-ANSI function declaration of function '%s'",
+				show_ident(*n));
+		return Empty;
+	}
+
+	if (next->special == SPECIAL_ELLIPSIS) {
+		warning(next->pos,
+			"variadic functions must have one named argument");
+		return Proto;
+	}
+
+	return Bad_Func;
+}
+
+static struct token *direct_declarator(struct token *token, struct decl_state *ctx)
+{
+	struct ctype *ctype = &ctx->ctype;
+	struct token *next;
+	struct ident **p = ctx->ident;
+
+	if (ctx->ident && token_type(token) == TOKEN_IDENT) {
+		*ctx->ident = token->ident;
+		token = token->next;
+	} else if (match_op(token, '(') &&
+	    is_nested(token, &next, ctx->prefer_abstract)) {
+		struct symbol *base_type = ctype->base_type;
+		if (token->next != next)
+			next = handle_attributes(token->next, ctx,
+						  KW_ATTRIBUTE);
+		token = declarator(next, ctx);
+		token = expect(token, ')', "in nested declarator");
+		while (ctype->base_type != base_type)
+			ctype = &ctype->base_type->ctype;
+		p = NULL;
+	}
+
+	if (match_op(token, '(')) {
+		enum kind kind = which_func(token, p, ctx->prefer_abstract);
+		struct symbol *fn;
+		fn = alloc_indirect_symbol(token->pos, ctype, SYM_FN);
+		token = token->next;
+		if (kind == K_R)
+			token = identifier_list(token, fn);
+		else if (kind == Proto)
+			token = parameter_type_list(token, fn);
+		token = expect(token, ')', "in function declarator");
+		fn->endpos = token->pos;
+		return token;
+	}
+
+	while (match_op(token, '[')) {
+		struct symbol *array;
+		array = alloc_indirect_symbol(token->pos, ctype, SYM_ARRAY);
+		token = abstract_array_declarator(token->next, array);
+		token = expect(token, ']', "in abstract_array_declarator");
+		array->endpos = token->pos;
+		ctype = &array->ctype;
+	}
+	return token;
+}
+
+static struct token *pointer(struct token *token, struct decl_state *ctx)
+{
+	while (match_op(token,'*')) {
+		struct symbol *ptr = alloc_symbol(token->pos, SYM_PTR);
+		ptr->ctype.modifiers = ctx->ctype.modifiers;
+		ptr->ctype.base_type = ctx->ctype.base_type;
+		ptr->ctype.as = ctx->ctype.as;
+		ptr->ctype.contexts = ctx->ctype.contexts;
+		ctx->ctype.modifiers = 0;
+		ctx->ctype.base_type = ptr;
+		ctx->ctype.as = 0;
+		ctx->ctype.contexts = NULL;
+		ctx->ctype.alignment = 0;
+
+		token = handle_qualifiers(token->next, ctx);
+		ctx->ctype.base_type->endpos = token->pos;
+	}
+	return token;
+}
+
+static struct token *declarator(struct token *token, struct decl_state *ctx)
+{
+	token = pointer(token, ctx);
+	return direct_declarator(token, ctx);
+}
+
+static struct token *handle_bitfield(struct token *token, struct decl_state *ctx)
+{
+	struct ctype *ctype = &ctx->ctype;
+	struct expression *expr;
+	struct symbol *bitfield;
+	long long width;
+
+	if (ctype->base_type != &int_type && !is_int_type(ctype->base_type)) {
+		sparse_error(token->pos, "invalid bitfield specifier for type %s.",
+			show_typename(ctype->base_type));
+		// Parse this to recover gracefully.
+		return conditional_expression(token->next, &expr);
+	}
+
+	bitfield = alloc_indirect_symbol(token->pos, ctype, SYM_BITFIELD);
+	token = conditional_expression(token->next, &expr);
+	width = const_expression_value(expr);
+	bitfield->bit_size = width;
+
+	if (width < 0 || width > INT_MAX) {
+		sparse_error(token->pos, "invalid bitfield width, %lld.", width);
+		width = -1;
+	} else if (*ctx->ident && width == 0) {
+		sparse_error(token->pos, "invalid named zero-width bitfield `%s'",
+		     show_ident(*ctx->ident));
+		width = -1;
+	} else if (*ctx->ident) {
+		struct symbol *base_type = bitfield->ctype.base_type;
+		struct symbol *bitfield_type = base_type == &int_type ? bitfield : base_type;
+		int is_signed = !(bitfield_type->ctype.modifiers & MOD_UNSIGNED);
+		if (Wone_bit_signed_bitfield && width == 1 && is_signed) {
+			// Valid values are either {-1;0} or {0}, depending on integer
+			// representation.  The latter makes for very efficient code...
+			sparse_error(token->pos, "dubious one-bit signed bitfield");
+		}
+		if (Wdefault_bitfield_sign &&
+		    bitfield_type->type != SYM_ENUM &&
+		    !(bitfield_type->ctype.modifiers & MOD_EXPLICITLY_SIGNED) &&
+		    is_signed) {
+			// The sign of bitfields is unspecified by default.
+			warning(token->pos, "dubious bitfield without explicit `signed' or `unsigned'");
+		}
+	}
+	bitfield->bit_size = width;
+	bitfield->endpos = token->pos;
+	return token;
+}
+
+static struct token *declaration_list(struct token *token, struct symbol_list **list)
+{
+	struct decl_state ctx = {.prefer_abstract = 0};
+	struct ctype saved;
+	unsigned long mod;
+
+	token = declaration_specifiers(token, &ctx);
+	mod = storage_modifiers(&ctx);
+	saved = ctx.ctype;
+	for (;;) {
+		struct symbol *decl = alloc_symbol(token->pos, SYM_NODE);
+		ctx.ident = &decl->ident;
+
+		token = declarator(token, &ctx);
+		if (match_op(token, ':'))
+			token = handle_bitfield(token, &ctx);
+
+		token = handle_attributes(token, &ctx, KW_ATTRIBUTE);
+		apply_modifiers(token->pos, &ctx);
+
+		decl->ctype = ctx.ctype;
+		decl->ctype.modifiers |= mod;
+		decl->endpos = token->pos;
+		add_symbol(list, decl);
+		if (!match_op(token, ','))
+			break;
+		token = token->next;
+		ctx.ctype = saved;
+	}
+	return token;
+}
+
+static struct token *struct_declaration_list(struct token *token, struct symbol_list **list)
+{
+	while (!match_op(token, '}')) {
+		if (match_ident(token, &_Static_assert_ident)) {
+			token = parse_static_assert(token, NULL);
+			continue;
+		}
+		if (!match_op(token, ';'))
+			token = declaration_list(token, list);
+		if (!match_op(token, ';')) {
+			sparse_error(token->pos, "expected ; at end of declaration");
+			break;
+		}
+		token = token->next;
+	}
+	return token;
+}
+
+static struct token *parameter_declaration(struct token *token, struct symbol *sym)
+{
+	struct decl_state ctx = {.prefer_abstract = 1};
+
+	token = declaration_specifiers(token, &ctx);
+	ctx.ident = &sym->ident;
+	token = declarator(token, &ctx);
+	token = handle_attributes(token, &ctx, KW_ATTRIBUTE);
+	apply_modifiers(token->pos, &ctx);
+	sym->ctype = ctx.ctype;
+	sym->ctype.modifiers |= storage_modifiers(&ctx);
+	sym->endpos = token->pos;
+	sym->forced_arg = ctx.storage_class == SForced;
+	return token;
+}
+
+struct token *typename(struct token *token, struct symbol **p, int *forced)
+{
+	struct decl_state ctx = {.prefer_abstract = 1};
+	int class;
+	struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
+	*p = sym;
+	token = declaration_specifiers(token, &ctx);
+	token = declarator(token, &ctx);
+	apply_modifiers(token->pos, &ctx);
+	sym->ctype = ctx.ctype;
+	sym->endpos = token->pos;
+	class = ctx.storage_class;
+	if (forced) {
+		*forced = 0;
+		if (class == SForced) {
+			*forced = 1;
+			class = 0;
+		}
+	}
+	if (class)
+		warning(sym->pos, "storage class in typename (%s %s)",
+			storage_class[class], show_typename(sym));
+	return token;
+}
+
+static struct token *parse_underscore_Pragma(struct token *token)
+{
+	struct token *next;
+
+	next = token->next;
+	if (!match_op(next, '('))
+		return next;
+	next = next->next;
+	if (next->pos.type != TOKEN_STRING)
+		return next;
+	next = next->next;
+	if (!match_op(next, ')'))
+		return next;
+	return next->next;
+}
+
+static struct token *expression_statement(struct token *token, struct expression **tree)
+{
+	if (match_ident(token, &_Pragma_ident))
+		return parse_underscore_Pragma(token);
+
+	token = parse_expression(token, tree);
+	return expect(token, ';', "at end of statement");
+}
+
+static struct token *parse_asm_operands(struct token *token, struct statement *stmt,
+	struct expression_list **inout)
+{
+	struct expression *expr;
+
+	/* Allow empty operands */
+	if (match_op(token->next, ':') || match_op(token->next, ')'))
+		return token->next;
+	do {
+		struct ident *ident = NULL;
+		if (match_op(token->next, '[') &&
+		    token_type(token->next->next) == TOKEN_IDENT &&
+		    match_op(token->next->next->next, ']')) {
+			ident = token->next->next->ident;
+			token = token->next->next->next;
+		}
+		add_expression(inout, (struct expression *)ident); /* UGGLEE!!! */
+		token = primary_expression(token->next, &expr);
+		add_expression(inout, expr);
+		token = parens_expression(token, &expr, "in asm parameter");
+		add_expression(inout, expr);
+	} while (match_op(token, ','));
+	return token;
+}
+
+static struct token *parse_asm_clobbers(struct token *token, struct statement *stmt,
+	struct expression_list **clobbers)
+{
+	struct expression *expr;
+
+	do {
+		token = primary_expression(token->next, &expr);
+		if (expr)
+			add_expression(clobbers, expr);
+	} while (match_op(token, ','));
+	return token;
+}
+
+static struct token *parse_asm_labels(struct token *token, struct statement *stmt,
+		        struct symbol_list **labels)
+{
+	struct symbol *label;
+
+	do {
+		token = token->next; /* skip ':' and ',' */
+		if (token_type(token) != TOKEN_IDENT)
+			return token;
+		label = label_symbol(token);
+		add_symbol(labels, label);
+		token = token->next;
+	} while (match_op(token, ','));
+	return token;
+}
+
+static struct token *parse_asm_statement(struct token *token, struct statement *stmt)
+{
+	int is_goto = 0;
+
+	token = token->next;
+	stmt->type = STMT_ASM;
+	if (match_idents(token, &__volatile___ident, &__volatile_ident, &volatile_ident, NULL)) {
+		token = token->next;
+	}
+	if (token_type(token) == TOKEN_IDENT && token->ident == &goto_ident) {
+		is_goto = 1;
+		token = token->next;
+	}
+	token = expect(token, '(', "after asm");
+	token = parse_expression(token, &stmt->asm_string);
+	if (match_op(token, ':'))
+		token = parse_asm_operands(token, stmt, &stmt->asm_outputs);
+	if (match_op(token, ':'))
+		token = parse_asm_operands(token, stmt, &stmt->asm_inputs);
+	if (match_op(token, ':'))
+		token = parse_asm_clobbers(token, stmt, &stmt->asm_clobbers);
+	if (is_goto && match_op(token, ':'))
+		token = parse_asm_labels(token, stmt, &stmt->asm_labels);
+	token = expect(token, ')', "after asm");
+	return expect(token, ';', "at end of asm-statement");
+}
+
+static struct token *parse_asm_declarator(struct token *token, struct decl_state *ctx)
+{
+	struct expression *expr;
+	token = expect(token, '(', "after asm");
+	token = parse_expression(token->next, &expr);
+	token = expect(token, ')', "after asm");
+	return token;
+}
+
+static struct token *parse_static_assert(struct token *token, struct symbol_list **unused)
+{
+	struct expression *cond = NULL, *message = NULL;
+
+	token = expect(token->next, '(', "after _Static_assert");
+	token = constant_expression(token, &cond);
+	if (!cond)
+		sparse_error(token->pos, "Expected constant expression");
+	token = expect(token, ',', "after conditional expression in _Static_assert");
+	token = parse_expression(token, &message);
+	if (!message || message->type != EXPR_STRING) {
+		struct position pos;
+
+		pos = message ? message->pos : token->pos;
+		sparse_error(pos, "bad or missing string literal");
+		cond = NULL;
+	}
+	token = expect(token, ')', "after diagnostic message in _Static_assert");
+
+	token = expect(token, ';', "after _Static_assert()");
+
+	if (cond && !const_expression_value(cond) && cond->type == EXPR_VALUE)
+		sparse_error(cond->pos, "static assertion failed: %s",
+			     show_string(message->string));
+	return token;
+}
+
+/* Make a statement out of an expression */
+static struct statement *make_statement(struct expression *expr)
+{
+	struct statement *stmt;
+
+	if (!expr)
+		return NULL;
+	stmt = alloc_statement(expr->pos, STMT_EXPRESSION);
+	stmt->expression = expr;
+	return stmt;
+}
+
+/*
+ * All iterators have two symbols associated with them:
+ * the "continue" and "break" symbols, which are targets
+ * for continue and break statements respectively.
+ *
+ * They are in a special name-space, but they follow
+ * all the normal visibility rules, so nested iterators
+ * automatically work right.
+ */
+static void start_iterator(struct statement *stmt)
+{
+	struct symbol *cont, *brk;
+
+	start_symbol_scope(stmt->pos);
+	cont = alloc_symbol(stmt->pos, SYM_NODE);
+	bind_symbol(cont, &continue_ident, NS_ITERATOR);
+	brk = alloc_symbol(stmt->pos, SYM_NODE);
+	bind_symbol(brk, &break_ident, NS_ITERATOR);
+
+	stmt->type = STMT_ITERATOR;
+	stmt->iterator_break = brk;
+	stmt->iterator_continue = cont;
+	fn_local_symbol(brk);
+	fn_local_symbol(cont);
+}
+
+static void end_iterator(struct statement *stmt)
+{
+	end_symbol_scope();
+}
+
+static struct statement *start_function(struct symbol *sym)
+{
+	struct symbol *ret;
+	struct statement *stmt = alloc_statement(sym->pos, STMT_COMPOUND);
+
+	start_function_scope(sym->pos);
+	ret = alloc_symbol(sym->pos, SYM_NODE);
+	ret->ctype = sym->ctype.base_type->ctype;
+	ret->ctype.modifiers &= ~(MOD_STORAGE | MOD_CONST | MOD_VOLATILE | MOD_TLS | MOD_INLINE | MOD_ADDRESSABLE | MOD_NOCAST | MOD_NODEREF | MOD_ACCESSED | MOD_TOPLEVEL);
+	ret->ctype.modifiers |= (MOD_AUTO | MOD_REGISTER);
+	bind_symbol(ret, &return_ident, NS_ITERATOR);
+	stmt->ret = ret;
+	fn_local_symbol(ret);
+
+	// Currently parsed symbol for __func__/__FUNCTION__/__PRETTY_FUNCTION__
+	current_fn = sym;
+
+	return stmt;
+}
+
+static void end_function(struct symbol *sym)
+{
+	current_fn = NULL;
+	end_function_scope();
+}
+
+/*
+ * A "switch()" statement, like an iterator, has a
+ * the "break" symbol associated with it. It works
+ * exactly like the iterator break - it's the target
+ * for any break-statements in scope, and means that
+ * "break" handling doesn't even need to know whether
+ * it's breaking out of an iterator or a switch.
+ *
+ * In addition, the "case" symbol is a marker for the
+ * case/default statements to find the switch statement
+ * that they are associated with.
+ */
+static void start_switch(struct statement *stmt)
+{
+	struct symbol *brk, *switch_case;
+
+	start_symbol_scope(stmt->pos);
+	brk = alloc_symbol(stmt->pos, SYM_NODE);
+	bind_symbol(brk, &break_ident, NS_ITERATOR);
+
+	switch_case = alloc_symbol(stmt->pos, SYM_NODE);
+	bind_symbol(switch_case, &case_ident, NS_ITERATOR);
+	switch_case->stmt = stmt;
+
+	stmt->type = STMT_SWITCH;
+	stmt->switch_break = brk;
+	stmt->switch_case = switch_case;
+
+	fn_local_symbol(brk);
+	fn_local_symbol(switch_case);
+}
+
+static void end_switch(struct statement *stmt)
+{
+	if (!stmt->switch_case->symbol_list)
+		warning(stmt->pos, "switch with no cases");
+	end_symbol_scope();
+}
+
+static void add_case_statement(struct statement *stmt)
+{
+	struct symbol *target = lookup_symbol(&case_ident, NS_ITERATOR);
+	struct symbol *sym;
+
+	if (!target) {
+		sparse_error(stmt->pos, "not in switch scope");
+		stmt->type = STMT_NONE;
+		return;
+	}
+	sym = alloc_symbol(stmt->pos, SYM_NODE);
+	add_symbol(&target->symbol_list, sym);
+	sym->stmt = stmt;
+	stmt->case_label = sym;
+	fn_local_symbol(sym);
+}
+
+static struct token *parse_return_statement(struct token *token, struct statement *stmt)
+{
+	struct symbol *target = lookup_symbol(&return_ident, NS_ITERATOR);
+
+	if (!target)
+		error_die(token->pos, "internal error: return without a function target");
+	stmt->type = STMT_RETURN;
+	stmt->ret_target = target;
+	return expression_statement(token->next, &stmt->ret_value);
+}
+
+static void validate_for_loop_decl(struct symbol *sym)
+{
+	unsigned long storage = sym->ctype.modifiers & MOD_STORAGE;
+
+	if (storage & ~(MOD_AUTO | MOD_REGISTER)) {
+		const char *name = show_ident(sym->ident);
+		sparse_error(sym->pos, "non-local var '%s' in for-loop initializer", name);
+		sym->ctype.modifiers &= ~MOD_STORAGE;
+	}
+}
+
+static struct token *parse_for_statement(struct token *token, struct statement *stmt)
+{
+	struct symbol_list *syms;
+	struct expression *e1, *e2, *e3;
+	struct statement *iterator;
+
+	start_iterator(stmt);
+	token = expect(token->next, '(', "after 'for'");
+
+	syms = NULL;
+	e1 = NULL;
+	/* C99 variable declaration? */
+	if (lookup_type(token)) {
+		token = external_declaration(token, &syms, validate_for_loop_decl);
+	} else {
+		token = parse_expression(token, &e1);
+		token = expect(token, ';', "in 'for'");
+	}
+	token = parse_expression(token, &e2);
+	token = expect(token, ';', "in 'for'");
+	token = parse_expression(token, &e3);
+	token = expect(token, ')', "in 'for'");
+	token = statement(token, &iterator);
+
+	stmt->iterator_syms = syms;
+	stmt->iterator_pre_statement = make_statement(e1);
+	stmt->iterator_pre_condition = e2;
+	stmt->iterator_post_statement = make_statement(e3);
+	stmt->iterator_post_condition = NULL;
+	stmt->iterator_statement = iterator;
+	end_iterator(stmt);
+
+	return token;
+}
+
+static struct token *parse_while_statement(struct token *token, struct statement *stmt)
+{
+	struct expression *expr;
+	struct statement *iterator;
+
+	start_iterator(stmt);
+	token = parens_expression(token->next, &expr, "after 'while'");
+	token = statement(token, &iterator);
+
+	stmt->iterator_pre_condition = expr;
+	stmt->iterator_post_condition = NULL;
+	stmt->iterator_statement = iterator;
+	end_iterator(stmt);
+
+	return token;
+}
+
+static struct token *parse_do_statement(struct token *token, struct statement *stmt)
+{
+	struct expression *expr;
+	struct statement *iterator;
+
+	start_iterator(stmt);
+	token = statement(token->next, &iterator);
+	if (token_type(token) == TOKEN_IDENT && token->ident == &while_ident)
+		token = token->next;
+	else
+		sparse_error(token->pos, "expected 'while' after 'do'");
+	token = parens_expression(token, &expr, "after 'do-while'");
+
+	stmt->iterator_post_condition = expr;
+	stmt->iterator_statement = iterator;
+	end_iterator(stmt);
+
+	if (iterator && iterator->type != STMT_COMPOUND && Wdo_while)
+		warning(iterator->pos, "do-while statement is not a compound statement");
+
+	return expect(token, ';', "after statement");
+}
+
+static struct token *parse_if_statement(struct token *token, struct statement *stmt)
+{
+	stmt->type = STMT_IF;
+	token = parens_expression(token->next, &stmt->if_conditional, "after if");
+	token = statement(token, &stmt->if_true);
+	if (token_type(token) != TOKEN_IDENT)
+		return token;
+	if (token->ident != &else_ident)
+		return token;
+	return statement(token->next, &stmt->if_false);
+}
+
+static inline struct token *case_statement(struct token *token, struct statement *stmt)
+{
+	stmt->type = STMT_CASE;
+	token = expect(token, ':', "after default/case");
+	add_case_statement(stmt);
+	return statement(token, &stmt->case_statement);
+}
+
+static struct token *parse_case_statement(struct token *token, struct statement *stmt)
+{
+	token = parse_expression(token->next, &stmt->case_expression);
+	if (match_op(token, SPECIAL_ELLIPSIS))
+		token = parse_expression(token->next, &stmt->case_to);
+	return case_statement(token, stmt);
+}
+
+static struct token *parse_default_statement(struct token *token, struct statement *stmt)
+{
+	return case_statement(token->next, stmt);
+}
+
+static struct token *parse_loop_iterator(struct token *token, struct statement *stmt)
+{
+	struct symbol *target = lookup_symbol(token->ident, NS_ITERATOR);
+	stmt->type = STMT_GOTO;
+	stmt->goto_label = target;
+	if (!target)
+		sparse_error(stmt->pos, "break/continue not in iterator scope");
+	return expect(token->next, ';', "at end of statement");
+}
+
+static struct token *parse_switch_statement(struct token *token, struct statement *stmt)
+{
+	stmt->type = STMT_SWITCH;
+	start_switch(stmt);
+	token = parens_expression(token->next, &stmt->switch_expression, "after 'switch'");
+	token = statement(token, &stmt->switch_statement);
+	end_switch(stmt);
+	return token;
+}
+
+static struct token *parse_goto_statement(struct token *token, struct statement *stmt)
+{
+	stmt->type = STMT_GOTO;
+	token = token->next;
+	if (match_op(token, '*')) {
+		token = parse_expression(token->next, &stmt->goto_expression);
+		add_statement(&function_computed_goto_list, stmt);
+	} else if (token_type(token) == TOKEN_IDENT) {
+		stmt->goto_label = label_symbol(token);
+		token = token->next;
+	} else {
+		sparse_error(token->pos, "Expected identifier or goto expression");
+	}
+	return expect(token, ';', "at end of statement");
+}
+
+static struct token *parse_context_statement(struct token *token, struct statement *stmt)
+{
+	stmt->type = STMT_CONTEXT;
+	token = parse_expression(token->next, &stmt->expression);
+	if (stmt->expression->type == EXPR_PREOP
+	    && stmt->expression->op == '('
+	    && stmt->expression->unop->type == EXPR_COMMA) {
+		struct expression *expr;
+		expr = stmt->expression->unop;
+		stmt->context = expr->left;
+		stmt->expression = expr->right;
+	}
+	return expect(token, ';', "at end of statement");
+}
+
+static struct token *parse_range_statement(struct token *token, struct statement *stmt)
+{
+	stmt->type = STMT_RANGE;
+	token = assignment_expression(token->next, &stmt->range_expression);
+	token = expect(token, ',', "after range expression");
+	token = assignment_expression(token, &stmt->range_low);
+	token = expect(token, ',', "after low range");
+	token = assignment_expression(token, &stmt->range_high);
+	return expect(token, ';', "after range statement");
+}
+
+static struct token *statement(struct token *token, struct statement **tree)
+{
+	struct statement *stmt = alloc_statement(token->pos, STMT_NONE);
+
+	*tree = stmt;
+	if (token_type(token) == TOKEN_IDENT) {
+		struct symbol *s = lookup_keyword(token->ident, NS_KEYWORD);
+		if (s && s->op->statement)
+			return s->op->statement(token, stmt);
+
+		if (match_op(token->next, ':')) {
+			struct symbol *s = label_symbol(token);
+			stmt->type = STMT_LABEL;
+			stmt->label_identifier = s;
+			if (s->stmt)
+				sparse_error(stmt->pos, "label '%s' redefined", show_ident(token->ident));
+			s->stmt = stmt;
+			token = skip_attributes(token->next->next);
+			return statement(token, &stmt->label_statement);
+		}
+	}
+
+	if (match_op(token, '{')) {
+		stmt->type = STMT_COMPOUND;
+		start_symbol_scope(stmt->pos);
+		token = compound_statement(token->next, stmt);
+		end_symbol_scope();
+		
+		return expect(token, '}', "at end of compound statement");
+	}
+			
+	stmt->type = STMT_EXPRESSION;
+	return expression_statement(token, &stmt->expression);
+}
+
+/* gcc extension - __label__ ident-list; in the beginning of compound stmt */
+static struct token *label_statement(struct token *token)
+{
+	while (token_type(token) == TOKEN_IDENT) {
+		struct symbol *sym = alloc_symbol(token->pos, SYM_LABEL);
+		/* it's block-scope, but we want label namespace */
+		bind_symbol(sym, token->ident, NS_SYMBOL);
+		sym->namespace = NS_LABEL;
+		fn_local_symbol(sym);
+		token = token->next;
+		if (!match_op(token, ','))
+			break;
+		token = token->next;
+	}
+	return expect(token, ';', "at end of label declaration");
+}
+
+static struct token * statement_list(struct token *token, struct statement_list **list)
+{
+	int seen_statement = 0;
+	while (token_type(token) == TOKEN_IDENT &&
+	       token->ident == &__label___ident)
+		token = label_statement(token->next);
+	for (;;) {
+		struct statement * stmt;
+		if (eof_token(token))
+			break;
+		if (match_op(token, '}'))
+			break;
+		if (match_ident(token, &_Static_assert_ident)) {
+			token = parse_static_assert(token, NULL);
+			continue;
+		}
+		if (lookup_type(token)) {
+			if (seen_statement) {
+				warning(token->pos, "mixing declarations and code");
+				seen_statement = 0;
+			}
+			stmt = alloc_statement(token->pos, STMT_DECLARATION);
+			token = external_declaration(token, &stmt->declaration, NULL);
+		} else {
+			seen_statement = Wdeclarationafterstatement;
+			token = statement(token, &stmt);
+		}
+		add_statement(list, stmt);
+	}
+	return token;
+}
+
+static struct token *identifier_list(struct token *token, struct symbol *fn)
+{
+	struct symbol_list **list = &fn->arguments;
+	for (;;) {
+		struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
+		sym->ident = token->ident;
+		token = token->next;
+		sym->endpos = token->pos;
+		sym->ctype.base_type = &incomplete_ctype;
+		add_symbol(list, sym);
+		if (!match_op(token, ',') ||
+		    token_type(token->next) != TOKEN_IDENT ||
+		    lookup_type(token->next))
+			break;
+		token = token->next;
+	}
+	return token;
+}
+
+static struct token *parameter_type_list(struct token *token, struct symbol *fn)
+{
+	struct symbol_list **list = &fn->arguments;
+
+	for (;;) {
+		struct symbol *sym;
+
+		if (match_op(token, SPECIAL_ELLIPSIS)) {
+			fn->variadic = 1;
+			token = token->next;
+			break;
+		}
+
+		sym = alloc_symbol(token->pos, SYM_NODE);
+		token = parameter_declaration(token, sym);
+		if (sym->ctype.base_type == &void_ctype) {
+			/* Special case: (void) */
+			if (!*list && !sym->ident)
+				break;
+			warning(token->pos, "void parameter");
+		}
+		add_symbol(list, sym);
+		if (!match_op(token, ','))
+			break;
+		token = token->next;
+	}
+	return token;
+}
+
+struct token *compound_statement(struct token *token, struct statement *stmt)
+{
+	token = statement_list(token, &stmt->stmts);
+	return token;
+}
+
+static struct expression *identifier_expression(struct token *token)
+{
+	struct expression *expr = alloc_expression(token->pos, EXPR_IDENTIFIER);
+	expr->expr_ident = token->ident;
+	return expr;
+}
+
+static struct expression *index_expression(struct expression *from, struct expression *to)
+{
+	int idx_from, idx_to;
+	struct expression *expr = alloc_expression(from->pos, EXPR_INDEX);
+
+	idx_from = const_expression_value(from);
+	idx_to = idx_from;
+	if (to) {
+		idx_to = const_expression_value(to);
+		if (idx_to < idx_from || idx_from < 0)
+			warning(from->pos, "nonsense array initializer index range");
+	}
+	expr->idx_from = idx_from;
+	expr->idx_to = idx_to;
+	return expr;
+}
+
+static struct token *single_initializer(struct expression **ep, struct token *token)
+{
+	int expect_equal = 0;
+	struct token *next = token->next;
+	struct expression **tail = ep;
+	int nested;
+
+	*ep = NULL; 
+
+	if ((token_type(token) == TOKEN_IDENT) && match_op(next, ':')) {
+		struct expression *expr = identifier_expression(token);
+		if (Wold_initializer)
+			warning(token->pos, "obsolete struct initializer, use C99 syntax");
+		token = initializer(&expr->ident_expression, next->next);
+		if (expr->ident_expression)
+			*ep = expr;
+		return token;
+	}
+
+	for (tail = ep, nested = 0; ; nested++, next = token->next) {
+		if (match_op(token, '.') && (token_type(next) == TOKEN_IDENT)) {
+			struct expression *expr = identifier_expression(next);
+			*tail = expr;
+			tail = &expr->ident_expression;
+			expect_equal = 1;
+			token = next->next;
+		} else if (match_op(token, '[')) {
+			struct expression *from = NULL, *to = NULL, *expr;
+			token = constant_expression(token->next, &from);
+			if (!from) {
+				sparse_error(token->pos, "Expected constant expression");
+				break;
+			}
+			if (match_op(token, SPECIAL_ELLIPSIS))
+				token = constant_expression(token->next, &to);
+			expr = index_expression(from, to);
+			*tail = expr;
+			tail = &expr->idx_expression;
+			token = expect(token, ']', "at end of initializer index");
+			if (nested)
+				expect_equal = 1;
+		} else {
+			break;
+		}
+	}
+	if (nested && !expect_equal) {
+		if (!match_op(token, '='))
+			warning(token->pos, "obsolete array initializer, use C99 syntax");
+		else
+			expect_equal = 1;
+	}
+	if (expect_equal)
+		token = expect(token, '=', "at end of initializer index");
+
+	token = initializer(tail, token);
+	if (!*tail)
+		*ep = NULL;
+	return token;
+}
+
+static struct token *initializer_list(struct expression_list **list, struct token *token)
+{
+	struct expression *expr;
+
+	for (;;) {
+		token = single_initializer(&expr, token);
+		if (!expr)
+			break;
+		add_expression(list, expr);
+		if (!match_op(token, ','))
+			break;
+		token = token->next;
+	}
+	return token;
+}
+
+struct token *initializer(struct expression **tree, struct token *token)
+{
+	if (match_op(token, '{')) {
+		struct expression *expr = alloc_expression(token->pos, EXPR_INITIALIZER);
+		*tree = expr;
+		token = initializer_list(&expr->expr_list, token->next);
+		return expect(token, '}', "at end of initializer");
+	}
+	return assignment_expression(token, tree);
+}
+
+static void declare_argument(struct symbol *sym, struct symbol *fn)
+{
+	if (!sym->ident) {
+		sparse_error(sym->pos, "no identifier for function argument");
+		return;
+	}
+	bind_symbol(sym, sym->ident, NS_SYMBOL);
+}
+
+static int is_syscall(struct symbol *sym)
+{
+	char *macro;
+	char *name;
+	int is_syscall = 0;
+
+	macro = get_macro_name(sym->pos);
+	if (macro &&
+	    (strncmp("SYSCALL_DEFINE", macro, strlen("SYSCALL_DEFINE")) == 0 ||
+	     strncmp("COMPAT_SYSCALL_DEFINE", macro, strlen("COMPAT_SYSCALL_DEFINE")) == 0))
+		is_syscall = 1;
+
+	name = sym->ident->name;
+
+	if (name && strncmp(name, "sys_", 4) ==0)
+		is_syscall = 1;
+	
+	if (name && strncmp(name, "compat_sys_", 11) == 0)
+		is_syscall = 1;
+
+	return is_syscall;
+}
+    
+
+static struct token *parse_function_body(struct token *token, struct symbol *decl,
+	struct symbol_list **list)
+{
+	struct symbol_list **old_symbol_list;
+	struct symbol *base_type = decl->ctype.base_type;
+	struct statement *stmt, **p;
+	struct symbol *prev;
+	struct symbol *arg;
+
+	old_symbol_list = function_symbol_list;
+	if (decl->ctype.modifiers & MOD_INLINE) {
+		function_symbol_list = &decl->inline_symbol_list;
+		p = &base_type->inline_stmt;
+	} else {
+		function_symbol_list = &decl->symbol_list;
+		p = &base_type->stmt;
+	}
+	function_computed_target_list = NULL;
+	function_computed_goto_list = NULL;
+
+	if (decl->ctype.modifiers & MOD_EXTERN &&
+		!(decl->ctype.modifiers & MOD_INLINE) &&
+		Wexternal_function_has_definition)
+		warning(decl->pos, "function '%s' with external linkage has definition", show_ident(decl->ident));
+
+	if (!(decl->ctype.modifiers & MOD_STATIC))
+		decl->ctype.modifiers |= MOD_EXTERN;
+
+	stmt = start_function(decl);
+
+	*p = stmt;
+	FOR_EACH_PTR (base_type->arguments, arg) {
+		declare_argument(arg, base_type);
+	} END_FOR_EACH_PTR(arg);
+
+	token = compound_statement(token->next, stmt);
+
+	end_function(decl); 
+	if (!(decl->ctype.modifiers & MOD_INLINE))
+		add_symbol(list, decl);
+	else if (is_syscall(decl)) {
+	    add_symbol(list, decl);
+	    /*
+	    printf("parse.c decl: %s\n", decl->ident->name);
+	    char *macro = get_macro_name(decl->pos);
+	    printf("decl macro: %s\n", macro);
+	    */
+	}
+	check_declaration(decl);
+	decl->definition = decl;
+	prev = decl->same_symbol;
+	if (prev && prev->definition) {
+		warning(decl->pos, "multiple definitions for function '%s'",
+			show_ident(decl->ident));
+		info(prev->definition->pos, " the previous one is here");
+	} else {
+		while (prev) {
+			rebind_scope(prev, decl->scope);
+			prev->definition = decl;
+			prev = prev->same_symbol;
+		}
+	}
+	function_symbol_list = old_symbol_list;
+	if (function_computed_goto_list) {
+		if (!function_computed_target_list)
+			warning(decl->pos, "function '%s' has computed goto but no targets?", show_ident(decl->ident));
+		else {
+			FOR_EACH_PTR(function_computed_goto_list, stmt) {
+				stmt->target_list = function_computed_target_list;
+			} END_FOR_EACH_PTR(stmt);
+		}
+	}
+	return expect(token, '}', "at end of function");
+}
+
+static void promote_k_r_types(struct symbol *arg)
+{
+	struct symbol *base = arg->ctype.base_type;
+	if (base && base->ctype.base_type == &int_type && (base->ctype.modifiers & (MOD_CHAR | MOD_SHORT))) {
+		arg->ctype.base_type = &int_ctype;
+	}
+}
+
+static void apply_k_r_types(struct symbol_list *argtypes, struct symbol *fn)
+{
+	struct symbol_list *real_args = fn->ctype.base_type->arguments;
+	struct symbol *arg;
+
+	FOR_EACH_PTR(real_args, arg) {
+		struct symbol *type;
+
+		/* This is quadratic in the number of arguments. We _really_ don't care */
+		FOR_EACH_PTR(argtypes, type) {
+			if (type->ident == arg->ident)
+				goto match;
+		} END_FOR_EACH_PTR(type);
+		if (Wimplicit_int) {
+			sparse_error(arg->pos, "missing type declaration for parameter '%s'",
+				show_ident(arg->ident));
+		}
+		continue;
+match:
+		type->used = 1;
+		/* "char" and "short" promote to "int" */
+		promote_k_r_types(type);
+
+		arg->ctype = type->ctype;
+	} END_FOR_EACH_PTR(arg);
+
+	FOR_EACH_PTR(argtypes, arg) {
+		if (!arg->used)
+			warning(arg->pos, "nonsensical parameter declaration '%s'", show_ident(arg->ident));
+	} END_FOR_EACH_PTR(arg);
+
+}
+
+static struct token *parse_k_r_arguments(struct token *token, struct symbol *decl,
+	struct symbol_list **list)
+{
+	struct symbol_list *args = NULL;
+
+	if (Wold_style_definition)
+		warning(token->pos, "non-ANSI definition of function '%s'", show_ident(decl->ident));
+
+	do {
+		token = declaration_list(token, &args);
+		if (!match_op(token, ';')) {
+			sparse_error(token->pos, "expected ';' at end of parameter declaration");
+			break;
+		}
+		token = token->next;
+	} while (lookup_type(token));
+
+	apply_k_r_types(args, decl);
+
+	if (!match_op(token, '{')) {
+		sparse_error(token->pos, "expected function body");
+		return token;
+	}
+	return parse_function_body(token, decl, list);
+}
+
+static struct token *toplevel_asm_declaration(struct token *token, struct symbol_list **list)
+{
+	struct symbol *anon = alloc_symbol(token->pos, SYM_NODE);
+	struct symbol *fn = alloc_symbol(token->pos, SYM_FN);
+	struct statement *stmt;
+
+	anon->ctype.base_type = fn;
+	stmt = alloc_statement(token->pos, STMT_NONE);
+	fn->stmt = stmt;
+
+	token = parse_asm_statement(token, stmt);
+
+	add_symbol(list, anon);
+	return token;
+}
+
+struct token *external_declaration(struct token *token, struct symbol_list **list,
+		validate_decl_t validate_decl)
+{
+	struct ident *ident = NULL;
+	struct symbol *decl;
+	struct decl_state ctx = { .ident = &ident };
+	struct ctype saved;
+	struct symbol *base_type;
+	unsigned long mod;
+	int is_typedef;
+
+	if (match_ident(token, &_Pragma_ident))
+		return parse_underscore_Pragma(token);
+
+	/* Top-level inline asm or static assertion? */
+	if (token_type(token) == TOKEN_IDENT) {
+		struct symbol *s = lookup_keyword(token->ident, NS_KEYWORD);
+		if (s && s->op->toplevel)
+			return s->op->toplevel(token, list);
+	}
+
+	/* Parse declaration-specifiers, if any */
+	token = declaration_specifiers(token, &ctx);
+	mod = storage_modifiers(&ctx);
+	decl = alloc_symbol(token->pos, SYM_NODE);
+	/* Just a type declaration? */
+	if (match_op(token, ';')) {
+		apply_modifiers(token->pos, &ctx);
+		return token->next;
+	}
+
+	saved = ctx.ctype;
+	token = declarator(token, &ctx);
+	token = handle_attributes(token, &ctx, KW_ATTRIBUTE | KW_ASM);
+	apply_modifiers(token->pos, &ctx);
+
+	decl->ctype = ctx.ctype;
+	decl->ctype.modifiers |= mod;
+	decl->endpos = token->pos;
+
+	/* Just a type declaration? */
+	if (!ident) {
+		warning(token->pos, "missing identifier in declaration");
+		return expect(token, ';', "at the end of type declaration");
+	}
+
+	/* type define declaration? */
+	is_typedef = ctx.storage_class == STypedef;
+
+	/* Typedefs don't have meaningful storage */
+	if (is_typedef)
+		decl->ctype.modifiers |= MOD_USERTYPE;
+
+	bind_symbol(decl, ident, is_typedef ? NS_TYPEDEF: NS_SYMBOL);
+
+	base_type = decl->ctype.base_type;
+
+	if (is_typedef) {
+		if (base_type && !base_type->ident) {
+			switch (base_type->type) {
+			case SYM_STRUCT:
+			case SYM_UNION:
+			case SYM_ENUM:
+			case SYM_RESTRICT:
+				base_type->ident = ident;
+				break;
+			default:
+				break;
+			}
+		}
+	} else if (base_type && base_type->type == SYM_FN) {
+		if (base_type->ctype.base_type == &incomplete_ctype) {
+			warning(decl->pos, "'%s()' has implicit return type",
+				show_ident(decl->ident));
+			base_type->ctype.base_type = &int_ctype;
+		}
+		/* K&R argument declaration? */
+		if (lookup_type(token))
+			return parse_k_r_arguments(token, decl, list);
+		if (match_op(token, '{'))
+			return parse_function_body(token, decl, list);
+
+		if (!(decl->ctype.modifiers & MOD_STATIC))
+			decl->ctype.modifiers |= MOD_EXTERN;
+	} else if (base_type == &void_ctype && !(decl->ctype.modifiers & MOD_EXTERN)) {
+		sparse_error(token->pos, "void declaration");
+	}
+	if (base_type == &incomplete_ctype) {
+		warning(decl->pos, "'%s' has implicit type", show_ident(decl->ident));
+		decl->ctype.base_type = &int_ctype;;
+	}
+
+	for (;;) {
+		if (!is_typedef && match_op(token, '=')) {
+			token = initializer(&decl->initializer, token->next);
+		}
+		if (!is_typedef) {
+			if (validate_decl)
+				validate_decl(decl);
+
+			if (decl->initializer && decl->ctype.modifiers & MOD_EXTERN) {
+				warning(decl->pos, "symbol with external linkage has initializer");
+				decl->ctype.modifiers &= ~MOD_EXTERN;
+			}
+
+			if (!(decl->ctype.modifiers & (MOD_EXTERN | MOD_INLINE))) {
+				add_symbol(list, decl);
+				fn_local_symbol(decl);
+			}
+		}
+		check_declaration(decl);
+		if (decl->same_symbol) {
+			decl->definition = decl->same_symbol->definition;
+			decl->op = decl->same_symbol->op;
+		}
+
+		if (!match_op(token, ','))
+			break;
+
+		token = token->next;
+		ident = NULL;
+		decl = alloc_symbol(token->pos, SYM_NODE);
+		ctx.ctype = saved;
+		token = handle_attributes(token, &ctx, KW_ATTRIBUTE);
+		token = declarator(token, &ctx);
+		token = handle_attributes(token, &ctx, KW_ATTRIBUTE | KW_ASM);
+		apply_modifiers(token->pos, &ctx);
+		decl->ctype = ctx.ctype;
+		decl->ctype.modifiers |= mod;
+		decl->endpos = token->pos;
+		if (!ident) {
+			sparse_error(token->pos, "expected identifier name in type definition");
+			return token;
+		}
+
+		if (is_typedef)
+			decl->ctype.modifiers |= MOD_USERTYPE;
+
+		bind_symbol(decl, ident, is_typedef ? NS_TYPEDEF: NS_SYMBOL);
+
+		/* Function declarations are automatically extern unless specifically static */
+		base_type = decl->ctype.base_type;
+		if (!is_typedef && base_type && base_type->type == SYM_FN) {
+			if (!(decl->ctype.modifiers & MOD_STATIC))
+				decl->ctype.modifiers |= MOD_EXTERN;
+		}
+	}
+	return expect(token, ';', "at end of declaration");
+}
diff --git a/usr/src/tools/smatch/src/parse.dtd b/usr/src/tools/smatch/src/parse.dtd
new file mode 100644
index 0000000000..cbf95ec1dd
--- /dev/null
+++ b/usr/src/tools/smatch/src/parse.dtd
@@ -0,0 +1,51 @@
+<!ELEMENT parse (symbol+) >
+
+<!ELEMENT symbol (symbol*) >
+
+<!ATTLIST symbol type (uninitialized|preprocessor|basetype|node|pointer|function|array|struct|union|enum|typedef|typeof|member|bitfield|label|restrict|fouled|keyword|bad) #REQUIRED
+                 id ID #REQUIRED
+		 file CDATA #REQUIRED
+		 start-line CDATA #REQUIRED
+		 start-col CDATA #REQUIRED
+		 end-line CDATA #IMPLIED
+		 end-col CDATA #IMPLIED
+		 end-file CDATA #IMPLIED
+
+		 ident CDATA #IMPLIED
+		 base-type IDREF #IMPLIED
+		 base-type-builtin (char|signed char|unsigned char|short|signed short|unsigned short|int|signed int|unsigned int|signed long|long|unsigned long|long long|signed long long|unsigned long long|void|bool|string|float|double|long double|incomplete type|abstract int|abstract fp|label type|bad type) #IMPLIED
+
+		 array-size CDATA #IMPLIED
+
+		 bit-size CDATA #IMPLIED
+		 alignment CDATA #IMPLIED
+		 offset CDATA #IMPLIED
+		 bit-offset CDATA #IMPLIED
+
+		 auto (0|1) #IMPLIED
+		 register (0|1) #IMPLIED
+		 static (0|1) #IMPLIED
+		 extern (0|1) #IMPLIED
+		 const (0|1) #IMPLIED
+		 volatile (0|1) #IMPLIED
+		 signed (0|1) #IMPLIED
+		 unsigned (0|1) #IMPLIED
+		 char (0|1) #IMPLIED
+		 short (0|1) #IMPLIED
+		 long (0|1) #IMPLIED
+		 long-long (0|1) #IMPLIED
+		 typedef (0|1) #IMPLIED
+		 inline (0|1) #IMPLIED
+		 addressable (0|1) #IMPLIED
+		 nocast (0|1) #IMPLIED
+		 noderef (0|1) #IMPLIED
+		 accessed (0|1) #IMPLIED
+		 toplevel (0|1) #IMPLIED
+		 label (0|1) #IMPLIED
+		 assigned (0|1) #IMPLIED
+		 type-type (0|1) #IMPLIED
+		 safe (0|1) #IMPLIED
+		 usertype (0|1) #IMPLIED
+		 force (0|1) #IMPLIED
+		 explicitly-signed (0|1) #IMPLIED
+		 bitwise (0|1) #IMPLIED >
diff --git a/usr/src/tools/smatch/src/parse.h b/usr/src/tools/smatch/src/parse.h
new file mode 100644
index 0000000000..f3612f5258
--- /dev/null
+++ b/usr/src/tools/smatch/src/parse.h
@@ -0,0 +1,155 @@
+#ifndef PARSE_H
+#define PARSE_H
+/*
+ * Basic parsing data structures. Statements and symbols.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "symbol.h"
+
+enum statement_type {
+	STMT_NONE,
+	STMT_DECLARATION,
+	STMT_EXPRESSION,
+	STMT_COMPOUND,
+	STMT_IF,
+	STMT_RETURN,
+	STMT_CASE,
+	STMT_SWITCH,
+	STMT_ITERATOR,
+	STMT_LABEL,
+	STMT_GOTO,
+	STMT_ASM,
+	STMT_CONTEXT,
+	STMT_RANGE,
+};
+
+struct statement {
+	enum statement_type type;
+	struct position pos;
+	struct statement *parent;
+	union {
+		struct /* declaration */ {
+			struct symbol_list *declaration;
+		};
+		struct /* context */ {
+			struct expression *expression;
+			struct expression *context;
+		};
+		struct /* return_statement */ {
+			struct expression *ret_value;
+			struct symbol *ret_target;
+		};
+		struct /* if_statement */ {
+			struct expression *if_conditional;
+			struct statement *if_true;
+			struct statement *if_false;
+		};
+		struct /* compound_struct */ {
+			struct statement_list *stmts;
+			struct symbol *ret;
+			struct symbol *inline_fn;
+			struct statement *args;
+		};
+		struct /* labeled_struct */ {
+			struct symbol *label_identifier;
+			struct statement *label_statement;
+		};
+		struct /* case_struct */ {
+			struct expression *case_expression;
+			struct expression *case_to;
+			struct statement *case_statement;
+			struct symbol *case_label;
+		};
+		struct /* switch_struct */ {
+			struct expression *switch_expression;
+			struct statement *switch_statement;
+			struct symbol *switch_break, *switch_case;
+		};
+		struct /* iterator_struct */ {
+			struct symbol *iterator_break;
+			struct symbol *iterator_continue;
+			struct symbol_list *iterator_syms;
+			struct statement  *iterator_pre_statement;
+			struct expression *iterator_pre_condition;
+
+			struct statement  *iterator_statement;
+
+			struct statement  *iterator_post_statement;
+			struct expression *iterator_post_condition;
+		};
+		struct /* goto_struct */ {
+			struct symbol *goto_label;
+
+			/* computed gotos have these: */
+			struct expression *goto_expression;
+			struct symbol_list *target_list;
+		};
+		struct /* asm */ {
+			struct expression *asm_string;
+			struct expression_list *asm_outputs;
+			struct expression_list *asm_inputs;
+			struct expression_list *asm_clobbers;
+			struct symbol_list *asm_labels;
+		};
+		struct /* range */ {
+			struct expression *range_expression;
+			struct expression *range_low;
+			struct expression *range_high;
+		};
+	};
+};
+
+extern struct symbol_list *function_computed_target_list;
+extern struct statement_list *function_computed_goto_list;
+
+extern struct token *parse_expression(struct token *, struct expression **);
+extern struct symbol *label_symbol(struct token *token);
+
+extern int show_statement(struct statement *);
+extern void show_statement_list(struct statement_list *, const char *);
+extern int show_expression(struct expression *);
+
+typedef void (*validate_decl_t)(struct symbol *decl);
+extern struct token *external_declaration(struct token *, struct symbol_list **, validate_decl_t);
+
+extern struct symbol *ctype_integer(int size, int want_unsigned);
+
+extern void copy_statement(struct statement *src, struct statement *dst);
+extern int inline_function(struct expression *expr, struct symbol *sym);
+extern void uninline(struct symbol *sym);
+extern void init_parser(int);
+
+static inline void stmt_set_parent_stmt(struct statement *stmt, struct statement *parent)
+{
+	if (!stmt)
+		return;
+	stmt->parent = parent;
+}
+
+static inline struct statement *stmt_get_parent_stmt(struct statement *stmt)
+{
+	return stmt->parent;
+}
+
+#endif /* PARSE_H */
diff --git a/usr/src/tools/smatch/src/pre-process.c b/usr/src/tools/smatch/src/pre-process.c
new file mode 100644
index 0000000000..a33ef69222
--- /dev/null
+++ b/usr/src/tools/smatch/src/pre-process.c
@@ -0,0 +1,2233 @@
+/*
+ * Do C preprocessing, based on a token list gathered by
+ * the tokenizer.
+ *
+ * This may not be the smartest preprocessor on the planet.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <time.h>
+#include <dirent.h>
+#include <sys/stat.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "parse.h"
+#include "token.h"
+#include "symbol.h"
+#include "expression.h"
+#include "scope.h"
+
+static struct ident_list *macros;	// only needed for -dD
+static int false_nesting = 0;
+static int counter_macro = 0;		// __COUNTER__ expansion
+
+#define INCLUDEPATHS 300
+const char *includepath[INCLUDEPATHS+1] = {
+	"",
+	"/usr/include",
+	"/usr/local/include",
+	NULL
+};
+
+static const char **quote_includepath = includepath;
+static const char **angle_includepath = includepath + 1;
+static const char **isys_includepath   = includepath + 1;
+static const char **sys_includepath   = includepath + 1;
+static const char **dirafter_includepath = includepath + 3;
+
+#define dirty_stream(stream)				\
+	do {						\
+		if (!stream->dirty) {			\
+			stream->dirty = 1;		\
+			if (!stream->ifndef)		\
+				stream->protect = NULL;	\
+		}					\
+	} while(0)
+
+#define end_group(stream)					\
+	do {							\
+		if (stream->ifndef == stream->top_if) {		\
+			stream->ifndef = NULL;			\
+			if (!stream->dirty)			\
+				stream->protect = NULL;		\
+			else if (stream->protect)		\
+				stream->dirty = 0;		\
+		}						\
+	} while(0)
+
+#define nesting_error(stream)		\
+	do {				\
+		stream->dirty = 1;	\
+		stream->ifndef = NULL;	\
+		stream->protect = NULL;	\
+	} while(0)
+
+static struct token *alloc_token(struct position *pos)
+{
+	struct token *token = __alloc_token(0);
+
+	token->pos.stream = pos->stream;
+	token->pos.line = pos->line;
+	token->pos.pos = pos->pos;
+	token->pos.whitespace = 1;
+	return token;
+}
+
+/* Expand symbol 'sym' at '*list' */
+static int expand(struct token **, struct symbol *);
+
+static void replace_with_string(struct token *token, const char *str)
+{
+	int size = strlen(str) + 1;
+	struct string *s = __alloc_string(size);
+
+	s->length = size;
+	memcpy(s->data, str, size);
+	token_type(token) = TOKEN_STRING;
+	token->string = s;
+}
+
+static void replace_with_integer(struct token *token, unsigned int val)
+{
+	char *buf = __alloc_bytes(11);
+	sprintf(buf, "%u", val);
+	token_type(token) = TOKEN_NUMBER;
+	token->number = buf;
+}
+
+static struct symbol *lookup_macro(struct ident *ident)
+{
+	struct symbol *sym = lookup_symbol(ident, NS_MACRO | NS_UNDEF);
+	if (sym && sym->namespace != NS_MACRO)
+		sym = NULL;
+	return sym;
+}
+
+static int token_defined(struct token *token)
+{
+	if (token_type(token) == TOKEN_IDENT) {
+		struct symbol *sym = lookup_macro(token->ident);
+		if (sym) {
+			sym->used_in = file_scope;
+			return 1;
+		}
+		return 0;
+	}
+
+	sparse_error(token->pos, "expected preprocessor identifier");
+	return 0;
+}
+
+static void replace_with_defined(struct token *token)
+{
+	static const char *string[] = { "0", "1" };
+	int defined = token_defined(token);
+
+	token_type(token) = TOKEN_NUMBER;
+	token->number = string[defined];
+}
+
+static int expand_one_symbol(struct token **list)
+{
+	struct token *token = *list;
+	struct symbol *sym;
+	static char buffer[12]; /* __DATE__: 3 + ' ' + 2 + ' ' + 4 + '\0' */
+	static time_t t = 0;
+
+	if (token->pos.noexpand)
+		return 1;
+
+	sym = lookup_macro(token->ident);
+	if (sym) {
+		store_macro_pos(token);
+		sym->used_in = file_scope;
+		return expand(list, sym);
+	}
+	if (token->ident == &__LINE___ident) {
+		replace_with_integer(token, token->pos.line);
+	} else if (token->ident == &__FILE___ident) {
+		replace_with_string(token, stream_name(token->pos.stream));
+	} else if (token->ident == &__DATE___ident) {
+		if (!t)
+			time(&t);
+		strftime(buffer, 12, "%b %e %Y", localtime(&t));
+		replace_with_string(token, buffer);
+	} else if (token->ident == &__TIME___ident) {
+		if (!t)
+			time(&t);
+		strftime(buffer, 9, "%T", localtime(&t));
+		replace_with_string(token, buffer);
+	} else if (token->ident == &__COUNTER___ident) {
+		replace_with_integer(token, counter_macro++);
+	}
+	return 1;
+}
+
+static inline struct token *scan_next(struct token **where)
+{
+	struct token *token = *where;
+	if (token_type(token) != TOKEN_UNTAINT)
+		return token;
+	do {
+		token->ident->tainted = 0;
+		token = token->next;
+	} while (token_type(token) == TOKEN_UNTAINT);
+	*where = token;
+	return token;
+}
+
+static void expand_list(struct token **list)
+{
+	struct token *next;
+	while (!eof_token(next = scan_next(list))) {
+		if (token_type(next) != TOKEN_IDENT || expand_one_symbol(list))
+			list = &next->next;
+	}
+}
+
+static void preprocessor_line(struct stream *stream, struct token **line);
+
+static struct token *collect_arg(struct token *prev, int vararg, struct position *pos, int count)
+{
+	struct stream *stream = input_streams + prev->pos.stream;
+	struct token **p = &prev->next;
+	struct token *next;
+	int nesting = 0;
+
+	while (!eof_token(next = scan_next(p))) {
+		if (next->pos.newline && match_op(next, '#')) {
+			if (!next->pos.noexpand) {
+				sparse_error(next->pos,
+					     "directive in argument list");
+				preprocessor_line(stream, p);
+				__free_token(next);	/* Free the '#' token */
+				continue;
+			}
+		}
+		switch (token_type(next)) {
+		case TOKEN_STREAMEND:
+		case TOKEN_STREAMBEGIN:
+			*p = &eof_token_entry;
+			return next;
+		case TOKEN_STRING:
+		case TOKEN_WIDE_STRING:
+			if (count > 1)
+				next->string->immutable = 1;
+			break;
+		}
+		if (false_nesting) {
+			*p = next->next;
+			__free_token(next);
+			continue;
+		}
+		if (match_op(next, '(')) {
+			nesting++;
+		} else if (match_op(next, ')')) {
+			if (!nesting--)
+				break;
+		} else if (match_op(next, ',') && !nesting && !vararg) {
+			break;
+		}
+		next->pos.stream = pos->stream;
+		next->pos.line = pos->line;
+		next->pos.pos = pos->pos;
+		p = &next->next;
+	}
+	*p = &eof_token_entry;
+	return next;
+}
+
+/*
+ * We store arglist as <counter> [arg1] <number of uses for arg1> ... eof
+ */
+
+struct arg {
+	struct token *arg;
+	struct token *expanded;
+	struct token *str;
+	int n_normal;
+	int n_quoted;
+	int n_str;
+};
+
+static int collect_arguments(struct token *start, struct token *arglist, struct arg *args, struct token *what)
+{
+	int wanted = arglist->count.normal;
+	struct token *next = NULL;
+	int count = 0;
+
+	arglist = arglist->next;	/* skip counter */
+
+	if (!wanted) {
+		next = collect_arg(start, 0, &what->pos, 0);
+		if (eof_token(next))
+			goto Eclosing;
+		if (!eof_token(start->next) || !match_op(next, ')')) {
+			count++;
+			goto Emany;
+		}
+	} else {
+		for (count = 0; count < wanted; count++) {
+			struct argcount *p = &arglist->next->count;
+			next = collect_arg(start, p->vararg, &what->pos, p->normal);
+			if (eof_token(next))
+				goto Eclosing;
+			if (p->vararg && wanted == 1 && eof_token(start->next))
+				break;
+			arglist = arglist->next->next;
+			args[count].arg = start->next;
+			args[count].n_normal = p->normal;
+			args[count].n_quoted = p->quoted;
+			args[count].n_str = p->str;
+			if (match_op(next, ')')) {
+				count++;
+				break;
+			}
+			start = next;
+		}
+		if (count == wanted && !match_op(next, ')'))
+			goto Emany;
+		if (count == wanted - 1) {
+			struct argcount *p = &arglist->next->count;
+			if (!p->vararg)
+				goto Efew;
+			args[count].arg = NULL;
+			args[count].n_normal = p->normal;
+			args[count].n_quoted = p->quoted;
+			args[count].n_str = p->str;
+		}
+		if (count < wanted - 1)
+			goto Efew;
+	}
+	what->next = next->next;
+	return 1;
+
+Efew:
+	sparse_error(what->pos, "macro \"%s\" requires %d arguments, but only %d given",
+		show_token(what), wanted, count);
+	goto out;
+Emany:
+	while (match_op(next, ',')) {
+		next = collect_arg(next, 0, &what->pos, 0);
+		count++;
+	}
+	if (eof_token(next))
+		goto Eclosing;
+	sparse_error(what->pos, "macro \"%s\" passed %d arguments, but takes just %d",
+		show_token(what), count, wanted);
+	goto out;
+Eclosing:
+	sparse_error(what->pos, "unterminated argument list invoking macro \"%s\"",
+		show_token(what));
+out:
+	what->next = next->next;
+	return 0;
+}
+
+static struct token *dup_list(struct token *list)
+{
+	struct token *res = NULL;
+	struct token **p = &res;
+
+	while (!eof_token(list)) {
+		struct token *newtok = __alloc_token(0);
+		*newtok = *list;
+		*p = newtok;
+		p = &newtok->next;
+		list = list->next;
+	}
+	return res;
+}
+
+static const char *show_token_sequence(struct token *token, int quote)
+{
+	static char buffer[MAX_STRING];
+	char *ptr = buffer;
+	int whitespace = 0;
+
+	if (!token && !quote)
+		return "<none>";
+	while (!eof_token(token)) {
+		const char *val = quote ? quote_token(token) : show_token(token);
+		int len = strlen(val);
+
+		if (ptr + whitespace + len >= buffer + sizeof(buffer)) {
+			sparse_error(token->pos, "too long token expansion");
+			break;
+		}
+
+		if (whitespace)
+			*ptr++ = ' ';
+		memcpy(ptr, val, len);
+		ptr += len;
+		token = token->next;
+		whitespace = token->pos.whitespace;
+	}
+	*ptr = 0;
+	return buffer;
+}
+
+static struct token *stringify(struct token *arg)
+{
+	const char *s = show_token_sequence(arg, 1);
+	int size = strlen(s)+1;
+	struct token *token = __alloc_token(0);
+	struct string *string = __alloc_string(size);
+
+	memcpy(string->data, s, size);
+	string->length = size;
+	token->pos = arg->pos;
+	token_type(token) = TOKEN_STRING;
+	token->string = string;
+	token->next = &eof_token_entry;
+	return token;
+}
+
+static void expand_arguments(int count, struct arg *args)
+{
+	int i;
+	for (i = 0; i < count; i++) {
+		struct token *arg = args[i].arg;
+		if (!arg)
+			arg = &eof_token_entry;
+		if (args[i].n_str)
+			args[i].str = stringify(arg);
+		if (args[i].n_normal) {
+			if (!args[i].n_quoted) {
+				args[i].expanded = arg;
+				args[i].arg = NULL;
+			} else if (eof_token(arg)) {
+				args[i].expanded = arg;
+			} else {
+				args[i].expanded = dup_list(arg);
+			}
+			expand_list(&args[i].expanded);
+		}
+	}
+}
+
+/*
+ * Possibly valid combinations:
+ *  - ident + ident -> ident
+ *  - ident + number -> ident unless number contains '.', '+' or '-'.
+ *  - 'L' + char constant -> wide char constant
+ *  - 'L' + string literal -> wide string literal
+ *  - number + number -> number
+ *  - number + ident -> number
+ *  - number + '.' -> number
+ *  - number + '+' or '-' -> number, if number used to end on [eEpP].
+ *  - '.' + number -> number, if number used to start with a digit.
+ *  - special + special -> either special or an error.
+ */
+static enum token_type combine(struct token *left, struct token *right, char *p)
+{
+	int len;
+	enum token_type t1 = token_type(left), t2 = token_type(right);
+
+	if (t1 != TOKEN_IDENT && t1 != TOKEN_NUMBER && t1 != TOKEN_SPECIAL)
+		return TOKEN_ERROR;
+
+	if (t1 == TOKEN_IDENT && left->ident == &L_ident) {
+		if (t2 >= TOKEN_CHAR && t2 < TOKEN_WIDE_CHAR)
+			return t2 + TOKEN_WIDE_CHAR - TOKEN_CHAR;
+		if (t2 == TOKEN_STRING)
+			return TOKEN_WIDE_STRING;
+	}
+
+	if (t2 != TOKEN_IDENT && t2 != TOKEN_NUMBER && t2 != TOKEN_SPECIAL)
+		return TOKEN_ERROR;
+
+	strcpy(p, show_token(left));
+	strcat(p, show_token(right));
+	len = strlen(p);
+
+	if (len >= 256)
+		return TOKEN_ERROR;
+
+	if (t1 == TOKEN_IDENT) {
+		if (t2 == TOKEN_SPECIAL)
+			return TOKEN_ERROR;
+		if (t2 == TOKEN_NUMBER && strpbrk(p, "+-."))
+			return TOKEN_ERROR;
+		return TOKEN_IDENT;
+	}
+
+	if (t1 == TOKEN_NUMBER) {
+		if (t2 == TOKEN_SPECIAL) {
+			switch (right->special) {
+			case '.':
+				break;
+			case '+': case '-':
+				if (strchr("eEpP", p[len - 2]))
+					break;
+			default:
+				return TOKEN_ERROR;
+			}
+		}
+		return TOKEN_NUMBER;
+	}
+
+	if (p[0] == '.' && isdigit((unsigned char)p[1]))
+		return TOKEN_NUMBER;
+
+	return TOKEN_SPECIAL;
+}
+
+static int merge(struct token *left, struct token *right)
+{
+	static char buffer[512];
+	enum token_type res = combine(left, right, buffer);
+	int n;
+
+	switch (res) {
+	case TOKEN_IDENT:
+		left->ident = built_in_ident(buffer);
+		left->pos.noexpand = 0;
+		return 1;
+
+	case TOKEN_NUMBER: {
+		char *number = __alloc_bytes(strlen(buffer) + 1);
+		memcpy(number, buffer, strlen(buffer) + 1);
+		token_type(left) = TOKEN_NUMBER;	/* could be . + num */
+		left->number = number;
+		return 1;
+	}
+
+	case TOKEN_SPECIAL:
+		if (buffer[2] && buffer[3])
+			break;
+		for (n = SPECIAL_BASE; n < SPECIAL_ARG_SEPARATOR; n++) {
+			if (!memcmp(buffer, combinations[n-SPECIAL_BASE], 3)) {
+				left->special = n;
+				return 1;
+			}
+		}
+		break;
+
+	case TOKEN_WIDE_CHAR:
+	case TOKEN_WIDE_STRING:
+		token_type(left) = res;
+		left->pos.noexpand = 0;
+		left->string = right->string;
+		return 1;
+
+	case TOKEN_WIDE_CHAR_EMBEDDED_0 ... TOKEN_WIDE_CHAR_EMBEDDED_3:
+		token_type(left) = res;
+		left->pos.noexpand = 0;
+		memcpy(left->embedded, right->embedded, 4);
+		return 1;
+
+	default:
+		;
+	}
+	sparse_error(left->pos, "'##' failed: concatenation is not a valid token");
+	return 0;
+}
+
+static struct token *dup_token(struct token *token, struct position *streampos)
+{
+	struct token *alloc = alloc_token(streampos);
+	token_type(alloc) = token_type(token);
+	alloc->pos.newline = token->pos.newline;
+	alloc->pos.whitespace = token->pos.whitespace;
+	alloc->number = token->number;
+	alloc->pos.noexpand = token->pos.noexpand;
+	return alloc;	
+}
+
+static struct token **copy(struct token **where, struct token *list, int *count)
+{
+	int need_copy = --*count;
+	while (!eof_token(list)) {
+		struct token *token;
+		if (need_copy)
+			token = dup_token(list, &list->pos);
+		else
+			token = list;
+		if (token_type(token) == TOKEN_IDENT && token->ident->tainted)
+			token->pos.noexpand = 1;
+		*where = token;
+		where = &token->next;
+		list = list->next;
+	}
+	*where = &eof_token_entry;
+	return where;
+}
+
+static int handle_kludge(struct token **p, struct arg *args)
+{
+	struct token *t = (*p)->next->next;
+	while (1) {
+		struct arg *v = &args[t->argnum];
+		if (token_type(t->next) != TOKEN_CONCAT) {
+			if (v->arg) {
+				/* ignore the first ## */
+				*p = (*p)->next;
+				return 0;
+			}
+			/* skip the entire thing */
+			*p = t;
+			return 1;
+		}
+		if (v->arg && !eof_token(v->arg))
+			return 0; /* no magic */
+		t = t->next->next;
+	}
+}
+
+static struct token **substitute(struct token **list, struct token *body, struct arg *args)
+{
+	struct position *base_pos = &(*list)->pos;
+	int *count;
+	enum {Normal, Placeholder, Concat} state = Normal;
+
+	for (; !eof_token(body); body = body->next) {
+		struct token *added, *arg;
+		struct token **tail;
+		struct token *t;
+
+		switch (token_type(body)) {
+		case TOKEN_GNU_KLUDGE:
+			/*
+			 * GNU kludge: if we had <comma>##<vararg>, behaviour
+			 * depends on whether we had enough arguments to have
+			 * a vararg.  If we did, ## is just ignored.  Otherwise
+			 * both , and ## are ignored.  Worse, there can be
+			 * an arbitrary number of ##<arg> in between; if all of
+			 * those are empty, we act as if they hadn't been there,
+			 * otherwise we act as if the kludge didn't exist.
+			 */
+			t = body;
+			if (handle_kludge(&body, args)) {
+				if (state == Concat)
+					state = Normal;
+				else
+					state = Placeholder;
+				continue;
+			}
+			added = dup_token(t, base_pos);
+			token_type(added) = TOKEN_SPECIAL;
+			tail = &added->next;
+			break;
+
+		case TOKEN_STR_ARGUMENT:
+			arg = args[body->argnum].str;
+			count = &args[body->argnum].n_str;
+			goto copy_arg;
+
+		case TOKEN_QUOTED_ARGUMENT:
+			arg = args[body->argnum].arg;
+			count = &args[body->argnum].n_quoted;
+			if (!arg || eof_token(arg)) {
+				if (state == Concat)
+					state = Normal;
+				else
+					state = Placeholder;
+				continue;
+			}
+			goto copy_arg;
+
+		case TOKEN_MACRO_ARGUMENT:
+			arg = args[body->argnum].expanded;
+			count = &args[body->argnum].n_normal;
+			if (eof_token(arg)) {
+				state = Normal;
+				continue;
+			}
+		copy_arg:
+			tail = copy(&added, arg, count);
+			added->pos.newline = body->pos.newline;
+			added->pos.whitespace = body->pos.whitespace;
+			break;
+
+		case TOKEN_CONCAT:
+			if (state == Placeholder)
+				state = Normal;
+			else
+				state = Concat;
+			continue;
+
+		case TOKEN_IDENT:
+			added = dup_token(body, base_pos);
+			if (added->ident->tainted)
+				added->pos.noexpand = 1;
+			tail = &added->next;
+			break;
+
+		default:
+			added = dup_token(body, base_pos);
+			tail = &added->next;
+			break;
+		}
+
+		/*
+		 * if we got to doing real concatenation, we already have
+		 * added something into the list, so containing_token() is OK.
+		 */
+		if (state == Concat && merge(containing_token(list), added)) {
+			*list = added->next;
+			if (tail != &added->next)
+				list = tail;
+		} else {
+			*list = added;
+			list = tail;
+		}
+		state = Normal;
+	}
+	*list = &eof_token_entry;
+	return list;
+}
+
+static int expand(struct token **list, struct symbol *sym)
+{
+	struct token *last;
+	struct token *token = *list;
+	struct ident *expanding = token->ident;
+	struct token **tail;
+	int nargs = sym->arglist ? sym->arglist->count.normal : 0;
+	struct arg args[nargs];
+
+	if (expanding->tainted) {
+		token->pos.noexpand = 1;
+		return 1;
+	}
+
+	if (sym->arglist) {
+		if (!match_op(scan_next(&token->next), '('))
+			return 1;
+		if (!collect_arguments(token->next, sym->arglist, args, token))
+			return 1;
+		expand_arguments(nargs, args);
+	}
+
+	expanding->tainted = 1;
+
+	last = token->next;
+	tail = substitute(list, sym->expansion, args);
+	/*
+	 * Note that it won't be eof - at least TOKEN_UNTAINT will be there.
+	 * We still can lose the newline flag if the sucker expands to nothing,
+	 * but the price of dealing with that is probably too high (we'd need
+	 * to collect the flags during scan_next())
+	 */
+	(*list)->pos.newline = token->pos.newline;
+	(*list)->pos.whitespace = token->pos.whitespace;
+	*tail = last;
+
+	return 0;
+}
+
+static const char *token_name_sequence(struct token *token, int endop, struct token *start)
+{
+	static char buffer[256];
+	char *ptr = buffer;
+
+	while (!eof_token(token) && !match_op(token, endop)) {
+		int len;
+		const char *val = token->string->data;
+		if (token_type(token) != TOKEN_STRING)
+			val = show_token(token);
+		len = strlen(val);
+		memcpy(ptr, val, len);
+		ptr += len;
+		token = token->next;
+	}
+	*ptr = 0;
+	if (endop && !match_op(token, endop))
+		sparse_error(start->pos, "expected '>' at end of filename");
+	return buffer;
+}
+
+static int already_tokenized(const char *path)
+{
+	int stream, next;
+
+	for (stream = *hash_stream(path); stream >= 0 ; stream = next) {
+		struct stream *s = input_streams + stream;
+
+		next = s->next_stream;
+		if (s->once) {
+			if (strcmp(path, s->name))
+				continue;
+			return 1;
+		}
+		if (s->constant != CONSTANT_FILE_YES)
+			continue;
+		if (strcmp(path, s->name))
+			continue;
+		if (s->protect && !lookup_macro(s->protect))
+			continue;
+		return 1;
+	}
+	return 0;
+}
+
+/* Handle include of header files.
+ * The relevant options are made compatible with gcc. The only options that
+ * are not supported is -withprefix and friends.
+ *
+ * Three set of include paths are known:
+ * quote_includepath:	Path to search when using #include "file.h"
+ * angle_includepath:	Paths to search when using #include <file.h>
+ * isys_includepath:	Paths specified with -isystem, come before the
+ *			built-in system include paths. Gcc would suppress
+ *			warnings from system headers. Here we separate
+ *			them from the angle_ ones to keep search ordering.
+ *
+ * sys_includepath:	Built-in include paths.
+ * dirafter_includepath Paths added with -dirafter.
+ *
+ * The above is implemented as one array with pointers
+ *                         +--------------+
+ * quote_includepath --->  |              |
+ *                         +--------------+
+ *                         |              |
+ *                         +--------------+
+ * angle_includepath --->  |              |
+ *                         +--------------+
+ * isys_includepath  --->  |              |
+ *                         +--------------+
+ * sys_includepath   --->  |              |
+ *                         +--------------+
+ * dirafter_includepath -> |              |
+ *                         +--------------+
+ *
+ * -I dir insert dir just before isys_includepath and move the rest
+ * -I- makes all dirs specified with -I before to quote dirs only and
+ *   angle_includepath is set equal to isys_includepath.
+ * -nostdinc removes all sys dirs by storing NULL in entry pointed
+ *   to by * sys_includepath. Note that this will reset all dirs built-in
+ *   and added before -nostdinc by -isystem and -idirafter.
+ * -isystem dir adds dir where isys_includepath points adding this dir as
+ *   first systemdir
+ * -idirafter dir adds dir to the end of the list
+ */
+
+static void set_stream_include_path(struct stream *stream)
+{
+	const char *path = stream->path;
+	if (!path) {
+		const char *p = strrchr(stream->name, '/');
+		path = "";
+		if (p) {
+			int len = p - stream->name + 1;
+			char *m = malloc(len+1);
+			/* This includes the final "/" */
+			memcpy(m, stream->name, len);
+			m[len] = 0;
+			path = m;
+		}
+		stream->path = path;
+	}
+	includepath[0] = path;
+}
+
+static int try_include(const char *path, const char *filename, int flen, struct token **where, const char **next_path)
+{
+	int fd;
+	int plen = strlen(path);
+	static char fullname[PATH_MAX];
+
+	memcpy(fullname, path, plen);
+	if (plen && path[plen-1] != '/') {
+		fullname[plen] = '/';
+		plen++;
+	}
+	memcpy(fullname+plen, filename, flen);
+	if (already_tokenized(fullname))
+		return 1;
+	fd = open(fullname, O_RDONLY);
+	if (fd >= 0) {
+		char * streamname = __alloc_bytes(plen + flen);
+		memcpy(streamname, fullname, plen + flen);
+		*where = tokenize(streamname, fd, *where, next_path);
+		close(fd);
+		return 1;
+	}
+	return 0;
+}
+
+static int do_include_path(const char **pptr, struct token **list, struct token *token, const char *filename, int flen)
+{
+	const char *path;
+
+	while ((path = *pptr++) != NULL) {
+		if (!try_include(path, filename, flen, list, pptr))
+			continue;
+		return 1;
+	}
+	return 0;
+}
+
+static int free_preprocessor_line(struct token *token)
+{
+	while (token_type(token) != TOKEN_EOF) {
+		struct token *free = token;
+		token = token->next;
+		__free_token(free);
+	};
+	return 1;
+}
+
+const char *find_include(const char *skip, const char *look_for)
+{
+	DIR *dp;
+	struct dirent *entry;
+	struct stat statbuf;
+	const char *ret;
+	char cwd[PATH_MAX];
+	static char buf[PATH_MAX + 1];
+
+	dp = opendir(".");
+	if (!dp)
+		return NULL;
+
+	if (!getcwd(cwd, sizeof(cwd)))
+		return NULL;
+
+	while ((entry = readdir(dp))) {
+		lstat(entry->d_name, &statbuf);
+
+		if (strcmp(entry->d_name, look_for) == 0) {
+			snprintf(buf, sizeof(buf), "%s/%s", cwd, entry->d_name);
+			return buf;
+		}
+
+		if (S_ISDIR(statbuf.st_mode)) {
+			/* Found a directory, but ignore . and .. */
+			if (strcmp(".", entry->d_name) == 0 ||
+			    strcmp("..", entry->d_name) == 0 ||
+			    strcmp(skip, entry->d_name) == 0)
+				continue;
+
+			chdir(entry->d_name);
+			ret = find_include("", look_for);
+			chdir("..");
+			if (ret)
+				return ret;
+		}
+	}
+	closedir(dp);
+
+	return NULL;
+}
+
+const char *search_dir(const char *stop, const char *look_for)
+{
+	char cwd[PATH_MAX];
+	int len;
+	const char *ret;
+	int cnt = 0;
+
+	if (!getcwd(cwd, sizeof(cwd)))
+		return NULL;
+
+	len = strlen(cwd);
+	while (len >= 0) {
+		ret = find_include(cnt++ ? cwd + len + 1 : "", look_for);
+		if (ret)
+			return ret;
+
+		if (strcmp(cwd, stop) == 0 ||
+		    strcmp(cwd, "/usr/include") == 0 ||
+		    strcmp(cwd, "/usr/local/include") == 0 ||
+		    strlen(cwd) <= 10 ||  /* heck...  don't search /usr/lib/ */
+		    strcmp(cwd, "/") == 0)
+			return NULL;
+
+		while (--len >= 0) {
+			if (cwd[len] == '/') {
+				cwd[len] = '\0';
+				break;
+			}
+		}
+
+		chdir("..");
+	}
+	return NULL;
+}
+
+static void use_best_guess_header_file(struct token *token, const char *filename, struct token **list)
+{
+	char cwd[PATH_MAX];
+	char dir_part[PATH_MAX];
+	const char *file_part;
+	const char *include_name;
+	int len;
+
+	if (!filename || filename[0] == '\0')
+		return;
+
+	file_part = filename;
+	while ((filename = strchr(filename, '/'))) {
+		++filename;
+		if (filename[0])
+			file_part = filename;
+	}
+
+	snprintf(dir_part, sizeof(dir_part), "%s", stream_name(token->pos.stream));
+	len = strlen(dir_part);
+	while (--len >= 0) {
+		if (dir_part[len] == '/') {
+			dir_part[len] = '\0';
+			break;
+		}
+	}
+	if (len < 0)
+		sprintf(dir_part, ".");
+
+	if (!getcwd(cwd, sizeof(cwd)))
+		return;
+
+	chdir(dir_part);
+	include_name = search_dir(cwd, file_part);
+	chdir(cwd);
+	if (!include_name)
+		return;
+	sparse_error(token->pos, "using '%s'", include_name);
+
+	try_include("", include_name, strlen(include_name), list, includepath);
+}
+
+static int handle_include_path(struct stream *stream, struct token **list, struct token *token, int how)
+{
+	const char *filename;
+	struct token *next;
+	const char **path;
+	int expect;
+	int flen;
+
+	next = token->next;
+	expect = '>';
+	if (!match_op(next, '<')) {
+		expand_list(&token->next);
+		expect = 0;
+		next = token;
+		if (match_op(token->next, '<')) {
+			next = token->next;
+			expect = '>';
+		}
+	}
+
+	token = next->next;
+	filename = token_name_sequence(token, expect, token);
+	flen = strlen(filename) + 1;
+
+	/* Absolute path? */
+	if (filename[0] == '/') {
+		if (try_include("", filename, flen, list, includepath))
+			return 0;
+		goto out;
+	}
+
+	switch (how) {
+	case 1:
+		path = stream->next_path;
+		break;
+	case 2:
+		includepath[0] = "";
+		path = includepath;
+		break;
+	default:
+		/* Dir of input file is first dir to search for quoted includes */
+		set_stream_include_path(stream);
+		path = expect ? angle_includepath : quote_includepath;
+		break;
+	}
+	/* Check the standard include paths.. */
+	if (do_include_path(path, list, token, filename, flen))
+		return 0;
+out:
+	sparse_error(token->pos, "unable to open '%s'", filename);
+	use_best_guess_header_file(token, filename, list);
+	return 0;
+}
+
+static int handle_include(struct stream *stream, struct token **list, struct token *token)
+{
+	return handle_include_path(stream, list, token, 0);
+}
+
+static int handle_include_next(struct stream *stream, struct token **list, struct token *token)
+{
+	return handle_include_path(stream, list, token, 1);
+}
+
+static int handle_argv_include(struct stream *stream, struct token **list, struct token *token)
+{
+	return handle_include_path(stream, list, token, 2);
+}
+
+static int token_different(struct token *t1, struct token *t2)
+{
+	int different;
+
+	if (token_type(t1) != token_type(t2))
+		return 1;
+
+	switch (token_type(t1)) {
+	case TOKEN_IDENT:
+		different = t1->ident != t2->ident;
+		break;
+	case TOKEN_ARG_COUNT:
+	case TOKEN_UNTAINT:
+	case TOKEN_CONCAT:
+	case TOKEN_GNU_KLUDGE:
+		different = 0;
+		break;
+	case TOKEN_NUMBER:
+		different = strcmp(t1->number, t2->number);
+		break;
+	case TOKEN_SPECIAL:
+		different = t1->special != t2->special;
+		break;
+	case TOKEN_MACRO_ARGUMENT:
+	case TOKEN_QUOTED_ARGUMENT:
+	case TOKEN_STR_ARGUMENT:
+		different = t1->argnum != t2->argnum;
+		break;
+	case TOKEN_CHAR_EMBEDDED_0 ... TOKEN_CHAR_EMBEDDED_3:
+	case TOKEN_WIDE_CHAR_EMBEDDED_0 ... TOKEN_WIDE_CHAR_EMBEDDED_3:
+		different = memcmp(t1->embedded, t2->embedded, 4);
+		break;
+	case TOKEN_CHAR:
+	case TOKEN_WIDE_CHAR:
+	case TOKEN_STRING:
+	case TOKEN_WIDE_STRING: {
+		struct string *s1, *s2;
+
+		s1 = t1->string;
+		s2 = t2->string;
+		different = 1;
+		if (s1->length != s2->length)
+			break;
+		different = memcmp(s1->data, s2->data, s1->length);
+		break;
+	}
+	default:
+		different = 1;
+		break;
+	}
+	return different;
+}
+
+static int token_list_different(struct token *list1, struct token *list2)
+{
+	for (;;) {
+		if (list1 == list2)
+			return 0;
+		if (!list1 || !list2)
+			return 1;
+		if (token_different(list1, list2))
+			return 1;
+		list1 = list1->next;
+		list2 = list2->next;
+	}
+}
+
+static inline void set_arg_count(struct token *token)
+{
+	token_type(token) = TOKEN_ARG_COUNT;
+	token->count.normal = token->count.quoted =
+	token->count.str = token->count.vararg = 0;
+}
+
+static struct token *parse_arguments(struct token *list)
+{
+	struct token *arg = list->next, *next = list;
+	struct argcount *count = &list->count;
+
+	set_arg_count(list);
+
+	if (match_op(arg, ')')) {
+		next = arg->next;
+		list->next = &eof_token_entry;
+		return next;
+	}
+
+	while (token_type(arg) == TOKEN_IDENT) {
+		if (arg->ident == &__VA_ARGS___ident)
+			goto Eva_args;
+		if (!++count->normal)
+			goto Eargs;
+		next = arg->next;
+
+		if (match_op(next, ',')) {
+			set_arg_count(next);
+			arg = next->next;
+			continue;
+		}
+
+		if (match_op(next, ')')) {
+			set_arg_count(next);
+			next = next->next;
+			arg->next->next = &eof_token_entry;
+			return next;
+		}
+
+		/* normal cases are finished here */
+
+		if (match_op(next, SPECIAL_ELLIPSIS)) {
+			if (match_op(next->next, ')')) {
+				set_arg_count(next);
+				next->count.vararg = 1;
+				next = next->next;
+				arg->next->next = &eof_token_entry;
+				return next->next;
+			}
+
+			arg = next;
+			goto Enotclosed;
+		}
+
+		if (eof_token(next)) {
+			goto Enotclosed;
+		} else {
+			arg = next;
+			goto Ebadstuff;
+		}
+	}
+
+	if (match_op(arg, SPECIAL_ELLIPSIS)) {
+		next = arg->next;
+		token_type(arg) = TOKEN_IDENT;
+		arg->ident = &__VA_ARGS___ident;
+		if (!match_op(next, ')'))
+			goto Enotclosed;
+		if (!++count->normal)
+			goto Eargs;
+		set_arg_count(next);
+		next->count.vararg = 1;
+		next = next->next;
+		arg->next->next = &eof_token_entry;
+		return next;
+	}
+
+	if (eof_token(arg)) {
+		arg = next;
+		goto Enotclosed;
+	}
+	if (match_op(arg, ','))
+		goto Emissing;
+	else
+		goto Ebadstuff;
+
+
+Emissing:
+	sparse_error(arg->pos, "parameter name missing");
+	return NULL;
+Ebadstuff:
+	sparse_error(arg->pos, "\"%s\" may not appear in macro parameter list",
+		show_token(arg));
+	return NULL;
+Enotclosed:
+	sparse_error(arg->pos, "missing ')' in macro parameter list");
+	return NULL;
+Eva_args:
+	sparse_error(arg->pos, "__VA_ARGS__ can only appear in the expansion of a C99 variadic macro");
+	return NULL;
+Eargs:
+	sparse_error(arg->pos, "too many arguments in macro definition");
+	return NULL;
+}
+
+static int try_arg(struct token *token, enum token_type type, struct token *arglist)
+{
+	struct ident *ident = token->ident;
+	int nr;
+
+	if (!arglist || token_type(token) != TOKEN_IDENT)
+		return 0;
+
+	arglist = arglist->next;
+
+	for (nr = 0; !eof_token(arglist); nr++, arglist = arglist->next->next) {
+		if (arglist->ident == ident) {
+			struct argcount *count = &arglist->next->count;
+			int n;
+
+			token->argnum = nr;
+			token_type(token) = type;
+			switch (type) {
+			case TOKEN_MACRO_ARGUMENT:
+				n = ++count->normal;
+				break;
+			case TOKEN_QUOTED_ARGUMENT:
+				n = ++count->quoted;
+				break;
+			default:
+				n = ++count->str;
+			}
+			if (n)
+				return count->vararg ? 2 : 1;
+			/*
+			 * XXX - need saner handling of that
+			 * (>= 1024 instances of argument)
+			 */
+			token_type(token) = TOKEN_ERROR;
+			return -1;
+		}
+	}
+	return 0;
+}
+
+static struct token *handle_hash(struct token **p, struct token *arglist)
+{
+	struct token *token = *p;
+	if (arglist) {
+		struct token *next = token->next;
+		if (!try_arg(next, TOKEN_STR_ARGUMENT, arglist))
+			goto Equote;
+		next->pos.whitespace = token->pos.whitespace;
+		__free_token(token);
+		token = *p = next;
+	} else {
+		token->pos.noexpand = 1;
+	}
+	return token;
+
+Equote:
+	sparse_error(token->pos, "'#' is not followed by a macro parameter");
+	return NULL;
+}
+
+/* token->next is ## */
+static struct token *handle_hashhash(struct token *token, struct token *arglist)
+{
+	struct token *last = token;
+	struct token *concat;
+	int state = match_op(token, ',');
+	
+	try_arg(token, TOKEN_QUOTED_ARGUMENT, arglist);
+
+	while (1) {
+		struct token *t;
+		int is_arg;
+
+		/* eat duplicate ## */
+		concat = token->next;
+		while (match_op(t = concat->next, SPECIAL_HASHHASH)) {
+			token->next = t;
+			__free_token(concat);
+			concat = t;
+		}
+		token_type(concat) = TOKEN_CONCAT;
+
+		if (eof_token(t))
+			goto Econcat;
+
+		if (match_op(t, '#')) {
+			t = handle_hash(&concat->next, arglist);
+			if (!t)
+				return NULL;
+		}
+
+		is_arg = try_arg(t, TOKEN_QUOTED_ARGUMENT, arglist);
+
+		if (state == 1 && is_arg) {
+			state = is_arg;
+		} else {
+			last = t;
+			state = match_op(t, ',');
+		}
+
+		token = t;
+		if (!match_op(token->next, SPECIAL_HASHHASH))
+			break;
+	}
+	/* handle GNU ,##__VA_ARGS__ kludge, in all its weirdness */
+	if (state == 2)
+		token_type(last) = TOKEN_GNU_KLUDGE;
+	return token;
+
+Econcat:
+	sparse_error(concat->pos, "'##' cannot appear at the ends of macro expansion");
+	return NULL;
+}
+
+static struct token *parse_expansion(struct token *expansion, struct token *arglist, struct ident *name)
+{
+	struct token *token = expansion;
+	struct token **p;
+
+	if (match_op(token, SPECIAL_HASHHASH))
+		goto Econcat;
+
+	for (p = &expansion; !eof_token(token); p = &token->next, token = *p) {
+		if (match_op(token, '#')) {
+			token = handle_hash(p, arglist);
+			if (!token)
+				return NULL;
+		}
+		if (match_op(token->next, SPECIAL_HASHHASH)) {
+			token = handle_hashhash(token, arglist);
+			if (!token)
+				return NULL;
+		} else {
+			try_arg(token, TOKEN_MACRO_ARGUMENT, arglist);
+		}
+		switch (token_type(token)) {
+		case TOKEN_ERROR:
+			goto Earg;
+
+		case TOKEN_STRING:
+		case TOKEN_WIDE_STRING:
+			token->string->immutable = 1;
+			break;
+		}
+	}
+	token = alloc_token(&expansion->pos);
+	token_type(token) = TOKEN_UNTAINT;
+	token->ident = name;
+	token->next = *p;
+	*p = token;
+	return expansion;
+
+Econcat:
+	sparse_error(token->pos, "'##' cannot appear at the ends of macro expansion");
+	return NULL;
+Earg:
+	sparse_error(token->pos, "too many instances of argument in body");
+	return NULL;
+}
+
+static int do_handle_define(struct stream *stream, struct token **line, struct token *token, int attr)
+{
+	struct token *arglist, *expansion;
+	struct token *left = token->next;
+	struct symbol *sym;
+	struct ident *name;
+	int ret;
+
+	if (token_type(left) != TOKEN_IDENT) {
+		sparse_error(token->pos, "expected identifier to 'define'");
+		return 1;
+	}
+
+	name = left->ident;
+
+	arglist = NULL;
+	expansion = left->next;
+	if (!expansion->pos.whitespace) {
+		if (match_op(expansion, '(')) {
+			arglist = expansion;
+			expansion = parse_arguments(expansion);
+			if (!expansion)
+				return 1;
+		} else if (!eof_token(expansion)) {
+			warning(expansion->pos,
+				"no whitespace before object-like macro body");
+		}
+	}
+
+	expansion = parse_expansion(expansion, arglist, name);
+	if (!expansion)
+		return 1;
+
+	ret = 1;
+	sym = lookup_symbol(name, NS_MACRO | NS_UNDEF);
+	if (sym) {
+		int clean;
+
+		if (attr < sym->attr)
+			goto out;
+
+		clean = (attr == sym->attr && sym->namespace == NS_MACRO);
+
+		if (token_list_different(sym->expansion, expansion) ||
+		    token_list_different(sym->arglist, arglist)) {
+			ret = 0;
+			if ((clean && attr == SYM_ATTR_NORMAL)
+					|| sym->used_in == file_scope) {
+				warning(left->pos, "preprocessor token %.*s redefined",
+						name->len, name->name);
+				info(sym->pos, "this was the original definition");
+			}
+		} else if (clean)
+			goto out;
+	}
+
+	if (!sym || sym->scope != file_scope) {
+		sym = alloc_symbol(left->pos, SYM_NODE);
+		bind_symbol(sym, name, NS_MACRO);
+		add_ident(&macros, name);
+		ret = 0;
+	}
+
+	if (!ret) {
+		sym->expansion = expansion;
+		sym->arglist = arglist;
+		__free_token(token);	/* Free the "define" token, but not the rest of the line */
+	}
+
+	sym->namespace = NS_MACRO;
+	sym->used_in = NULL;
+	sym->attr = attr;
+out:
+	return ret;
+}
+
+static int handle_define(struct stream *stream, struct token **line, struct token *token)
+{
+	return do_handle_define(stream, line, token, SYM_ATTR_NORMAL);
+}
+
+static int handle_weak_define(struct stream *stream, struct token **line, struct token *token)
+{
+	return do_handle_define(stream, line, token, SYM_ATTR_WEAK);
+}
+
+static int handle_strong_define(struct stream *stream, struct token **line, struct token *token)
+{
+	return do_handle_define(stream, line, token, SYM_ATTR_STRONG);
+}
+
+static int do_handle_undef(struct stream *stream, struct token **line, struct token *token, int attr)
+{
+	struct token *left = token->next;
+	struct symbol *sym;
+
+	if (token_type(left) != TOKEN_IDENT) {
+		sparse_error(token->pos, "expected identifier to 'undef'");
+		return 1;
+	}
+
+	sym = lookup_symbol(left->ident, NS_MACRO | NS_UNDEF);
+	if (sym) {
+		if (attr < sym->attr)
+			return 1;
+		if (attr == sym->attr && sym->namespace == NS_UNDEF)
+			return 1;
+	} else if (attr <= SYM_ATTR_NORMAL)
+		return 1;
+
+	if (!sym || sym->scope != file_scope) {
+		sym = alloc_symbol(left->pos, SYM_NODE);
+		bind_symbol(sym, left->ident, NS_MACRO);
+	}
+
+	sym->namespace = NS_UNDEF;
+	sym->used_in = NULL;
+	sym->attr = attr;
+
+	return 1;
+}
+
+static int handle_undef(struct stream *stream, struct token **line, struct token *token)
+{
+	return do_handle_undef(stream, line, token, SYM_ATTR_NORMAL);
+}
+
+static int handle_strong_undef(struct stream *stream, struct token **line, struct token *token)
+{
+	return do_handle_undef(stream, line, token, SYM_ATTR_STRONG);
+}
+
+static int preprocessor_if(struct stream *stream, struct token *token, int true)
+{
+	token_type(token) = false_nesting ? TOKEN_SKIP_GROUPS : TOKEN_IF;
+	free_preprocessor_line(token->next);
+	token->next = stream->top_if;
+	stream->top_if = token;
+	if (false_nesting || true != 1)
+		false_nesting++;
+	return 0;
+}
+
+static int handle_ifdef(struct stream *stream, struct token **line, struct token *token)
+{
+	struct token *next = token->next;
+	int arg;
+	if (token_type(next) == TOKEN_IDENT) {
+		arg = token_defined(next);
+	} else {
+		dirty_stream(stream);
+		if (!false_nesting)
+			sparse_error(token->pos, "expected preprocessor identifier");
+		arg = -1;
+	}
+	return preprocessor_if(stream, token, arg);
+}
+
+static int handle_ifndef(struct stream *stream, struct token **line, struct token *token)
+{
+	struct token *next = token->next;
+	int arg;
+	if (token_type(next) == TOKEN_IDENT) {
+		if (!stream->dirty && !stream->ifndef) {
+			if (!stream->protect) {
+				stream->ifndef = token;
+				stream->protect = next->ident;
+			} else if (stream->protect == next->ident) {
+				stream->ifndef = token;
+				stream->dirty = 1;
+			}
+		}
+		arg = !token_defined(next);
+	} else {
+		dirty_stream(stream);
+		if (!false_nesting)
+			sparse_error(token->pos, "expected preprocessor identifier");
+		arg = -1;
+	}
+
+	return preprocessor_if(stream, token, arg);
+}
+
+static const char *show_token_sequence(struct token *token, int quote);
+
+/*
+ * Expression handling for #if and #elif; it differs from normal expansion
+ * due to special treatment of "defined".
+ */
+static int expression_value(struct token **where)
+{
+	struct expression *expr;
+	struct token *p;
+	struct token **list = where, **beginning = NULL;
+	long long value;
+	int state = 0;
+
+	while (!eof_token(p = scan_next(list))) {
+		switch (state) {
+		case 0:
+			if (token_type(p) != TOKEN_IDENT)
+				break;
+			if (p->ident == &defined_ident) {
+				state = 1;
+				beginning = list;
+				break;
+			}
+			if (!expand_one_symbol(list))
+				continue;
+			if (token_type(p) != TOKEN_IDENT)
+				break;
+			token_type(p) = TOKEN_ZERO_IDENT;
+			break;
+		case 1:
+			if (match_op(p, '(')) {
+				state = 2;
+			} else {
+				state = 0;
+				replace_with_defined(p);
+				*beginning = p;
+			}
+			break;
+		case 2:
+			if (token_type(p) == TOKEN_IDENT)
+				state = 3;
+			else
+				state = 0;
+			replace_with_defined(p);
+			*beginning = p;
+			break;
+		case 3:
+			state = 0;
+			if (!match_op(p, ')'))
+				sparse_error(p->pos, "missing ')' after \"defined\"");
+			*list = p->next;
+			continue;
+		}
+		list = &p->next;
+	}
+
+	p = constant_expression(*where, &expr);
+	if (!eof_token(p))
+		sparse_error(p->pos, "garbage at end: %s", show_token_sequence(p, 0));
+	value = get_expression_value(expr);
+	return value != 0;
+}
+
+static int handle_if(struct stream *stream, struct token **line, struct token *token)
+{
+	int value = 0;
+	if (!false_nesting)
+		value = expression_value(&token->next);
+
+	dirty_stream(stream);
+	return preprocessor_if(stream, token, value);
+}
+
+static int handle_elif(struct stream * stream, struct token **line, struct token *token)
+{
+	struct token *top_if = stream->top_if;
+	end_group(stream);
+
+	if (!top_if) {
+		nesting_error(stream);
+		sparse_error(token->pos, "unmatched #elif within stream");
+		return 1;
+	}
+
+	if (token_type(top_if) == TOKEN_ELSE) {
+		nesting_error(stream);
+		sparse_error(token->pos, "#elif after #else");
+		if (!false_nesting)
+			false_nesting = 1;
+		return 1;
+	}
+
+	dirty_stream(stream);
+	if (token_type(top_if) != TOKEN_IF)
+		return 1;
+	if (false_nesting) {
+		false_nesting = 0;
+		if (!expression_value(&token->next))
+			false_nesting = 1;
+	} else {
+		false_nesting = 1;
+		token_type(top_if) = TOKEN_SKIP_GROUPS;
+	}
+	return 1;
+}
+
+static int handle_else(struct stream *stream, struct token **line, struct token *token)
+{
+	struct token *top_if = stream->top_if;
+	end_group(stream);
+
+	if (!top_if) {
+		nesting_error(stream);
+		sparse_error(token->pos, "unmatched #else within stream");
+		return 1;
+	}
+
+	if (token_type(top_if) == TOKEN_ELSE) {
+		nesting_error(stream);
+		sparse_error(token->pos, "#else after #else");
+	}
+	if (false_nesting) {
+		if (token_type(top_if) == TOKEN_IF)
+			false_nesting = 0;
+	} else {
+		false_nesting = 1;
+	}
+	token_type(top_if) = TOKEN_ELSE;
+	return 1;
+}
+
+static int handle_endif(struct stream *stream, struct token **line, struct token *token)
+{
+	struct token *top_if = stream->top_if;
+	end_group(stream);
+	if (!top_if) {
+		nesting_error(stream);
+		sparse_error(token->pos, "unmatched #endif in stream");
+		return 1;
+	}
+	if (false_nesting)
+		false_nesting--;
+	stream->top_if = top_if->next;
+	__free_token(top_if);
+	return 1;
+}
+
+static int handle_warning(struct stream *stream, struct token **line, struct token *token)
+{
+	warning(token->pos, "%s", show_token_sequence(token->next, 0));
+	return 1;
+}
+
+static int handle_error(struct stream *stream, struct token **line, struct token *token)
+{
+	sparse_error(token->pos, "%s", show_token_sequence(token->next, 0));
+	return 1;
+}
+
+static int handle_nostdinc(struct stream *stream, struct token **line, struct token *token)
+{
+	/*
+	 * Do we have any non-system includes?
+	 * Clear them out if so..
+	 */
+	*sys_includepath = NULL;
+	return 1;
+}
+
+static inline void update_inc_ptrs(const char ***where)
+{
+
+	if (*where <= dirafter_includepath) {
+		dirafter_includepath++;
+		/* If this was the entry that we prepend, don't
+		 * rise the lower entries, even if they are at
+		 * the same level. */
+		if (where == &dirafter_includepath)
+			return;
+	}
+	if (*where <= sys_includepath) {
+		sys_includepath++;
+		if (where == &sys_includepath)
+			return;
+	}
+	if (*where <= isys_includepath) {
+		isys_includepath++;
+		if (where == &isys_includepath)
+			return;
+	}
+
+	/* angle_includepath is actually never updated, since we
+	 * don't suppport -iquote rught now. May change some day. */
+	if (*where <= angle_includepath) {
+		angle_includepath++;
+		if (where == &angle_includepath)
+			return;
+	}
+}
+
+/* Add a path before 'where' and update the pointers associated with the
+ * includepath array */
+static void add_path_entry(struct token *token, const char *path,
+	const char ***where)
+{
+	const char **dst;
+	const char *next;
+
+	/* Need one free entry.. */
+	if (includepath[INCLUDEPATHS-2])
+		error_die(token->pos, "too many include path entries");
+
+	/* check that this is not a duplicate */
+	dst = includepath;
+	while (*dst) {
+		if (strcmp(*dst, path) == 0)
+			return;
+		dst++;
+	}
+	next = path;
+	dst = *where;
+
+	update_inc_ptrs(where);
+
+	/*
+	 * Move them all up starting at dst,
+	 * insert the new entry..
+	 */
+	do {
+		const char *tmp = *dst;
+		*dst = next;
+		next = tmp;
+		dst++;
+	} while (next);
+}
+
+static int handle_add_include(struct stream *stream, struct token **line, struct token *token)
+{
+	for (;;) {
+		token = token->next;
+		if (eof_token(token))
+			return 1;
+		if (token_type(token) != TOKEN_STRING) {
+			warning(token->pos, "expected path string");
+			return 1;
+		}
+		add_path_entry(token, token->string->data, &isys_includepath);
+	}
+}
+
+static int handle_add_isystem(struct stream *stream, struct token **line, struct token *token)
+{
+	for (;;) {
+		token = token->next;
+		if (eof_token(token))
+			return 1;
+		if (token_type(token) != TOKEN_STRING) {
+			sparse_error(token->pos, "expected path string");
+			return 1;
+		}
+		add_path_entry(token, token->string->data, &sys_includepath);
+	}
+}
+
+static int handle_add_system(struct stream *stream, struct token **line, struct token *token)
+{
+	for (;;) {
+		token = token->next;
+		if (eof_token(token))
+			return 1;
+		if (token_type(token) != TOKEN_STRING) {
+			sparse_error(token->pos, "expected path string");
+			return 1;
+		}
+		add_path_entry(token, token->string->data, &dirafter_includepath);
+	}
+}
+
+/* Add to end on includepath list - no pointer updates */
+static void add_dirafter_entry(struct token *token, const char *path)
+{
+	const char **dst = includepath;
+
+	/* Need one free entry.. */
+	if (includepath[INCLUDEPATHS-2])
+		error_die(token->pos, "too many include path entries");
+
+	/* Add to the end */
+	while (*dst)
+		dst++;
+	*dst = path;
+	dst++;
+	*dst = NULL;
+}
+
+static int handle_add_dirafter(struct stream *stream, struct token **line, struct token *token)
+{
+	for (;;) {
+		token = token->next;
+		if (eof_token(token))
+			return 1;
+		if (token_type(token) != TOKEN_STRING) {
+			sparse_error(token->pos, "expected path string");
+			return 1;
+		}
+		add_dirafter_entry(token, token->string->data);
+	}
+}
+
+static int handle_split_include(struct stream *stream, struct token **line, struct token *token)
+{
+	/*
+	 * -I-
+	 *  From info gcc:
+	 *  Split the include path.  Any directories specified with `-I'
+	 *  options before `-I-' are searched only for headers requested with
+	 *  `#include "FILE"'; they are not searched for `#include <FILE>'.
+	 *  If additional directories are specified with `-I' options after
+	 *  the `-I-', those directories are searched for all `#include'
+	 *  directives.
+	 *  In addition, `-I-' inhibits the use of the directory of the current
+	 *  file directory as the first search directory for `#include "FILE"'.
+	 */
+	quote_includepath = includepath+1;
+	angle_includepath = sys_includepath;
+	return 1;
+}
+
+/*
+ * We replace "#pragma xxx" with "__pragma__" in the token
+ * stream. Just as an example.
+ *
+ * We'll just #define that away for now, but the theory here
+ * is that we can use this to insert arbitrary token sequences
+ * to turn the pragmas into internal front-end sequences for
+ * when we actually start caring about them.
+ *
+ * So eventually this will turn into some kind of extended
+ * __attribute__() like thing, except called __pragma__(xxx).
+ */
+static int handle_pragma(struct stream *stream, struct token **line, struct token *token)
+{
+	struct token *next = *line;
+
+	if (match_ident(token->next, &once_ident) && eof_token(token->next->next)) {
+		stream->once = 1;
+		return 1;
+	}
+	token->ident = &pragma_ident;
+	token->pos.newline = 1;
+	token->pos.whitespace = 1;
+	token->pos.pos = 1;
+	*line = token;
+	token->next = next;
+	return 0;
+}
+
+/*
+ * We ignore #line for now.
+ */
+static int handle_line(struct stream *stream, struct token **line, struct token *token)
+{
+	return 1;
+}
+
+/*
+ * Ignore "#ident".
+ */
+static int handle_ident(struct stream *stream, struct token **line, struct token *token)
+{
+	return 1;
+}
+
+static int handle_nondirective(struct stream *stream, struct token **line, struct token *token)
+{
+	sparse_error(token->pos, "unrecognized preprocessor line '%s'", show_token_sequence(token, 0));
+	return 1;
+}
+
+
+static void init_preprocessor(void)
+{
+	int i;
+	int stream = init_stream("preprocessor", -1, includepath);
+	static struct {
+		const char *name;
+		int (*handler)(struct stream *, struct token **, struct token *);
+	} normal[] = {
+		{ "define",		handle_define },
+		{ "weak_define",	handle_weak_define },
+		{ "strong_define",	handle_strong_define },
+		{ "undef",		handle_undef },
+		{ "strong_undef",	handle_strong_undef },
+		{ "warning",		handle_warning },
+		{ "error",		handle_error },
+		{ "include",		handle_include },
+		{ "include_next",	handle_include_next },
+		{ "pragma",		handle_pragma },
+		{ "line",		handle_line },
+		{ "ident",		handle_ident },
+
+		// our internal preprocessor tokens
+		{ "nostdinc",	   handle_nostdinc },
+		{ "add_include",   handle_add_include },
+		{ "add_isystem",   handle_add_isystem },
+		{ "add_system",    handle_add_system },
+		{ "add_dirafter",  handle_add_dirafter },
+		{ "split_include", handle_split_include },
+		{ "argv_include",  handle_argv_include },
+	}, special[] = {
+		{ "ifdef",	handle_ifdef },
+		{ "ifndef",	handle_ifndef },
+		{ "else",	handle_else },
+		{ "endif",	handle_endif },
+		{ "if",		handle_if },
+		{ "elif",	handle_elif },
+	};
+
+	for (i = 0; i < ARRAY_SIZE(normal); i++) {
+		struct symbol *sym;
+		sym = create_symbol(stream, normal[i].name, SYM_PREPROCESSOR, NS_PREPROCESSOR);
+		sym->handler = normal[i].handler;
+		sym->normal = 1;
+	}
+	for (i = 0; i < ARRAY_SIZE(special); i++) {
+		struct symbol *sym;
+		sym = create_symbol(stream, special[i].name, SYM_PREPROCESSOR, NS_PREPROCESSOR);
+		sym->handler = special[i].handler;
+		sym->normal = 0;
+	}
+
+	counter_macro = 0;
+}
+
+static void handle_preprocessor_line(struct stream *stream, struct token **line, struct token *start)
+{
+	int (*handler)(struct stream *, struct token **, struct token *);
+	struct token *token = start->next;
+	int is_normal = 1;
+
+	if (eof_token(token))
+		return;
+
+	if (token_type(token) == TOKEN_IDENT) {
+		struct symbol *sym = lookup_symbol(token->ident, NS_PREPROCESSOR);
+		if (sym) {
+			handler = sym->handler;
+			is_normal = sym->normal;
+		} else {
+			handler = handle_nondirective;
+		}
+	} else if (token_type(token) == TOKEN_NUMBER) {
+		handler = handle_line;
+	} else {
+		handler = handle_nondirective;
+	}
+
+	if (is_normal) {
+		dirty_stream(stream);
+		if (false_nesting)
+			goto out;
+	}
+	if (!handler(stream, line, token))	/* all set */
+		return;
+
+out:
+	free_preprocessor_line(token);
+}
+
+static void preprocessor_line(struct stream *stream, struct token **line)
+{
+	struct token *start = *line, *next;
+	struct token **tp = &start->next;
+
+	for (;;) {
+		next = *tp;
+		if (next->pos.newline)
+			break;
+		tp = &next->next;
+	}
+	*line = next;
+	*tp = &eof_token_entry;
+	handle_preprocessor_line(stream, line, start);
+}
+
+static void do_preprocess(struct token **list)
+{
+	struct token *next;
+
+	while (!eof_token(next = scan_next(list))) {
+		struct stream *stream = input_streams + next->pos.stream;
+
+		if (next->pos.newline && match_op(next, '#')) {
+			if (!next->pos.noexpand) {
+				preprocessor_line(stream, list);
+				__free_token(next);	/* Free the '#' token */
+				continue;
+			}
+		}
+
+		switch (token_type(next)) {
+		case TOKEN_STREAMEND:
+			if (stream->top_if) {
+				nesting_error(stream);
+				sparse_error(stream->top_if->pos, "unterminated preprocessor conditional");
+				stream->top_if = NULL;
+				false_nesting = 0;
+			}
+			if (!stream->dirty)
+				stream->constant = CONSTANT_FILE_YES;
+			*list = next->next;
+			continue;
+		case TOKEN_STREAMBEGIN:
+			*list = next->next;
+			continue;
+
+		default:
+			dirty_stream(stream);
+			if (false_nesting) {
+				*list = next->next;
+				__free_token(next);
+				continue;
+			}
+
+			if (token_type(next) != TOKEN_IDENT ||
+			    expand_one_symbol(list))
+				list = &next->next;
+		}
+	}
+}
+
+void init_include_path(void)
+{
+	FILE *fp;
+	char path[256];
+	char arch[32];
+	char os[32];
+
+	fp = popen("/bin/uname -m", "r");
+	if (!fp)
+		return;
+	if (!fgets(arch, sizeof(arch) - 1, fp))
+		return;
+	pclose(fp);
+	if (arch[strlen(arch) - 1] == '\n')
+		arch[strlen(arch) - 1] = '\0';
+
+	fp = popen("/bin/uname -o", "r");
+	if (!fp)
+		return;
+	fgets(os, sizeof(os) - 1, fp);
+	pclose(fp);
+
+	if (strcmp(os, "GNU/Linux\n") != 0)
+		return;
+	strcpy(os, "linux-gnu");
+
+	snprintf(path, sizeof(path), "/usr/include/%s-%s/", arch, os);
+	add_pre_buffer("#add_system \"%s/\"\n", path);
+}
+
+struct token * preprocess(struct token *token)
+{
+	preprocessing = 1;
+	init_preprocessor();
+	do_preprocess(&token);
+
+	// Drop all expressions from preprocessing, they're not used any more.
+	// This is not true when we have multiple files, though ;/
+	// clear_expression_alloc();
+	preprocessing = 0;
+
+	return token;
+}
+
+static void dump_macro(struct symbol *sym)
+{
+	int nargs = sym->arglist ? sym->arglist->count.normal : 0;
+	struct token *args[nargs];
+	struct token *token;
+
+	printf("#define %s", show_ident(sym->ident));
+	token = sym->arglist;
+	if (token) {
+		const char *sep = "";
+		int narg = 0;
+		putchar('(');
+		for (; !eof_token(token); token = token->next) {
+			if (token_type(token) == TOKEN_ARG_COUNT)
+				continue;
+			printf("%s%s", sep, show_token(token));
+			args[narg++] = token;
+			sep = ", ";
+		}
+		putchar(')');
+	}
+	putchar(' ');
+
+	token = sym->expansion;
+	while (!eof_token(token)) {
+		struct token *next = token->next;
+		switch (token_type(token)) {
+		case TOKEN_UNTAINT:
+			break;
+		case TOKEN_MACRO_ARGUMENT:
+			token = args[token->argnum];
+			/* fall-through */
+		default:
+			printf("%s", show_token(token));
+			if (next->pos.whitespace)
+				putchar(' ');
+		}
+		token = next;
+	}
+	putchar('\n');
+}
+
+void dump_macro_definitions(void)
+{
+	struct ident *name;
+
+	FOR_EACH_PTR(macros, name) {
+		struct symbol *sym = lookup_macro(name);
+		if (sym)
+			dump_macro(sym);
+	} END_FOR_EACH_PTR(name);
+}
diff --git a/usr/src/tools/smatch/src/ptrlist.c b/usr/src/tools/smatch/src/ptrlist.c
new file mode 100644
index 0000000000..635b6bbe59
--- /dev/null
+++ b/usr/src/tools/smatch/src/ptrlist.c
@@ -0,0 +1,255 @@
+/*
+ * ptrlist.c
+ *
+ * Pointer list manipulation
+ *
+ * (C) Copyright Linus Torvalds 2003-2005
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "ptrlist.h"
+#include "allocate.h"
+#include "compat.h"
+
+__DECLARE_ALLOCATOR(struct ptr_list, ptrlist);
+__ALLOCATOR(struct ptr_list, "ptr list", ptrlist);
+__ALLOCATOR(struct ptr_list, "rl ptr list", rl_ptrlist);
+
+int ptr_list_size(struct ptr_list *head)
+{
+	int nr = 0;
+
+	if (head) {
+		struct ptr_list *list = head;
+		do {
+			nr += list->nr - list->rm;
+		} while ((list = list->next) != head);
+	}
+	return nr;
+}
+
+/*
+ * Linearize the entries of a list up to a total of 'max',
+ * and return the nr of entries linearized.
+ *
+ * The array to linearize into (second argument) should really
+ * be "void *x[]", but we want to let people fill in any kind
+ * of pointer array, so let's just call it "void **".
+ */
+int linearize_ptr_list(struct ptr_list *head, void **arr, int max)
+{
+	int nr = 0;
+	if (head && max > 0) {
+		struct ptr_list *list = head;
+
+		do {
+			int i = list->nr;
+			if (i > max) 
+				i = max;
+			memcpy(arr, list->list, i*sizeof(void *));
+			arr += i;
+			nr += i;
+			max -= i;
+			if (!max)
+				break;
+		} while ((list = list->next) != head);
+	}
+	return nr;
+}
+
+/*
+ * When we've walked the list and deleted entries,
+ * we may need to re-pack it so that we don't have
+ * any empty blocks left (empty blocks upset the
+ * walking code
+ */
+void pack_ptr_list(struct ptr_list **listp)
+{
+	struct ptr_list *head = *listp;
+
+	if (head) {
+		struct ptr_list *entry = head;
+		do {
+			struct ptr_list *next;
+restart:
+			next = entry->next;
+			if (!entry->nr) {
+				struct ptr_list *prev;
+				if (next == entry) {
+					__free_ptrlist(entry);
+					*listp = NULL;
+					return;
+				}
+				prev = entry->prev;
+				prev->next = next;
+				next->prev = prev;
+				__free_ptrlist(entry);
+				if (entry == head) {
+					*listp = next;
+					head = next;
+					entry = next;
+					goto restart;
+				}
+			}
+			entry = next;
+		} while (entry != head);
+	}
+}		
+
+void split_ptr_list_head(struct ptr_list *head)
+{
+	int old = head->nr, nr = old / 2;
+	struct ptr_list *newlist = __alloc_ptrlist(0);
+	struct ptr_list *next = head->next;
+
+	old -= nr;
+	head->nr = old;
+	newlist->next = next;
+	next->prev = newlist;
+	newlist->prev = head;
+	head->next = newlist;
+	newlist->nr = nr;
+	memcpy(newlist->list, head->list + old, nr * sizeof(void *));
+	memset(head->list + old, 0xf0, nr * sizeof(void *));
+}
+
+int rl_ptrlist_hack;
+void **__add_ptr_list(struct ptr_list **listp, void *ptr, unsigned long tag)
+{
+	struct ptr_list *list = *listp;
+	struct ptr_list *last = NULL; /* gcc complains needlessly */
+	void **ret;
+	int nr;
+
+	/* The low two bits are reserved for tags */
+	assert((3 & (unsigned long)ptr) == 0);
+	assert((~3 & tag) == 0);
+	ptr = (void *)(tag | (unsigned long)ptr);
+
+	if (!list || (nr = (last = list->prev)->nr) >= LIST_NODE_NR) {
+		struct ptr_list *newlist;
+
+		if (rl_ptrlist_hack)
+			newlist = __alloc_rl_ptrlist(0);
+		else
+			newlist = __alloc_ptrlist(0);
+		if (!list) {
+			newlist->next = newlist;
+			newlist->prev = newlist;
+			*listp = newlist;
+		} else {
+			newlist->prev = last;
+			newlist->next = list;
+			list->prev = newlist;
+			last->next = newlist;
+		}
+		last = newlist;
+		nr = 0;
+	}
+	ret = last->list + nr;
+	*ret = ptr;
+	nr++;
+	last->nr = nr;
+	return ret;
+}
+
+int delete_ptr_list_entry(struct ptr_list **list, void *entry, int count)
+{
+	void *ptr;
+
+	FOR_EACH_PTR(*list, ptr) {
+		if (ptr == entry) {
+			DELETE_CURRENT_PTR(ptr);
+			if (!--count)
+				goto out;
+		}
+	} END_FOR_EACH_PTR(ptr);
+	assert(count <= 0);
+out:
+	pack_ptr_list(list);
+	return count;
+}
+
+int replace_ptr_list_entry(struct ptr_list **list, void *old_ptr, void *new_ptr, int count)
+{
+	void *ptr;
+
+	FOR_EACH_PTR(*list, ptr) {
+		if (ptr==old_ptr) {
+			REPLACE_CURRENT_PTR(ptr, new_ptr);
+			if (!--count)
+				goto out;
+		}
+	}END_FOR_EACH_PTR(ptr);
+	assert(count <= 0);
+out:
+	return count;
+}
+
+/* This removes the last entry, but doesn't pack the ptr list */
+void * undo_ptr_list_last(struct ptr_list **head)
+{
+	struct ptr_list *last, *first = *head;
+
+	if (!first)
+		return NULL;
+	last = first;
+	do {
+		last = last->prev;
+		if (last->nr) {
+			void *ptr;
+			int nr = --last->nr;
+			ptr = last->list[nr];
+			last->list[nr] = (void *)0xf1f1f1f1;
+			return ptr;
+		}
+	} while (last != first);
+	return NULL;
+}
+
+void * delete_ptr_list_last(struct ptr_list **head)
+{
+	void *ptr = NULL;
+	struct ptr_list *last, *first = *head;
+
+	if (!first)
+		return NULL;
+	last = first->prev;
+	if (last->nr)
+		ptr = last->list[--last->nr];
+	if (last->nr <=0) {
+		first->prev = last->prev;
+		last->prev->next = first;
+		if (last == first)
+			*head = NULL;
+		__free_ptrlist(last);
+	}
+	return ptr;
+}
+
+void concat_ptr_list(struct ptr_list *a, struct ptr_list **b)
+{
+	void *entry;
+	FOR_EACH_PTR(a, entry) {
+		add_ptr_list(b, entry);
+	} END_FOR_EACH_PTR(entry);
+}
+
+void __free_ptr_list(struct ptr_list **listp)
+{
+	struct ptr_list *tmp, *list = *listp;
+
+	if (!list)
+		return;
+
+	list->prev->next = NULL;
+	while (list) {
+		tmp = list;
+		list = list->next;
+		__free_ptrlist(tmp);
+	}
+
+	*listp = NULL;
+}
diff --git a/usr/src/tools/smatch/src/ptrlist.h b/usr/src/tools/smatch/src/ptrlist.h
new file mode 100644
index 0000000000..78625c8d87
--- /dev/null
+++ b/usr/src/tools/smatch/src/ptrlist.h
@@ -0,0 +1,320 @@
+#ifndef PTR_LIST_H
+#define PTR_LIST_H
+
+#include <stdlib.h>
+
+/*
+ * Generic pointer list manipulation code. 
+ *
+ * (C) Copyright Linus Torvalds 2003-2005
+ */
+
+/* Silly type-safety check ;) */
+#define DECLARE_PTR_LIST(listname,type)	struct listname { type *list[1]; }
+#define CHECK_TYPE(head,ptr)		(void)(&(ptr) == &(head)->list[0])
+#define TYPEOF(head)			__typeof__(&(head)->list[0])
+#define VRFY_PTR_LIST(head)		(void)(sizeof((head)->list[0]))
+
+/*
+ * The "unnecessary" statement expression is there to shut up a totally 
+ * bogus gcc warning about unused expressions, brought on by the fact
+ * that we cast the result to the proper type.
+ */
+#define MKTYPE(head,expr)		({ (TYPEOF(head))(expr); })
+
+#define LIST_NODE_NR (29)
+
+struct ptr_list {
+	int nr:8;
+	int rm:8;
+	struct ptr_list *prev;
+	struct ptr_list *next;
+	void *list[LIST_NODE_NR];
+};
+
+#define ptr_list_empty(x) ((x) == NULL)
+
+void * undo_ptr_list_last(struct ptr_list **head);
+void * delete_ptr_list_last(struct ptr_list **head);
+int delete_ptr_list_entry(struct ptr_list **, void *, int);
+int replace_ptr_list_entry(struct ptr_list **, void *old, void *new, int);
+extern void sort_list(struct ptr_list **, int (*)(const void *, const void *));
+
+extern void **__add_ptr_list(struct ptr_list **, void *, unsigned long);
+extern void concat_ptr_list(struct ptr_list *a, struct ptr_list **b);
+extern void __free_ptr_list(struct ptr_list **);
+extern int ptr_list_size(struct ptr_list *);
+extern int linearize_ptr_list(struct ptr_list *, void **, int);
+
+/*
+ * Hey, who said that you can't do overloading in C?
+ *
+ * You just have to be creative, and use some gcc
+ * extensions..
+ */
+#define add_ptr_list_tag(list,entry,tag) \
+	MKTYPE(*(list), (CHECK_TYPE(*(list),(entry)),__add_ptr_list((struct ptr_list **)(list), (entry), (tag))))
+#define add_ptr_list_notag(list,entry)										\
+	MKTYPE(*(list), (CHECK_TYPE(*(list),(entry)),__add_ptr_list((struct ptr_list **)(list),			\
+								    (void *)((unsigned long)(entry) & ~3UL), 	\
+								    (unsigned long)(entry) & 3)))
+#define add_ptr_list(list,entry) \
+	add_ptr_list_tag(list,entry,0)
+#define free_ptr_list(list) \
+	do { VRFY_PTR_LIST(*(list)); __free_ptr_list((struct ptr_list **)(list)); } while (0)
+
+#define PTR_ENTRY_NOTAG(h,i)	((h)->list[i])
+#define PTR_ENTRY(h,i)	(void *)(~3UL & (unsigned long)PTR_ENTRY_NOTAG(h,i))
+
+static inline void *first_ptr_list(struct ptr_list *list)
+{
+	struct ptr_list *head = list;
+
+	if (!list)
+		return NULL;
+
+	while (list->nr == 0) {
+		list = list->next;
+		if (list == head)
+			return NULL;
+	}
+	return PTR_ENTRY(list, 0);
+}
+
+static inline void *last_ptr_list(struct ptr_list *list)
+{
+	struct ptr_list *head = list;
+
+	if (!list)
+		return NULL;
+	list = list->prev;
+	while (list->nr == 0) {
+		if (list == head)
+			return NULL;
+		list = list->prev;
+	}
+	return PTR_ENTRY(list, list->nr-1);
+}
+
+#define PTR_DEREF(__head, idx, PTR_ENTRY) ({						\
+	struct ptr_list *__list = __head;						\
+	while (__list && __list->nr == 0) {						\
+		__list = __list->next;							\
+		if (__list == __head)							\
+			__list = NULL;							\
+	}										\
+	__list ? PTR_ENTRY(__list, idx) : NULL;						\
+})
+
+#define DO_PREPARE(head, ptr, __head, __list, __nr, PTR_ENTRY)				\
+	do {										\
+		struct ptr_list *__head = (struct ptr_list *) (head);			\
+		struct ptr_list *__list = __head;					\
+		int __nr = 0;								\
+		CHECK_TYPE(head,ptr);							\
+		ptr = PTR_DEREF(__head, 0, PTR_ENTRY);					\
+
+#define DO_NEXT(ptr, __head, __list, __nr, PTR_ENTRY)					\
+		if (ptr) {								\
+			if (++__nr < __list->nr) {					\
+				ptr = PTR_ENTRY(__list,__nr);				\
+			} else {							\
+				__list = __list->next;					\
+				ptr = NULL;						\
+				while (__list->nr == 0 && __list != __head)		\
+					__list = __list->next;				\
+				if (__list != __head) {					\
+					__nr = 0;					\
+					ptr = PTR_ENTRY(__list,0);			\
+				}							\
+			}								\
+		}
+
+#define DO_RESET(ptr, __head, __list, __nr, PTR_ENTRY)					\
+	do {										\
+		__nr = 0;								\
+		__list = __head;							\
+		if (__head) ptr = PTR_DEREF(__head, 0, PTR_ENTRY);			\
+	} while (0)
+
+#define DO_FINISH(ptr, __head, __list, __nr)						\
+		(void)(__nr); /* Sanity-check nesting */				\
+	} while (0)
+
+#define PREPARE_PTR_LIST(head, ptr) \
+	DO_PREPARE(head, ptr, __head##ptr, __list##ptr, __nr##ptr, PTR_ENTRY)
+
+#define NEXT_PTR_LIST(ptr) \
+	DO_NEXT(ptr, __head##ptr, __list##ptr, __nr##ptr, PTR_ENTRY)
+
+#define RESET_PTR_LIST(ptr) \
+	DO_RESET(ptr, __head##ptr, __list##ptr, __nr##ptr, PTR_ENTRY)
+
+#define FINISH_PTR_LIST(ptr) \
+	DO_FINISH(ptr, __head##ptr, __list##ptr, __nr##ptr)
+
+#define DO_FOR_EACH(head, ptr, __head, __list, __nr, PTR_ENTRY) do {			\
+	struct ptr_list *__head = (struct ptr_list *) (head);				\
+	struct ptr_list *__list = __head;						\
+	CHECK_TYPE(head,ptr);								\
+	if (__head) {									\
+		do { int __nr;								\
+			for (__nr = 0; __nr < __list->nr; __nr++) {			\
+				do {							\
+					ptr = PTR_ENTRY(__list,__nr);			\
+					if (__list->rm && !ptr)				\
+						continue;				\
+					do {
+
+#define DO_END_FOR_EACH(ptr, __head, __list, __nr)					\
+					} while (0);					\
+				} while (0);						\
+			}								\
+		} while ((__list = __list->next) != __head);				\
+	}										\
+} while (0)
+
+#define DO_FOR_EACH_REVERSE(head, ptr, __head, __list, __nr, PTR_ENTRY) do {		\
+	struct ptr_list *__head = (struct ptr_list *) (head);				\
+	struct ptr_list *__list = __head;						\
+	CHECK_TYPE(head,ptr);								\
+	if (__head) {									\
+		do { int __nr;								\
+			__list = __list->prev;						\
+			__nr = __list->nr;						\
+			while (--__nr >= 0) {						\
+				do {							\
+					ptr = PTR_ENTRY(__list,__nr);			\
+					if (__list->rm && !ptr)				\
+						continue;				\
+					do {
+
+
+#define DO_END_FOR_EACH_REVERSE(ptr, __head, __list, __nr)				\
+					} while (0);					\
+				} while (0);						\
+			}								\
+		} while (__list != __head);						\
+	}										\
+} while (0)
+
+#define DO_REVERSE(ptr, __head, __list, __nr, new, __newhead,				\
+		   __newlist, __newnr, PTR_ENTRY) do { 					\
+	struct ptr_list *__newhead = __head;						\
+	struct ptr_list *__newlist = __list;						\
+	int __newnr = __nr;								\
+	new = ptr;									\
+	goto __inside##new;								\
+	if (1) {									\
+		do {									\
+			__newlist = __newlist->prev;					\
+			__newnr = __newlist->nr;					\
+	__inside##new:									\
+			while (--__newnr >= 0) {					\
+				do {							\
+					new = PTR_ENTRY(__newlist,__newnr);		\
+					do {
+
+#define RECURSE_PTR_REVERSE(ptr, new)							\
+	DO_REVERSE(ptr, __head##ptr, __list##ptr, __nr##ptr,				\
+		   new, __head##new, __list##new, __nr##new, PTR_ENTRY)
+
+#define DO_THIS_ADDRESS(ptr, __head, __list, __nr)					\
+	((__typeof__(&(ptr))) (__list->list + __nr))
+
+#define FOR_EACH_PTR(head, ptr) \
+	DO_FOR_EACH(head, ptr, __head##ptr, __list##ptr, __nr##ptr, PTR_ENTRY)
+
+#define END_FOR_EACH_PTR(ptr) \
+	DO_END_FOR_EACH(ptr, __head##ptr, __list##ptr, __nr##ptr)
+
+#define FOR_EACH_PTR_NOTAG(head, ptr) \
+	DO_FOR_EACH(head, ptr, __head##ptr, __list##ptr, __nr##ptr, PTR_ENTRY_NOTAG)
+
+#define END_FOR_EACH_PTR_NOTAG(ptr) END_FOR_EACH_PTR(ptr)
+
+#define FOR_EACH_PTR_REVERSE(head, ptr) \
+	DO_FOR_EACH_REVERSE(head, ptr, __head##ptr, __list##ptr, __nr##ptr, PTR_ENTRY)
+
+#define END_FOR_EACH_PTR_REVERSE(ptr) \
+	DO_END_FOR_EACH_REVERSE(ptr, __head##ptr, __list##ptr, __nr##ptr)
+
+#define FOR_EACH_PTR_REVERSE_NOTAG(head, ptr) \
+	DO_FOR_EACH_REVERSE(head, ptr, __head##ptr, __list##ptr, __nr##ptr, PTR_ENTRY_NOTAG)
+
+#define END_FOR_EACH_PTR_REVERSE_NOTAG(ptr) END_FOR_EACH_PTR_REVERSE(ptr)
+
+#define THIS_ADDRESS(ptr) \
+	DO_THIS_ADDRESS(ptr, __head##ptr, __list##ptr, __nr##ptr)
+
+extern void split_ptr_list_head(struct ptr_list *);
+
+#define DO_SPLIT(ptr, __head, __list, __nr) do {					\
+	split_ptr_list_head(__list);							\
+	if (__nr >= __list->nr) {							\
+		__nr -= __list->nr;							\
+		__list = __list->next;							\
+	};										\
+} while (0)
+
+#define DO_INSERT_CURRENT(new, ptr, __head, __list, __nr) do {				\
+	void **__this, **__last;							\
+	if (__list->nr == LIST_NODE_NR)							\
+		DO_SPLIT(ptr, __head, __list, __nr);					\
+	__this = __list->list + __nr;							\
+	__last = __list->list + __list->nr - 1;						\
+	while (__last >= __this) {							\
+		__last[1] = __last[0];							\
+		__last--;								\
+	}										\
+	*__this = (new);								\
+	__list->nr++;									\
+} while (0)
+
+#define INSERT_CURRENT(new, ptr) \
+	DO_INSERT_CURRENT(new, ptr, __head##ptr, __list##ptr, __nr##ptr)
+
+#define DO_DELETE_CURRENT(ptr, __head, __list, __nr) do {				\
+	void **__this = __list->list + __nr;						\
+	void **__last = __list->list + __list->nr - 1;					\
+	while (__this < __last) {							\
+		__this[0] = __this[1];							\
+		__this++;								\
+	}										\
+	*__this = (void *)0xf0f0f0f0;							\
+	__list->nr--; __nr--;								\
+} while (0)
+
+#define DELETE_CURRENT_PTR(ptr) \
+	DO_DELETE_CURRENT(ptr, __head##ptr, __list##ptr, __nr##ptr)
+
+#define REPLACE_CURRENT_PTR(ptr, new_ptr)						\
+	do { *THIS_ADDRESS(ptr) = (new_ptr); } while (0)
+
+#define DO_MARK_CURRENT_DELETED(ptr, __list) do {	\
+		REPLACE_CURRENT_PTR(ptr, NULL);		\
+		__list->rm++;				\
+	} while (0)
+
+#define MARK_CURRENT_DELETED(ptr) \
+	DO_MARK_CURRENT_DELETED(ptr, __list##ptr)
+
+extern void pack_ptr_list(struct ptr_list **);
+
+#define PACK_PTR_LIST(x) pack_ptr_list((struct ptr_list **)(x))
+
+static inline void update_tag(void *p, unsigned long tag)
+{
+	unsigned long *ptr = p;
+	*ptr = tag | (~3UL & *ptr);
+}
+
+static inline void *tag_ptr(void *ptr, unsigned long tag)
+{
+	return (void *)(tag | (unsigned long)ptr);
+}
+
+#define CURRENT_TAG(ptr) (3 & (unsigned long)*THIS_ADDRESS(ptr))
+#define TAG_CURRENT(ptr,val)	update_tag(THIS_ADDRESS(ptr),val)
+
+#endif /* PTR_LIST_H */
diff --git a/usr/src/tools/smatch/src/scope.c b/usr/src/tools/smatch/src/scope.c
new file mode 100644
index 0000000000..3d0bb7f78b
--- /dev/null
+++ b/usr/src/tools/smatch/src/scope.c
@@ -0,0 +1,149 @@
+/*
+ * Symbol scoping.
+ *
+ * This is pretty trivial.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "symbol.h"
+#include "scope.h"
+
+static struct scope builtin_scope = { .next = &builtin_scope };
+
+struct scope	*block_scope = &builtin_scope,		// regular automatic variables etc
+		*function_scope = &builtin_scope,	// labels, arguments etc
+		*file_scope = &builtin_scope,		// static
+		*global_scope = &builtin_scope;		// externally visible
+
+void bind_scope(struct symbol *sym, struct scope *scope)
+{
+	sym->scope = scope;
+	add_symbol(&scope->symbols, sym);
+}
+
+void rebind_scope(struct symbol *sym, struct scope *new)
+{
+	struct scope *old = sym->scope;
+
+	if (old == new)
+		return;
+
+	if (old)
+		delete_ptr_list_entry((struct ptr_list**) &old->symbols, sym, 1);
+
+	bind_scope(sym, new);
+}
+
+static void start_scope(struct scope **s, struct position pos)
+{
+	struct scope *scope = __alloc_scope(0);
+	memset(scope, 0, sizeof(*scope));
+	scope->token = __alloc_token(0);
+	scope->token->pos = pos;
+	scope->next = *s;
+	*s = scope;
+}
+
+void start_file_scope(void)
+{
+	struct scope *scope = __alloc_scope(0);
+
+	memset(scope, 0, sizeof(*scope));
+	scope->next = &builtin_scope;
+	file_scope = scope;
+
+	/* top-level stuff defaults to file scope, "extern" etc will choose global scope */
+	function_scope = scope;
+	block_scope = scope;
+}
+
+void start_symbol_scope(struct position pos)
+{
+	start_scope(&block_scope, pos);
+}
+
+void start_function_scope(struct position pos)
+{
+	start_scope(&function_scope, pos);
+	start_scope(&block_scope, pos);
+}
+
+static void remove_symbol_scope(struct symbol *sym)
+{
+	struct symbol **ptr = &sym->ident->symbols;
+
+	while (*ptr != sym)
+		ptr = &(*ptr)->next_id;
+	*ptr = sym->next_id;
+}
+
+static void end_scope(struct scope **s)
+{
+	struct scope *scope = *s;
+	struct symbol_list *symbols = scope->symbols;
+	struct symbol *sym;
+
+	*s = scope->next;
+	scope->symbols = NULL;
+	FOR_EACH_PTR(symbols, sym) {
+		remove_symbol_scope(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+void end_file_scope(void)
+{
+	end_scope(&file_scope);
+}
+
+void new_file_scope(void)
+{
+	if (file_scope != &builtin_scope)
+		end_file_scope();
+	start_file_scope();
+}
+
+void end_symbol_scope(void)
+{
+	end_scope(&block_scope);
+}
+
+void end_function_scope(void)
+{
+	end_scope(&block_scope);
+	end_scope(&function_scope);
+}
+
+int is_outer_scope(struct scope *scope)
+{
+	if (scope == block_scope)
+		return 0;
+	if (scope == &builtin_scope && block_scope->next == &builtin_scope)
+		return 0;
+	return 1;
+}
+
diff --git a/usr/src/tools/smatch/src/scope.h b/usr/src/tools/smatch/src/scope.h
new file mode 100644
index 0000000000..10118e5655
--- /dev/null
+++ b/usr/src/tools/smatch/src/scope.h
@@ -0,0 +1,62 @@
+#ifndef SCOPE_H
+#define SCOPE_H
+/*
+ * Symbol scoping is pretty simple.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+struct symbol;
+struct position;
+
+struct scope {
+	struct token *token;		/* Scope start information */
+	struct symbol_list *symbols;	/* List of symbols in this scope */
+	struct scope *next;
+};
+
+extern struct scope
+		*block_scope,
+		*function_scope,
+		*file_scope,
+		*global_scope;
+
+static inline int toplevel(struct scope *scope)
+{
+	return scope == file_scope || scope == global_scope;
+}
+
+extern void start_file_scope(void);
+extern void end_file_scope(void);
+extern void new_file_scope(void);
+
+extern void start_symbol_scope(struct position pos);
+extern void end_symbol_scope(void);
+
+extern void start_function_scope(struct position pos);
+extern void end_function_scope(void);
+
+extern void bind_scope(struct symbol *, struct scope *);
+extern void rebind_scope(struct symbol *, struct scope *);
+
+extern int is_outer_scope(struct scope *);
+#endif
diff --git a/usr/src/tools/smatch/src/show-parse.c b/usr/src/tools/smatch/src/show-parse.c
new file mode 100644
index 0000000000..d365d737f1
--- /dev/null
+++ b/usr/src/tools/smatch/src/show-parse.c
@@ -0,0 +1,1174 @@
+/*
+ * sparse/show-parse.c
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Print out results of parsing for debugging and testing.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "scope.h"
+#include "expression.h"
+#include "target.h"
+
+static int show_symbol_expr(struct symbol *sym);
+static int show_string_expr(struct expression *expr);
+
+static void do_debug_symbol(struct symbol *sym, int indent)
+{
+	static const char indent_string[] = "                                  ";
+	static const char *typestr[] = {
+		[SYM_UNINITIALIZED] = "none",
+		[SYM_PREPROCESSOR] = "cpp.",
+		[SYM_BASETYPE] = "base",
+		[SYM_NODE] = "node",
+		[SYM_PTR] = "ptr.",
+		[SYM_FN] = "fn..",
+		[SYM_ARRAY] = "arry",
+		[SYM_STRUCT] = "strt",
+		[SYM_UNION] = "unin",
+		[SYM_ENUM] = "enum",
+		[SYM_TYPEDEF] = "tdef",
+		[SYM_TYPEOF] = "tpof",
+		[SYM_MEMBER] = "memb",
+		[SYM_BITFIELD] = "bitf",
+		[SYM_LABEL] = "labl",
+		[SYM_RESTRICT] = "rstr",
+		[SYM_FOULED] = "foul",
+		[SYM_BAD] = "bad.",
+	};
+	struct context *context;
+	int i;
+
+	if (!sym)
+		return;
+	fprintf(stderr, "%.*s%s%3d:%lu %s %s (as: %d) %p (%s:%d:%d) %s\n",
+		indent, indent_string, typestr[sym->type],
+		sym->bit_size, sym->ctype.alignment,
+		modifier_string(sym->ctype.modifiers), show_ident(sym->ident), sym->ctype.as,
+		sym, stream_name(sym->pos.stream), sym->pos.line, sym->pos.pos,
+		builtin_typename(sym) ?: "");
+	i = 0;
+	FOR_EACH_PTR(sym->ctype.contexts, context) {
+		/* FIXME: should print context expression */
+		fprintf(stderr, "< context%d: in=%d, out=%d\n",
+			i, context->in, context->out);
+		fprintf(stderr, "  end context%d >\n", i);
+		i++;
+	} END_FOR_EACH_PTR(context);
+	if (sym->type == SYM_FN) {
+		struct symbol *arg;
+		i = 0;
+		FOR_EACH_PTR(sym->arguments, arg) {
+			fprintf(stderr, "< arg%d:\n", i);
+			do_debug_symbol(arg, 0);
+			fprintf(stderr, "  end arg%d >\n", i);
+			i++;
+		} END_FOR_EACH_PTR(arg);
+	}
+	do_debug_symbol(sym->ctype.base_type, indent+2);
+}
+
+void debug_symbol(struct symbol *sym)
+{
+	do_debug_symbol(sym, 0);
+}
+
+/*
+ * Symbol type printout. The type system is by far the most
+ * complicated part of C - everything else is trivial.
+ */
+const char *modifier_string(unsigned long mod)
+{
+	static char buffer[100];
+	int len = 0;
+	int i;
+	struct mod_name {
+		unsigned long mod;
+		const char *name;
+	} *m;
+
+	static struct mod_name mod_names[] = {
+		{MOD_AUTO,		"auto"},
+		{MOD_REGISTER,		"register"},
+		{MOD_STATIC,		"static"},
+		{MOD_EXTERN,		"extern"},
+		{MOD_CONST,		"const"},
+		{MOD_VOLATILE,		"volatile"},
+		{MOD_SIGNED,		"[signed]"},
+		{MOD_UNSIGNED,		"[unsigned]"},
+		{MOD_CHAR,		"[char]"},
+		{MOD_SHORT,		"[short]"},
+		{MOD_LONG,		"[long]"},
+		{MOD_LONGLONG,		"[long long]"},
+		{MOD_LONGLONGLONG,	"[long long long]"},
+		{MOD_TYPEDEF,		"[typedef]"},
+		{MOD_TLS,		"[tls]"},
+		{MOD_INLINE,		"inline"},
+		{MOD_ADDRESSABLE,	"[addressable]"},
+		{MOD_NOCAST,		"[nocast]"},
+		{MOD_NODEREF,		"[noderef]"},
+		{MOD_ACCESSED,		"[accessed]"},
+		{MOD_TOPLEVEL,		"[toplevel]"},
+		{MOD_ASSIGNED,		"[assigned]"},
+		{MOD_TYPE,		"[type]"},
+		{MOD_SAFE,		"[safe]"},
+		{MOD_USERTYPE,		"[usertype]"},
+		{MOD_NORETURN,		"[noreturn]"},
+		{MOD_EXPLICITLY_SIGNED,	"[explicitly-signed]"},
+		{MOD_BITWISE,		"[bitwise]"},
+		{MOD_PURE,		"[pure]"},
+	};
+
+	for (i = 0; i < ARRAY_SIZE(mod_names); i++) {
+		m = mod_names + i;
+		if (mod & m->mod) {
+			char c;
+			const char *name = m->name;
+			while ((c = *name++) != '\0' && len + 2 < sizeof buffer)
+				buffer[len++] = c;
+			buffer[len++] = ' ';
+		}
+	}
+	buffer[len] = 0;
+	return buffer;
+}
+
+static void show_struct_member(struct symbol *sym)
+{
+	printf("\t%s:%d:%ld at offset %ld.%d", show_ident(sym->ident), sym->bit_size, sym->ctype.alignment, sym->offset, sym->bit_offset);
+	printf("\n");
+}
+
+void show_symbol_list(struct symbol_list *list, const char *sep)
+{
+	struct symbol *sym;
+	const char *prepend = "";
+
+	FOR_EACH_PTR(list, sym) {
+		puts(prepend);
+		prepend = ", ";
+		show_symbol(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+struct type_name {
+	char *start;
+	char *end;
+};
+
+static void FORMAT_ATTR(2) prepend(struct type_name *name, const char *fmt, ...)
+{
+	static char buffer[512];
+	int n;
+
+	va_list args;
+	va_start(args, fmt);
+	n = vsprintf(buffer, fmt, args);
+	va_end(args);
+
+	name->start -= n;
+	memcpy(name->start, buffer, n);
+}
+
+static void FORMAT_ATTR(2) append(struct type_name *name, const char *fmt, ...)
+{
+	static char buffer[512];
+	int n;
+
+	va_list args;
+	va_start(args, fmt);
+	n = vsprintf(buffer, fmt, args);
+	va_end(args);
+
+	memcpy(name->end, buffer, n);
+	name->end += n;
+}
+
+static struct ctype_name {
+	struct symbol *sym;
+	const char *name;
+} typenames[] = {
+	{ & char_ctype,  "char" },
+	{ &schar_ctype,  "signed char" },
+	{ &uchar_ctype,  "unsigned char" },
+	{ & short_ctype, "short" },
+	{ &sshort_ctype, "signed short" },
+	{ &ushort_ctype, "unsigned short" },
+	{ & int_ctype,   "int" },
+	{ &sint_ctype,   "signed int" },
+	{ &uint_ctype,   "unsigned int" },
+	{ &slong_ctype,  "signed long" },
+	{ & long_ctype,  "long" },
+	{ &ulong_ctype,  "unsigned long" },
+	{ & llong_ctype, "long long" },
+	{ &sllong_ctype, "signed long long" },
+	{ &ullong_ctype, "unsigned long long" },
+	{ & lllong_ctype, "long long long" },
+	{ &slllong_ctype, "signed long long long" },
+	{ &ulllong_ctype, "unsigned long long long" },
+
+	{ &void_ctype,   "void" },
+	{ &bool_ctype,   "bool" },
+	{ &string_ctype, "string" },
+
+	{ &float_ctype,  "float" },
+	{ &double_ctype, "double" },
+	{ &ldouble_ctype,"long double" },
+	{ &incomplete_ctype, "incomplete type" },
+	{ &int_type, "abstract int" },
+	{ &fp_type, "abstract fp" },
+	{ &label_ctype, "label type" },
+	{ &bad_ctype, "bad type" },
+};
+
+const char *builtin_typename(struct symbol *sym)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(typenames); i++)
+		if (typenames[i].sym == sym)
+			return typenames[i].name;
+	return NULL;
+}
+
+const char *builtin_ctypename(struct ctype *ctype)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(typenames); i++)
+		if (&typenames[i].sym->ctype == ctype)
+			return typenames[i].name;
+	return NULL;
+}
+
+static void do_show_type(struct symbol *sym, struct type_name *name)
+{
+	const char *typename;
+	unsigned long mod = 0;
+	int as = 0;
+	int was_ptr = 0;
+	int restr = 0;
+	int fouled = 0;
+
+deeper:
+	if (!sym || (sym->type != SYM_NODE && sym->type != SYM_ARRAY &&
+		     sym->type != SYM_BITFIELD)) {
+		const char *s;
+		size_t len;
+
+		if (as)
+			prepend(name, "<asn:%d>", as);
+
+		s = modifier_string(mod);
+		len = strlen(s);
+		name->start -= len;    
+		memcpy(name->start, s, len);  
+		mod = 0;
+		as = 0;
+	}
+
+	if (!sym)
+		goto out;
+
+	if ((typename = builtin_typename(sym))) {
+		int len = strlen(typename);
+		if (name->start != name->end)
+			*--name->start = ' ';
+		name->start -= len;
+		memcpy(name->start, typename, len);
+		goto out;
+	}
+
+	/* Prepend */
+	switch (sym->type) {
+	case SYM_PTR:
+		prepend(name, "*");
+		mod = sym->ctype.modifiers;
+		as = sym->ctype.as;
+		was_ptr = 1;
+		break;
+
+	case SYM_FN:
+		if (was_ptr) {
+			prepend(name, "( ");
+			append(name, " )");
+			was_ptr = 0;
+		}
+		append(name, "( ... )");
+		break;
+
+	case SYM_STRUCT:
+		if (name->start != name->end)
+			*--name->start = ' ';
+		prepend(name, "struct %s", show_ident(sym->ident));
+		goto out;
+
+	case SYM_UNION:
+		if (name->start != name->end)
+			*--name->start = ' ';
+		prepend(name, "union %s", show_ident(sym->ident));
+		goto out;
+
+	case SYM_ENUM:
+		prepend(name, "enum %s ", show_ident(sym->ident));
+		break;
+
+	case SYM_NODE:
+		append(name, "%s", show_ident(sym->ident));
+		mod |= sym->ctype.modifiers;
+		as |= sym->ctype.as;
+		break;
+
+	case SYM_BITFIELD:
+		mod |= sym->ctype.modifiers;
+		as |= sym->ctype.as;
+		append(name, ":%d", sym->bit_size);
+		break;
+
+	case SYM_LABEL:
+		append(name, "label(%s:%p)", show_ident(sym->ident), sym);
+		return;
+
+	case SYM_ARRAY:
+		mod |= sym->ctype.modifiers;
+		as |= sym->ctype.as;
+		if (was_ptr) {
+			prepend(name, "( ");
+			append(name, " )");
+			was_ptr = 0;
+		}
+		append(name, "[%lld]", get_expression_value(sym->array_size));
+		break;
+
+	case SYM_RESTRICT:
+		if (!sym->ident) {
+			restr = 1;
+			break;
+		}
+		if (name->start != name->end)
+			*--name->start = ' ';
+		prepend(name, "restricted %s", show_ident(sym->ident));
+		goto out;
+
+	case SYM_FOULED:
+		fouled = 1;
+		break;
+
+	default:
+		if (name->start != name->end)
+			*--name->start = ' ';
+		prepend(name, "unknown type %d", sym->type);
+		goto out;
+	}
+
+	sym = sym->ctype.base_type;
+	goto deeper;
+
+out:
+	if (restr)
+		prepend(name, "restricted ");
+	if (fouled)
+		prepend(name, "fouled ");
+}
+
+void show_type(struct symbol *sym)
+{
+	char array[200];
+	struct type_name name;
+
+	name.start = name.end = array+100;
+	do_show_type(sym, &name);
+	*name.end = 0;
+	printf("%s", name.start);
+}
+
+const char *show_typename(struct symbol *sym)
+{
+	static char array[200];
+	struct type_name name;
+
+	name.start = name.end = array+100;
+	do_show_type(sym, &name);
+	*name.end = 0;
+	return name.start;
+}
+
+void show_symbol(struct symbol *sym)
+{
+	struct symbol *type;
+
+	if (!sym)
+		return;
+
+	if (sym->ctype.alignment)
+		printf(".align %ld\n", sym->ctype.alignment);
+
+	show_type(sym);
+	type = sym->ctype.base_type;
+	if (!type) {
+		printf("\n");
+		return;
+	}
+
+	/*
+	 * Show actual implementation information
+	 */
+	switch (type->type) {
+		struct symbol *member;
+
+	case SYM_STRUCT:
+	case SYM_UNION:
+		printf(" {\n");
+		FOR_EACH_PTR(type->symbol_list, member) {
+			show_struct_member(member);
+		} END_FOR_EACH_PTR(member);
+		printf("}\n");
+		break;
+
+	case SYM_FN: {
+		struct statement *stmt = type->stmt;
+		printf("\n");
+		if (stmt) {
+			int val;
+			val = show_statement(stmt);
+			if (val)
+				printf("\tmov.%d\t\tretval,%d\n", stmt->ret->bit_size, val);
+			printf("\tret\n");
+		}
+		break;
+	}
+
+	default:
+		printf("\n");
+		break;
+	}
+
+	if (sym->initializer) {
+		printf(" = \n");
+		show_expression(sym->initializer);
+	}
+}
+
+static int show_symbol_init(struct symbol *sym);
+
+static int new_pseudo(void)
+{
+	static int nr = 0;
+	return ++nr;
+}
+
+static int new_label(void)
+{
+	static int label = 0;
+	return ++label;
+}
+
+static void show_switch_statement(struct statement *stmt)
+{
+	int val = show_expression(stmt->switch_expression);
+	struct symbol *sym;
+	printf("\tswitch v%d\n", val);
+
+	/*
+	 * Debugging only: Check that the case list is correct
+	 * by printing it out.
+	 *
+	 * This is where a _real_ back-end would go through the
+	 * cases to decide whether to use a lookup table or a
+	 * series of comparisons etc
+	 */
+	printf("# case table:\n");
+	FOR_EACH_PTR(stmt->switch_case->symbol_list, sym) {
+		struct statement *case_stmt = sym->stmt;
+		struct expression *expr = case_stmt->case_expression;
+		struct expression *to = case_stmt->case_to;
+
+		if (!expr) {
+			printf("    default");
+		} else {
+			if (expr->type == EXPR_VALUE) {
+				printf("    case %lld", expr->value);
+				if (to) {
+					if (to->type == EXPR_VALUE) {
+						printf(" .. %lld", to->value);
+					} else {
+						printf(" .. what?");
+					}
+				}
+			} else
+				printf("    what?");
+		}
+		printf(": .L%p\n", sym);
+	} END_FOR_EACH_PTR(sym);
+	printf("# end case table\n");
+
+	show_statement(stmt->switch_statement);
+
+	if (stmt->switch_break->used)
+		printf(".L%p:\n", stmt->switch_break);
+}
+
+static void show_symbol_decl(struct symbol_list *syms)
+{
+	struct symbol *sym;
+	FOR_EACH_PTR(syms, sym) {
+		show_symbol_init(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+static int show_return_stmt(struct statement *stmt);
+
+/*
+ * Print out a statement
+ */
+int show_statement(struct statement *stmt)
+{
+	if (!stmt)
+		return 0;
+	switch (stmt->type) {
+	case STMT_DECLARATION:
+		show_symbol_decl(stmt->declaration);
+		return 0;
+	case STMT_RETURN:
+		return show_return_stmt(stmt);
+	case STMT_COMPOUND: {
+		struct statement *s;
+		int last = 0;
+
+		if (stmt->inline_fn) {
+			show_statement(stmt->args);
+			printf("\tbegin_inline \t%s\n", show_ident(stmt->inline_fn->ident));
+		}
+		FOR_EACH_PTR(stmt->stmts, s) {
+			last = show_statement(s);
+		} END_FOR_EACH_PTR(s);
+		if (stmt->ret) {
+			int addr, bits;
+			printf(".L%p:\n", stmt->ret);
+			addr = show_symbol_expr(stmt->ret);
+			bits = stmt->ret->bit_size;
+			last = new_pseudo();
+			printf("\tld.%d\t\tv%d,[v%d]\n", bits, last, addr);
+		}
+		if (stmt->inline_fn)
+			printf("\tend_inlined\t%s\n", show_ident(stmt->inline_fn->ident));
+		return last;
+	}
+
+	case STMT_EXPRESSION:
+		return show_expression(stmt->expression);
+	case STMT_IF: {
+		int val, target;
+		struct expression *cond = stmt->if_conditional;
+
+/* This is only valid if nobody can jump into the "dead" statement */
+#if 0
+		if (cond->type == EXPR_VALUE) {
+			struct statement *s = stmt->if_true;
+			if (!cond->value)
+				s = stmt->if_false;
+			show_statement(s);
+			break;
+		}
+#endif
+		val = show_expression(cond);
+		target = new_label();
+		printf("\tje\t\tv%d,.L%d\n", val, target);
+		show_statement(stmt->if_true);
+		if (stmt->if_false) {
+			int last = new_label();
+			printf("\tjmp\t\t.L%d\n", last);
+			printf(".L%d:\n", target);
+			target = last;
+			show_statement(stmt->if_false);
+		}
+		printf(".L%d:\n", target);
+		break;
+	}
+	case STMT_SWITCH:
+		show_switch_statement(stmt);
+		break;
+
+	case STMT_CASE:
+		printf(".L%p:\n", stmt->case_label);
+		show_statement(stmt->case_statement);
+		break;
+
+	case STMT_ITERATOR: {
+		struct statement  *pre_statement = stmt->iterator_pre_statement;
+		struct expression *pre_condition = stmt->iterator_pre_condition;
+		struct statement  *statement = stmt->iterator_statement;
+		struct statement  *post_statement = stmt->iterator_post_statement;
+		struct expression *post_condition = stmt->iterator_post_condition;
+		int val, loop_top = 0, loop_bottom = 0;
+
+		show_symbol_decl(stmt->iterator_syms);
+		show_statement(pre_statement);
+		if (pre_condition) {
+			if (pre_condition->type == EXPR_VALUE) {
+				if (!pre_condition->value) {
+					loop_bottom = new_label();   
+					printf("\tjmp\t\t.L%d\n", loop_bottom);
+				}
+			} else {
+				loop_bottom = new_label();
+				val = show_expression(pre_condition);
+				printf("\tje\t\tv%d, .L%d\n", val, loop_bottom);
+			}
+		}
+		if (!post_condition || post_condition->type != EXPR_VALUE || post_condition->value) {
+			loop_top = new_label();
+			printf(".L%d:\n", loop_top);
+		}
+		show_statement(statement);
+		if (stmt->iterator_continue->used)
+			printf(".L%p:\n", stmt->iterator_continue);
+		show_statement(post_statement);
+		if (!post_condition) {
+			printf("\tjmp\t\t.L%d\n", loop_top);
+		} else if (post_condition->type == EXPR_VALUE) {
+			if (post_condition->value)
+				printf("\tjmp\t\t.L%d\n", loop_top);
+		} else {
+			val = show_expression(post_condition);
+			printf("\tjne\t\tv%d, .L%d\n", val, loop_top);
+		}
+		if (stmt->iterator_break->used)
+			printf(".L%p:\n", stmt->iterator_break);
+		if (loop_bottom)
+			printf(".L%d:\n", loop_bottom);
+		break;
+	}
+	case STMT_NONE:
+		break;
+	
+	case STMT_LABEL:
+		printf(".L%p:\n", stmt->label_identifier);
+		show_statement(stmt->label_statement);
+		break;
+
+	case STMT_GOTO:
+		if (stmt->goto_expression) {
+			int val = show_expression(stmt->goto_expression);
+			printf("\tgoto\t\t*v%d\n", val);
+		} else {
+			printf("\tgoto\t\t.L%p\n", stmt->goto_label);
+		}
+		break;
+	case STMT_ASM:
+		printf("\tasm( .... )\n");
+		break;
+	case STMT_CONTEXT: {
+		int val = show_expression(stmt->expression);
+		printf("\tcontext( %d )\n", val);
+		break;
+	}
+	case STMT_RANGE: {
+		int val = show_expression(stmt->range_expression);
+		int low = show_expression(stmt->range_low);
+		int high = show_expression(stmt->range_high);
+		printf("\trange( %d %d-%d)\n", val, low, high); 
+		break;
+	}	
+	}
+	return 0;
+}
+
+static int show_call_expression(struct expression *expr)
+{
+	struct symbol *direct;
+	struct expression *arg, *fn;
+	int fncall, retval;
+	int framesize;
+
+	if (!expr->ctype) {
+		warning(expr->pos, "\tcall with no type!");
+		return 0;
+	}
+
+	framesize = 0;
+	FOR_EACH_PTR_REVERSE(expr->args, arg) {
+		int new = show_expression(arg);
+		int size = arg->ctype->bit_size;
+		printf("\tpush.%d\t\tv%d\n", size, new);
+		framesize += bits_to_bytes(size);
+	} END_FOR_EACH_PTR_REVERSE(arg);
+
+	fn = expr->fn;
+
+	/* Remove dereference, if any */
+	direct = NULL;
+	if (fn->type == EXPR_PREOP) {
+		if (fn->unop->type == EXPR_SYMBOL) {
+			struct symbol *sym = fn->unop->symbol;
+			if (sym->ctype.base_type->type == SYM_FN)
+				direct = sym;
+		}
+	}
+	if (direct) {
+		printf("\tcall\t\t%s\n", show_ident(direct->ident));
+	} else {
+		fncall = show_expression(fn);
+		printf("\tcall\t\t*v%d\n", fncall);
+	}
+	if (framesize)
+		printf("\tadd.%d\t\tvSP,vSP,$%d\n", bits_in_pointer, framesize);
+
+	retval = new_pseudo();
+	printf("\tmov.%d\t\tv%d,retval\n", expr->ctype->bit_size, retval);
+	return retval;
+}
+
+static int show_comma(struct expression *expr)
+{
+	show_expression(expr->left);
+	return show_expression(expr->right);
+}
+
+static int show_binop(struct expression *expr)
+{
+	int left = show_expression(expr->left);
+	int right = show_expression(expr->right);
+	int new = new_pseudo();
+	const char *opname;
+	static const char *name[] = {
+		['+'] = "add", ['-'] = "sub",
+		['*'] = "mul", ['/'] = "div",
+		['%'] = "mod", ['&'] = "and",
+		['|'] = "lor", ['^'] = "xor"
+	};
+	unsigned int op = expr->op;
+
+	opname = show_special(op);
+	if (op < ARRAY_SIZE(name))
+		opname = name[op];
+	printf("\t%s.%d\t\tv%d,v%d,v%d\n", opname,
+		expr->ctype->bit_size,
+		new, left, right);
+	return new;
+}
+
+static int show_slice(struct expression *expr)
+{
+	int target = show_expression(expr->base);
+	int new = new_pseudo();
+	printf("\tslice.%d\t\tv%d,v%d,%d\n", expr->r_nrbits, target, new, expr->r_bitpos);
+	return new;
+}
+
+static int show_regular_preop(struct expression *expr)
+{
+	int target = show_expression(expr->unop);
+	int new = new_pseudo();
+	static const char *name[] = {
+		['!'] = "nonzero", ['-'] = "neg",
+		['~'] = "not",
+	};
+	unsigned int op = expr->op;
+	const char *opname;
+
+	opname = show_special(op);
+	if (op < ARRAY_SIZE(name))
+		opname = name[op];
+	printf("\t%s.%d\t\tv%d,v%d\n", opname, expr->ctype->bit_size, new, target);
+	return new;
+}
+
+/*
+ * FIXME! Not all accesses are memory loads. We should
+ * check what kind of symbol is behind the dereference.
+ */
+static int show_address_gen(struct expression *expr)
+{
+	return show_expression(expr->unop);
+}
+
+static int show_load_gen(int bits, struct expression *expr, int addr)
+{
+	int new = new_pseudo();
+
+	printf("\tld.%d\t\tv%d,[v%d]\n", bits, new, addr);
+	return new;
+}
+
+static void show_store_gen(int bits, int value, struct expression *expr, int addr)
+{
+	/* FIXME!!! Bitfield store! */
+	printf("\tst.%d\t\tv%d,[v%d]\n", bits, value, addr);
+}
+
+static int show_assignment(struct expression *expr)
+{
+	struct expression *target = expr->left;
+	int val, addr, bits;
+
+	if (!expr->ctype)
+		return 0;
+
+	bits = expr->ctype->bit_size;
+	val = show_expression(expr->right);
+	addr = show_address_gen(target);
+	show_store_gen(bits, val, target, addr);
+	return val;
+}
+
+static int show_return_stmt(struct statement *stmt)
+{
+	struct expression *expr = stmt->ret_value;
+	struct symbol *target = stmt->ret_target;
+
+	if (expr && expr->ctype) {
+		int val = show_expression(expr);
+		int bits = expr->ctype->bit_size;
+		int addr = show_symbol_expr(target);
+		show_store_gen(bits, val, NULL, addr);
+	}
+	printf("\tret\t\t(%p)\n", target);
+	return 0;
+}
+
+static int show_initialization(struct symbol *sym, struct expression *expr)
+{
+	int val, addr, bits;
+
+	if (!expr->ctype)
+		return 0;
+
+	bits = expr->ctype->bit_size;
+	val = show_expression(expr);
+	addr = show_symbol_expr(sym);
+	// FIXME! The "target" expression is for bitfield store information.
+	// Leave it NULL, which works fine.
+	show_store_gen(bits, val, NULL, addr);
+	return 0;
+}
+
+static int show_access(struct expression *expr)
+{
+	int addr = show_address_gen(expr);
+	return show_load_gen(expr->ctype->bit_size, expr, addr);
+}
+
+static int show_inc_dec(struct expression *expr, int postop)
+{
+	int addr = show_address_gen(expr->unop);
+	int retval, new;
+	const char *opname = expr->op == SPECIAL_INCREMENT ? "add" : "sub";
+	int bits = expr->ctype->bit_size;
+
+	retval = show_load_gen(bits, expr->unop, addr);
+	new = retval;
+	if (postop)
+		new = new_pseudo();
+	printf("\t%s.%d\t\tv%d,v%d,$1\n", opname, bits, new, retval);
+	show_store_gen(bits, new, expr->unop, addr);
+	return retval;
+}	
+
+static int show_preop(struct expression *expr)
+{
+	/*
+	 * '*' is an lvalue access, and is fundamentally different
+	 * from an arithmetic operation. Maybe it should have an
+	 * expression type of its own..
+	 */
+	if (expr->op == '*')
+		return show_access(expr);
+	if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
+		return show_inc_dec(expr, 0);
+	return show_regular_preop(expr);
+}
+
+static int show_postop(struct expression *expr)
+{
+	return show_inc_dec(expr, 1);
+}	
+
+static int show_symbol_expr(struct symbol *sym)
+{
+	int new = new_pseudo();
+
+	if (sym->initializer && sym->initializer->type == EXPR_STRING)
+		return show_string_expr(sym->initializer);
+
+	if (sym->ctype.modifiers & (MOD_TOPLEVEL | MOD_EXTERN | MOD_STATIC)) {
+		printf("\tmovi.%d\t\tv%d,$%s\n", bits_in_pointer, new, show_ident(sym->ident));
+		return new;
+	}
+	if (sym->ctype.modifiers & MOD_ADDRESSABLE) {
+		printf("\taddi.%d\t\tv%d,vFP,$%lld\n", bits_in_pointer, new, sym->value);
+		return new;
+	}
+	printf("\taddi.%d\t\tv%d,vFP,$offsetof(%s:%p)\n", bits_in_pointer, new, show_ident(sym->ident), sym);
+	return new;
+}
+
+static int show_symbol_init(struct symbol *sym)
+{
+	struct expression *expr = sym->initializer;
+
+	if (expr) {
+		int val, addr, bits;
+
+		bits = expr->ctype->bit_size;
+		val = show_expression(expr);
+		addr = show_symbol_expr(sym);
+		show_store_gen(bits, val, NULL, addr);
+	}
+	return 0;
+}
+
+static int type_is_signed(struct symbol *sym)
+{
+	if (sym->type == SYM_NODE)
+		sym = sym->ctype.base_type;
+	if (sym->type == SYM_PTR)
+		return 0;
+	return !(sym->ctype.modifiers & MOD_UNSIGNED);
+}
+
+static int show_cast_expr(struct expression *expr)
+{
+	struct symbol *old_type, *new_type;
+	int op = show_expression(expr->cast_expression);
+	int oldbits, newbits;
+	int new, is_signed;
+
+	old_type = expr->cast_expression->ctype;
+	new_type = expr->cast_type;
+	
+	oldbits = old_type->bit_size;
+	newbits = new_type->bit_size;
+	if (oldbits >= newbits)
+		return op;
+	new = new_pseudo();
+	is_signed = type_is_signed(old_type);
+	if (is_signed) {
+		printf("\tsext%d.%d\tv%d,v%d\n", oldbits, newbits, new, op);
+	} else {
+		printf("\tandl.%d\t\tv%d,v%d,$%lu\n", newbits, new, op, (1UL << oldbits)-1);
+	}
+	return new;
+}
+
+static int show_value(struct expression *expr)
+{
+	int new = new_pseudo();
+	unsigned long long value = expr->value;
+
+	printf("\tmovi.%d\t\tv%d,$%llu\n", expr->ctype->bit_size, new, value);
+	return new;
+}
+
+static int show_fvalue(struct expression *expr)
+{
+	int new = new_pseudo();
+	long double value = expr->fvalue;
+
+	printf("\tmovf.%d\t\tv%d,$%Lf\n", expr->ctype->bit_size, new, value);
+	return new;
+}
+
+static int show_string_expr(struct expression *expr)
+{
+	int new = new_pseudo();
+
+	printf("\tmovi.%d\t\tv%d,&%s\n", bits_in_pointer, new, show_string(expr->string));
+	return new;
+}
+
+static int show_label_expr(struct expression *expr)
+{
+	int new = new_pseudo();
+	printf("\tmovi.%d\t\tv%d,.L%p\n",bits_in_pointer, new, expr->label_symbol);
+	return new;
+}
+
+static int show_conditional_expr(struct expression *expr)
+{
+	int cond = show_expression(expr->conditional);
+	int true = show_expression(expr->cond_true);
+	int false = show_expression(expr->cond_false);
+	int new = new_pseudo();
+
+	printf("[v%d]\tcmov.%d\t\tv%d,v%d,v%d\n", cond, expr->ctype->bit_size, new, true, false);
+	return new;
+}
+
+static int show_statement_expr(struct expression *expr)
+{
+	return show_statement(expr->statement);
+}
+
+static int show_position_expr(struct expression *expr, struct symbol *base)
+{
+	int new = show_expression(expr->init_expr);
+	struct symbol *ctype = expr->init_expr->ctype;
+	int bit_offset;
+
+	bit_offset = ctype ? ctype->bit_offset : -1;
+
+	printf("\tinsert v%d at [%d:%d] of %s\n", new,
+		expr->init_offset, bit_offset,
+		show_ident(base->ident));
+	return 0;
+}
+
+static int show_initializer_expr(struct expression *expr, struct symbol *ctype)
+{
+	struct expression *entry;
+
+	FOR_EACH_PTR(expr->expr_list, entry) {
+
+again:
+		// Nested initializers have their positions already
+		// recursively calculated - just output them too
+		if (entry->type == EXPR_INITIALIZER) {
+			show_initializer_expr(entry, ctype);
+			continue;
+		}
+
+		// Initializer indexes and identifiers should
+		// have been evaluated to EXPR_POS
+		if (entry->type == EXPR_IDENTIFIER) {
+			printf(" AT '%s':\n", show_ident(entry->expr_ident));
+			entry = entry->ident_expression;
+			goto again;
+		}
+			
+		if (entry->type == EXPR_INDEX) {
+			printf(" AT '%d..%d:\n", entry->idx_from, entry->idx_to);
+			entry = entry->idx_expression;
+			goto again;
+		}
+		if (entry->type == EXPR_POS) {
+			show_position_expr(entry, ctype);
+			continue;
+		}
+		show_initialization(ctype, entry);
+	} END_FOR_EACH_PTR(entry);
+	return 0;
+}
+
+int show_symbol_expr_init(struct symbol *sym)
+{
+	struct expression *expr = sym->initializer;
+
+	if (expr)
+		show_expression(expr);
+	return show_symbol_expr(sym);
+}
+
+/*
+ * Print out an expression. Return the pseudo that contains the
+ * variable.
+ */
+int show_expression(struct expression *expr)
+{
+	if (!expr)
+		return 0;
+
+	if (!expr->ctype) {
+		struct position *pos = &expr->pos;
+		printf("\tno type at %s:%d:%d\n",
+			stream_name(pos->stream),
+			pos->line, pos->pos);
+		return 0;
+	}
+		
+	switch (expr->type) {
+	case EXPR_CALL:
+		return show_call_expression(expr);
+		
+	case EXPR_ASSIGNMENT:
+		return show_assignment(expr);
+
+	case EXPR_COMMA:
+		return show_comma(expr);
+	case EXPR_BINOP:
+	case EXPR_COMPARE:
+	case EXPR_LOGICAL:
+		return show_binop(expr);
+	case EXPR_PREOP:
+		return show_preop(expr);
+	case EXPR_POSTOP:
+		return show_postop(expr);
+	case EXPR_SYMBOL:
+		return show_symbol_expr(expr->symbol);
+	case EXPR_DEREF:
+	case EXPR_SIZEOF:
+	case EXPR_PTRSIZEOF:
+	case EXPR_ALIGNOF:
+	case EXPR_OFFSETOF:
+		warning(expr->pos, "invalid expression after evaluation");
+		return 0;
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+	case EXPR_IMPLIED_CAST:
+		return show_cast_expr(expr);
+	case EXPR_VALUE:
+		return show_value(expr);
+	case EXPR_FVALUE:
+		return show_fvalue(expr);
+	case EXPR_STRING:
+		return show_string_expr(expr);
+	case EXPR_INITIALIZER:
+		return show_initializer_expr(expr, expr->ctype);
+	case EXPR_SELECT:
+	case EXPR_CONDITIONAL:
+		return show_conditional_expr(expr);
+	case EXPR_STATEMENT:
+		return show_statement_expr(expr);
+	case EXPR_LABEL:
+		return show_label_expr(expr);
+	case EXPR_SLICE:
+		return show_slice(expr);
+
+	// None of these should exist as direct expressions: they are only
+	// valid as sub-expressions of initializers.
+	case EXPR_POS:
+		warning(expr->pos, "unable to show plain initializer position expression");
+		return 0;
+	case EXPR_IDENTIFIER:
+		warning(expr->pos, "unable to show identifier expression");
+		return 0;
+	case EXPR_INDEX:
+		warning(expr->pos, "unable to show index expression");
+		return 0;
+	case EXPR_TYPE:
+		warning(expr->pos, "unable to show type expression");
+		return 0;
+	}
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/simplify.c b/usr/src/tools/smatch/src/simplify.c
new file mode 100644
index 0000000000..1e926e7d6e
--- /dev/null
+++ b/usr/src/tools/smatch/src/simplify.c
@@ -0,0 +1,1227 @@
+/*
+ * Simplify - do instruction simplification before CSE
+ *
+ * Copyright (C) 2004 Linus Torvalds
+ */
+
+#include <assert.h>
+
+#include "parse.h"
+#include "expression.h"
+#include "linearize.h"
+#include "flow.h"
+#include "symbol.h"
+
+/* Find the trivial parent for a phi-source */
+static struct basic_block *phi_parent(struct basic_block *source, pseudo_t pseudo)
+{
+	/* Can't go upwards if the pseudo is defined in the bb it came from.. */
+	if (pseudo->type == PSEUDO_REG) {
+		struct instruction *def = pseudo->def;
+		if (def->bb == source)
+			return source;
+	}
+	if (bb_list_size(source->children) != 1 || bb_list_size(source->parents) != 1)
+		return source;
+	return first_basic_block(source->parents);
+}
+
+/*
+ * Copy the phi-node's phisrcs into to given array.
+ * Returns 0 if the the list contained the expected
+ * number of element, a positive number if there was
+ * more than expected and a negative one if less.
+ *
+ * Note: we can't reuse a function like linearize_ptr_list()
+ * because any VOIDs in the phi-list must be ignored here
+ * as in this context they mean 'entry has been removed'.
+ */
+static int get_phisources(struct instruction *sources[], int nbr, struct instruction *insn)
+{
+	pseudo_t phi;
+	int i = 0;
+
+	assert(insn->opcode == OP_PHI);
+	FOR_EACH_PTR(insn->phi_list, phi) {
+		struct instruction *def;
+		if (phi == VOID)
+			continue;
+		if (i >= nbr)
+			return 1;
+		def = phi->def;
+		assert(def->opcode == OP_PHISOURCE);
+		sources[i++] = def;
+	} END_FOR_EACH_PTR(phi);
+	return i - nbr;
+}
+
+static int if_convert_phi(struct instruction *insn)
+{
+	struct instruction *array[2];
+	struct basic_block *parents[3];
+	struct basic_block *bb, *bb1, *bb2, *source;
+	struct instruction *br;
+	pseudo_t p1, p2;
+
+	bb = insn->bb;
+	if (get_phisources(array, 2, insn))
+		return 0;
+	if (linearize_ptr_list((struct ptr_list *)bb->parents, (void **)parents, 3) != 2)
+		return 0;
+	p1 = array[0]->src1;
+	bb1 = array[0]->bb;
+	p2 = array[1]->src1;
+	bb2 = array[1]->bb;
+
+	/* Only try the simple "direct parents" case */
+	if ((bb1 != parents[0] || bb2 != parents[1]) &&
+	    (bb1 != parents[1] || bb2 != parents[0]))
+		return 0;
+
+	/*
+	 * See if we can find a common source for this..
+	 */
+	source = phi_parent(bb1, p1);
+	if (source != phi_parent(bb2, p2))
+		return 0;
+
+	/*
+	 * Cool. We now know that 'source' is the exclusive
+	 * parent of both phi-nodes, so the exit at the
+	 * end of it fully determines which one it is, and
+	 * we can turn it into a select.
+	 *
+	 * HOWEVER, right now we only handle regular
+	 * conditional branches. No multijumps or computed
+	 * stuff. Verify that here.
+	 */
+	br = last_instruction(source->insns);
+	if (!br || br->opcode != OP_CBR)
+		return 0;
+
+	assert(br->cond);
+	assert(br->bb_false);
+
+	/*
+	 * We're in business. Match up true/false with p1/p2.
+	 */
+	if (br->bb_true == bb2 || br->bb_false == bb1) {
+		pseudo_t p = p1;
+		p1 = p2;
+		p2 = p;
+	}
+
+	/*
+	 * OK, we can now replace that last
+	 *
+	 *	br cond, a, b
+	 *
+	 * with the sequence
+	 *
+	 *	setcc cond
+	 *	select pseudo, p1, p2
+	 *	br cond, a, b
+	 *
+	 * and remove the phi-node. If it then
+	 * turns out that 'a' or 'b' is entirely
+	 * empty (common case), and now no longer
+	 * a phi-source, we'll be able to simplify
+	 * the conditional branch too.
+	 */
+	insert_select(source, br, insn, p1, p2);
+	kill_instruction(insn);
+	return REPEAT_CSE;
+}
+
+static int clean_up_phi(struct instruction *insn)
+{
+	pseudo_t phi;
+	struct instruction *last;
+	int same;
+
+	last = NULL;
+	same = 1;
+	FOR_EACH_PTR(insn->phi_list, phi) {
+		struct instruction *def;
+		if (phi == VOID)
+			continue;
+		def = phi->def;
+		if (def->src1 == VOID || !def->bb)
+			continue;
+		if (last) {
+			if (last->src1 != def->src1)
+				same = 0;
+			continue;
+		}
+		last = def;
+	} END_FOR_EACH_PTR(phi);
+
+	if (same) {
+		pseudo_t pseudo = last ? last->src1 : VOID;
+		convert_instruction_target(insn, pseudo);
+		kill_instruction(insn);
+		return REPEAT_CSE;
+	}
+
+	return if_convert_phi(insn);
+}
+
+static int delete_pseudo_user_list_entry(struct pseudo_user_list **list, pseudo_t *entry, int count)
+{
+	struct pseudo_user *pu;
+
+	FOR_EACH_PTR(*list, pu) {
+		if (pu->userp == entry) {
+			MARK_CURRENT_DELETED(pu);
+			if (!--count)
+				goto out;
+		}
+	} END_FOR_EACH_PTR(pu);
+	assert(count <= 0);
+out:
+	if (ptr_list_size((struct ptr_list *) *list) == 0)
+		*list = NULL;
+	return count;
+}
+
+static inline void remove_usage(pseudo_t p, pseudo_t *usep)
+{
+	if (has_use_list(p)) {
+		delete_pseudo_user_list_entry(&p->users, usep, 1);
+		if (!p->users)
+			kill_instruction(p->def);
+	}
+}
+
+void kill_use(pseudo_t *usep)
+{
+	if (usep) {
+		pseudo_t p = *usep;
+		*usep = VOID;
+		remove_usage(p, usep);
+	}
+}
+
+static void kill_use_list(struct pseudo_list *list)
+{
+	pseudo_t p;
+	FOR_EACH_PTR(list, p) {
+		if (p == VOID)
+			continue;
+		kill_use(THIS_ADDRESS(p));
+	} END_FOR_EACH_PTR(p);
+}
+
+/*
+ * kill an instruction:
+ * - remove it from its bb
+ * - remove the usage of all its operands
+ * If forse is zero, the normal case, the function only for
+ * instructions free of (possible) side-effects. Otherwise
+ * the function does that unconditionally (must only be used
+ * for unreachable instructions.
+ */
+void kill_insn(struct instruction *insn, int force)
+{
+	if (!insn || !insn->bb)
+		return;
+
+	switch (insn->opcode) {
+	case OP_SEL:
+	case OP_RANGE:
+		kill_use(&insn->src3);
+		/* fall through */
+
+	case OP_BINARY ... OP_BINCMP_END:
+		kill_use(&insn->src2);
+		/* fall through */
+
+	case OP_CAST:
+	case OP_SCAST:
+	case OP_FPCAST:
+	case OP_PTRCAST:
+	case OP_SETVAL:
+	case OP_NOT: case OP_NEG:
+	case OP_SLICE:
+		kill_use(&insn->src1);
+		break;
+
+	case OP_PHI:
+		kill_use_list(insn->phi_list);
+		break;
+	case OP_PHISOURCE:
+		kill_use(&insn->phi_src);
+		break;
+
+	case OP_SYMADDR:
+		repeat_phase |= REPEAT_SYMBOL_CLEANUP;
+		break;
+
+	case OP_CBR:
+	case OP_COMPUTEDGOTO:
+		kill_use(&insn->cond);
+		break;
+
+	case OP_CALL:
+		if (!force) {
+			/* a "pure" function can be killed too */
+			if (!(insn->func->type == PSEUDO_SYM))
+				return;
+			if (!(insn->func->sym->ctype.modifiers & MOD_PURE))
+				return;
+		}
+		kill_use_list(insn->arguments);
+		if (insn->func->type == PSEUDO_REG)
+			kill_use(&insn->func);
+		break;
+
+	case OP_LOAD:
+		if (!force && insn->type->ctype.modifiers & MOD_VOLATILE)
+			return;
+		kill_use(&insn->src);
+		break;
+
+	case OP_STORE:
+		if (!force)
+			return;
+		kill_use(&insn->src);
+		kill_use(&insn->target);
+		break;
+
+	case OP_ENTRY:
+		/* ignore */
+		return;
+
+	case OP_BR:
+	default:
+		break;
+	}
+
+	insn->bb = NULL;
+	repeat_phase |= REPEAT_CSE;
+	return;
+}
+
+/*
+ * Kill trivially dead instructions
+ */
+static int dead_insn(struct instruction *insn, pseudo_t *src1, pseudo_t *src2, pseudo_t *src3)
+{
+	struct pseudo_user *pu;
+	FOR_EACH_PTR(insn->target->users, pu) {
+		if (*pu->userp != VOID)
+			return 0;
+	} END_FOR_EACH_PTR(pu);
+
+	insn->bb = NULL;
+	kill_use(src1);
+	kill_use(src2);
+	kill_use(src3);
+	return REPEAT_CSE;
+}
+
+static inline int constant(pseudo_t pseudo)
+{
+	return pseudo->type == PSEUDO_VAL;
+}
+
+static int replace_with_pseudo(struct instruction *insn, pseudo_t pseudo)
+{
+	convert_instruction_target(insn, pseudo);
+
+	switch (insn->opcode) {
+	case OP_SEL:
+	case OP_RANGE:
+		kill_use(&insn->src3);
+	case OP_BINARY ... OP_BINCMP_END:
+		kill_use(&insn->src2);
+	case OP_NOT:
+	case OP_NEG:
+	case OP_SYMADDR:
+	case OP_CAST:
+	case OP_SCAST:
+	case OP_FPCAST:
+	case OP_PTRCAST:
+		kill_use(&insn->src1);
+		break;
+
+	default:
+		assert(0);
+	}
+	insn->bb = NULL;
+	return REPEAT_CSE;
+}
+
+unsigned int value_size(long long value)
+{
+	value >>= 8;
+	if (!value)
+		return 8;
+	value >>= 8;
+	if (!value)
+		return 16;
+	value >>= 16;
+	if (!value)
+		return 32;
+	return 64;
+}
+
+/*
+ * Try to determine the maximum size of bits in a pseudo.
+ *
+ * Right now this only follow casts and constant values, but we
+ * could look at things like logical 'and' instructions etc.
+ */
+static unsigned int operand_size(struct instruction *insn, pseudo_t pseudo)
+{
+	unsigned int size = insn->size;
+
+	if (pseudo->type == PSEUDO_REG) {
+		struct instruction *src = pseudo->def;
+		if (src && src->opcode == OP_CAST && src->orig_type) {
+			unsigned int orig_size = src->orig_type->bit_size;
+			if (orig_size < size)
+				size = orig_size;
+		}
+	}
+	if (pseudo->type == PSEUDO_VAL) {
+		unsigned int orig_size = value_size(pseudo->value);
+		if (orig_size < size)
+			size = orig_size;
+	}
+	return size;
+}
+
+static int simplify_asr(struct instruction *insn, pseudo_t pseudo, long long value)
+{
+	unsigned int size = operand_size(insn, pseudo);
+
+	if (value >= size) {
+		warning(insn->pos, "right shift by bigger than source value");
+		return replace_with_pseudo(insn, value_pseudo(insn->type, 0));
+	}
+	if (!value)
+		return replace_with_pseudo(insn, pseudo);
+	return 0;
+}
+
+static int simplify_mul_div(struct instruction *insn, long long value)
+{
+	unsigned long long sbit = 1ULL << (insn->size - 1);
+	unsigned long long bits = sbit | (sbit - 1);
+
+	if (value == 1)
+		return replace_with_pseudo(insn, insn->src1);
+
+	switch (insn->opcode) {
+	case OP_MULS:
+	case OP_MULU:
+		if (value == 0)
+			return replace_with_pseudo(insn, insn->src2);
+	/* Fall through */
+	case OP_DIVS:
+		if (!(value & sbit))	// positive
+			break;
+
+		value |= ~bits;
+		if (value == -1) {
+			insn->opcode = OP_NEG;
+			return REPEAT_CSE;
+		}
+	}
+
+	return 0;
+}
+
+static int compare_opcode(int opcode, int inverse)
+{
+	if (!inverse)
+		return opcode;
+
+	switch (opcode) {
+	case OP_SET_EQ:	return OP_SET_NE;
+	case OP_SET_NE:	return OP_SET_EQ;
+
+	case OP_SET_LT:	return OP_SET_GE;
+	case OP_SET_LE:	return OP_SET_GT;
+	case OP_SET_GT:	return OP_SET_LE;
+	case OP_SET_GE:	return OP_SET_LT;
+
+	case OP_SET_A:	return OP_SET_BE;
+	case OP_SET_AE:	return OP_SET_B;
+	case OP_SET_B:	return OP_SET_AE;
+	case OP_SET_BE:	return OP_SET_A;
+
+	default:
+		return opcode;
+	}
+}
+
+static int simplify_seteq_setne(struct instruction *insn, long long value)
+{
+	pseudo_t old = insn->src1;
+	struct instruction *def = old->def;
+	pseudo_t src1, src2;
+	int inverse;
+	int opcode;
+
+	if (value != 0 && value != 1)
+		return 0;
+
+	if (!def)
+		return 0;
+
+	inverse = (insn->opcode == OP_SET_NE) == value;
+	opcode = def->opcode;
+	switch (opcode) {
+	case OP_BINCMP ... OP_BINCMP_END:
+		// Convert:
+		//	setcc.n	%t <- %a, %b
+		//	setne.m %r <- %t, $0
+		// into:
+		//	setcc.n	%t <- %a, %b
+		//	setcc.m %r <- %a, $b
+		// and similar for setne/eq ... 0/1
+		src1 = def->src1;
+		src2 = def->src2;
+		insn->opcode = compare_opcode(opcode, inverse);
+		use_pseudo(insn, src1, &insn->src1);
+		use_pseudo(insn, src2, &insn->src2);
+		remove_usage(old, &insn->src1);
+		return REPEAT_CSE;
+
+	default:
+		return 0;
+	}
+}
+
+static int simplify_constant_rightside(struct instruction *insn)
+{
+	long long value = insn->src2->value;
+
+	switch (insn->opcode) {
+	case OP_OR_BOOL:
+		if (value == 1)
+			return replace_with_pseudo(insn, insn->src2);
+		goto case_neutral_zero;
+
+	case OP_SUB:
+		if (value) {
+			insn->opcode = OP_ADD;
+			insn->src2 = value_pseudo(insn->type, -value);
+			return REPEAT_CSE;
+		}
+	/* Fall through */
+	case OP_ADD:
+	case OP_OR: case OP_XOR:
+	case OP_SHL:
+	case OP_LSR:
+	case_neutral_zero:
+		if (!value)
+			return replace_with_pseudo(insn, insn->src1);
+		return 0;
+	case OP_ASR:
+		return simplify_asr(insn, insn->src1, value);
+
+	case OP_MODU: case OP_MODS:
+		if (value == 1)
+			return replace_with_pseudo(insn, value_pseudo(insn->type, 0));
+		return 0;
+
+	case OP_DIVU: case OP_DIVS:
+	case OP_MULU: case OP_MULS:
+		return simplify_mul_div(insn, value);
+
+	case OP_AND_BOOL:
+		if (value == 1)
+			return replace_with_pseudo(insn, insn->src1);
+	/* Fall through */
+	case OP_AND:
+		if (!value)
+			return replace_with_pseudo(insn, insn->src2);
+		return 0;
+
+	case OP_SET_NE:
+	case OP_SET_EQ:
+		return simplify_seteq_setne(insn, value);
+	}
+	return 0;
+}
+
+static int simplify_constant_leftside(struct instruction *insn)
+{
+	long long value = insn->src1->value;
+
+	switch (insn->opcode) {
+	case OP_ADD: case OP_OR: case OP_XOR:
+		if (!value)
+			return replace_with_pseudo(insn, insn->src2);
+		return 0;
+
+	case OP_SHL:
+	case OP_LSR: case OP_ASR:
+	case OP_AND:
+	case OP_MULU: case OP_MULS:
+		if (!value)
+			return replace_with_pseudo(insn, insn->src1);
+		return 0;
+	}
+	return 0;
+}
+
+static int simplify_constant_binop(struct instruction *insn)
+{
+	/* FIXME! Verify signs and sizes!! */
+	long long left = insn->src1->value;
+	long long right = insn->src2->value;
+	unsigned long long ul, ur;
+	long long res, mask, bits;
+
+	mask = 1ULL << (insn->size-1);
+	bits = mask | (mask-1);
+
+	if (left & mask)
+		left |= ~bits;
+	if (right & mask)
+		right |= ~bits;
+	ul = left & bits;
+	ur = right & bits;
+
+	switch (insn->opcode) {
+	case OP_ADD:
+		res = left + right;
+		break;
+	case OP_SUB:
+		res = left - right;
+		break;
+	case OP_MULU:
+		res = ul * ur;
+		break;
+	case OP_MULS:
+		res = left * right;
+		break;
+	case OP_DIVU:
+		if (!ur)
+			return 0;
+		res = ul / ur;
+		break;
+	case OP_DIVS:
+		if (!right)
+			return 0;
+		if (left == mask && right == -1)
+			return 0;
+		res = left / right;
+		break;
+	case OP_MODU:
+		if (!ur)
+			return 0;
+		res = ul % ur;
+		break;
+	case OP_MODS:
+		if (!right)
+			return 0;
+		if (left == mask && right == -1)
+			return 0;
+		res = left % right;
+		break;
+	case OP_SHL:
+		res = left << right;
+		break;
+	case OP_LSR:
+		res = ul >> ur;
+		break;
+	case OP_ASR:
+		res = left >> right;
+		break;
+       /* Logical */
+	case OP_AND:
+		res = left & right;
+		break;
+	case OP_OR:
+		res = left | right;
+		break;
+	case OP_XOR:
+		res = left ^ right;
+		break;
+	case OP_AND_BOOL:
+		res = left && right;
+		break;
+	case OP_OR_BOOL:
+		res = left || right;
+		break;
+			       
+	/* Binary comparison */
+	case OP_SET_EQ:
+		res = left == right;
+		break;
+	case OP_SET_NE:
+		res = left != right;
+		break;
+	case OP_SET_LE:
+		res = left <= right;
+		break;
+	case OP_SET_GE:
+		res = left >= right;
+		break;
+	case OP_SET_LT:
+		res = left < right;
+		break;
+	case OP_SET_GT:
+		res = left > right;
+		break;
+	case OP_SET_B:
+		res = ul < ur;
+		break;
+	case OP_SET_A:
+		res = ul > ur;
+		break;
+	case OP_SET_BE:
+		res = ul <= ur;
+		break;
+	case OP_SET_AE:
+		res = ul >= ur;
+		break;
+	default:
+		return 0;
+	}
+	res &= bits;
+
+	replace_with_pseudo(insn, value_pseudo(insn->type, res));
+	return REPEAT_CSE;
+}
+
+static int simplify_binop_same_args(struct instruction *insn, pseudo_t arg)
+{
+	switch (insn->opcode) {
+	case OP_SET_NE:
+	case OP_SET_LT: case OP_SET_GT:
+	case OP_SET_B:  case OP_SET_A:
+		if (Wtautological_compare)
+			warning(insn->pos, "self-comparison always evaluates to false");
+	case OP_SUB:
+	case OP_XOR:
+		return replace_with_pseudo(insn, value_pseudo(insn->type, 0));
+
+	case OP_SET_EQ:
+	case OP_SET_LE: case OP_SET_GE:
+	case OP_SET_BE: case OP_SET_AE:
+		if (Wtautological_compare)
+			warning(insn->pos, "self-comparison always evaluates to true");
+		return replace_with_pseudo(insn, value_pseudo(insn->type, 1));
+
+	case OP_AND:
+	case OP_OR:
+		return replace_with_pseudo(insn, arg);
+
+	case OP_AND_BOOL:
+	case OP_OR_BOOL:
+		remove_usage(arg, &insn->src2);
+		insn->src2 = value_pseudo(insn->type, 0);
+		insn->opcode = OP_SET_NE;
+		return REPEAT_CSE;
+
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static int simplify_binop(struct instruction *insn)
+{
+	if (dead_insn(insn, &insn->src1, &insn->src2, NULL))
+		return REPEAT_CSE;
+	if (constant(insn->src1)) {
+		if (constant(insn->src2))
+			return simplify_constant_binop(insn);
+		return simplify_constant_leftside(insn);
+	}
+	if (constant(insn->src2))
+		return simplify_constant_rightside(insn);
+	if (insn->src1 == insn->src2)
+		return simplify_binop_same_args(insn, insn->src1);
+	return 0;
+}
+
+static void switch_pseudo(struct instruction *insn1, pseudo_t *pp1, struct instruction *insn2, pseudo_t *pp2)
+{
+	pseudo_t p1 = *pp1, p2 = *pp2;
+
+	use_pseudo(insn1, p2, pp1);
+	use_pseudo(insn2, p1, pp2);
+	remove_usage(p1, pp1);
+	remove_usage(p2, pp2);
+}
+
+static int canonical_order(pseudo_t p1, pseudo_t p2)
+{
+	/* symbol/constants on the right */
+	if (p1->type == PSEUDO_VAL)
+		return p2->type == PSEUDO_VAL;
+
+	if (p1->type == PSEUDO_SYM)
+		return p2->type == PSEUDO_SYM || p2->type == PSEUDO_VAL;
+
+	return 1;
+}
+
+static int simplify_commutative_binop(struct instruction *insn)
+{
+	if (!canonical_order(insn->src1, insn->src2)) {
+		switch_pseudo(insn, &insn->src1, insn, &insn->src2);
+		return REPEAT_CSE;
+	}
+	return 0;
+}
+
+static inline int simple_pseudo(pseudo_t pseudo)
+{
+	return pseudo->type == PSEUDO_VAL || pseudo->type == PSEUDO_SYM;
+}
+
+static int simplify_associative_binop(struct instruction *insn)
+{
+	struct instruction *def;
+	pseudo_t pseudo = insn->src1;
+
+	if (!simple_pseudo(insn->src2))
+		return 0;
+	if (pseudo->type != PSEUDO_REG)
+		return 0;
+	def = pseudo->def;
+	if (def == insn)
+		return 0;
+	if (def->opcode != insn->opcode)
+		return 0;
+	if (!simple_pseudo(def->src2))
+		return 0;
+	if (ptr_list_size((struct ptr_list *)def->target->users) != 1)
+		return 0;
+	switch_pseudo(def, &def->src1, insn, &insn->src2);
+	return REPEAT_CSE;
+}
+
+static int simplify_constant_unop(struct instruction *insn)
+{
+	long long val = insn->src1->value;
+	long long res, mask;
+
+	switch (insn->opcode) {
+	case OP_NOT:
+		res = ~val;
+		break;
+	case OP_NEG:
+		res = -val;
+		break;
+	default:
+		return 0;
+	}
+	mask = 1ULL << (insn->size-1);
+	res &= mask | (mask-1);
+	
+	replace_with_pseudo(insn, value_pseudo(insn->type, res));
+	return REPEAT_CSE;
+}
+
+static int simplify_unop(struct instruction *insn)
+{
+	if (dead_insn(insn, &insn->src1, NULL, NULL))
+		return REPEAT_CSE;
+	if (constant(insn->src1))
+		return simplify_constant_unop(insn);
+
+	switch (insn->opcode) {
+		struct instruction *def;
+
+	case OP_NOT:
+		def = insn->src->def;
+		if (def && def->opcode == OP_NOT)
+			return replace_with_pseudo(insn, def->src);
+		break;
+	case OP_NEG:
+		def = insn->src->def;
+		if (def && def->opcode == OP_NEG)
+			return replace_with_pseudo(insn, def->src);
+		break;
+	default:
+		return 0;
+	}
+	return 0;
+}
+
+static int simplify_one_memop(struct instruction *insn, pseudo_t orig)
+{
+	pseudo_t addr = insn->src;
+	pseudo_t new, off;
+
+	if (addr->type == PSEUDO_REG) {
+		struct instruction *def = addr->def;
+		if (def->opcode == OP_SYMADDR && def->src) {
+			kill_use(&insn->src);
+			use_pseudo(insn, def->src, &insn->src);
+			return REPEAT_CSE | REPEAT_SYMBOL_CLEANUP;
+		}
+		if (def->opcode == OP_ADD) {
+			new = def->src1;
+			off = def->src2;
+			if (constant(off))
+				goto offset;
+			new = off;
+			off = def->src1;
+			if (constant(off))
+				goto offset;
+			return 0;
+		}
+	}
+	return 0;
+
+offset:
+	/* Invalid code */
+	if (new == orig) {
+		if (new == VOID)
+			return 0;
+		/*
+		 * If some BB have been removed it is possible that this
+		 * memop is in fact part of a dead BB. In this case
+		 * we must not warn since nothing is wrong.
+		 * If not part of a dead BB this will be redone after
+		 * the BBs have been cleaned up.
+		 */
+		if (repeat_phase & REPEAT_CFG_CLEANUP)
+			return 0;
+		new = VOID;
+		warning(insn->pos, "crazy programmer");
+	}
+	insn->offset += off->value;
+	use_pseudo(insn, new, &insn->src);
+	remove_usage(addr, &insn->src);
+	return REPEAT_CSE | REPEAT_SYMBOL_CLEANUP;
+}
+
+/*
+ * We walk the whole chain of adds/subs backwards. That's not
+ * only more efficient, but it allows us to find loops.
+ */
+static int simplify_memop(struct instruction *insn)
+{
+	int one, ret = 0;
+	pseudo_t orig = insn->src;
+
+	do {
+		one = simplify_one_memop(insn, orig);
+		ret |= one;
+	} while (one);
+	return ret;
+}
+
+static long long get_cast_value(long long val, int old_size, int new_size, int sign)
+{
+	long long mask;
+
+	if (sign && new_size > old_size) {
+		mask = 1 << (old_size-1);
+		if (val & mask)
+			val |= ~(mask | (mask-1));
+	}
+	mask = 1 << (new_size-1);
+	return val & (mask | (mask-1));
+}
+
+static int simplify_cast(struct instruction *insn)
+{
+	struct symbol *orig_type;
+	int orig_size, size;
+	pseudo_t src;
+
+	if (dead_insn(insn, &insn->src, NULL, NULL))
+		return REPEAT_CSE;
+
+	orig_type = insn->orig_type;
+	if (!orig_type)
+		return 0;
+
+	/* Keep casts with pointer on either side (not only case of OP_PTRCAST) */
+	if (is_ptr_type(orig_type) || is_ptr_type(insn->type))
+		return 0;
+
+	orig_size = orig_type->bit_size;
+	size = insn->size;
+	src = insn->src;
+
+	/* A cast of a constant? */
+	if (constant(src)) {
+		int sign = orig_type->ctype.modifiers & MOD_SIGNED;
+		long long val = get_cast_value(src->value, orig_size, size, sign);
+		src = value_pseudo(orig_type, val);
+		goto simplify;
+	}
+
+	/* A cast of a "and" might be a no-op.. */
+	if (src->type == PSEUDO_REG) {
+		struct instruction *def = src->def;
+		if (def->opcode == OP_AND && def->size >= size) {
+			pseudo_t val = def->src2;
+			if (val->type == PSEUDO_VAL) {
+				unsigned long long value = val->value;
+				if (!(value >> (size-1)))
+					goto simplify;
+			}
+		}
+	}
+
+	if (size == orig_size) {
+		int op = (orig_type->ctype.modifiers & MOD_SIGNED) ? OP_SCAST : OP_CAST;
+		if (insn->opcode == op)
+			goto simplify;
+		if (insn->opcode == OP_FPCAST && is_float_type(orig_type))
+			goto simplify;
+	}
+
+	return 0;
+
+simplify:
+	return replace_with_pseudo(insn, src);
+}
+
+static int simplify_select(struct instruction *insn)
+{
+	pseudo_t cond, src1, src2;
+
+	if (dead_insn(insn, &insn->src1, &insn->src2, &insn->src3))
+		return REPEAT_CSE;
+
+	cond = insn->src1;
+	src1 = insn->src2;
+	src2 = insn->src3;
+	if (constant(cond) || src1 == src2) {
+		pseudo_t *kill, take;
+		kill_use(&insn->src1);
+		take = cond->value ? src1 : src2;
+		kill = cond->value ? &insn->src3 : &insn->src2;
+		kill_use(kill);
+		replace_with_pseudo(insn, take);
+		return REPEAT_CSE;
+	}
+	if (constant(src1) && constant(src2)) {
+		long long val1 = src1->value;
+		long long val2 = src2->value;
+
+		/* The pair 0/1 is special - replace with SETNE/SETEQ */
+		if ((val1 | val2) == 1) {
+			int opcode = OP_SET_EQ;
+			if (val1) {
+				src1 = src2;
+				opcode = OP_SET_NE;
+			}
+			insn->opcode = opcode;
+			/* insn->src1 is already cond */
+			insn->src2 = src1; /* Zero */
+			return REPEAT_CSE;
+		}
+	}
+	return 0;
+}
+
+static int is_in_range(pseudo_t src, long long low, long long high)
+{
+	long long value;
+
+	switch (src->type) {
+	case PSEUDO_VAL:
+		value = src->value;
+		return value >= low && value <= high;
+	default:
+		return 0;
+	}
+}
+
+static int simplify_range(struct instruction *insn)
+{
+	pseudo_t src1, src2, src3;
+
+	src1 = insn->src1;
+	src2 = insn->src2;
+	src3 = insn->src3;
+	if (src2->type != PSEUDO_VAL || src3->type != PSEUDO_VAL)
+		return 0;
+	if (is_in_range(src1, src2->value, src3->value)) {
+		kill_instruction(insn);
+		return REPEAT_CSE;
+	}
+	return 0;
+}
+
+/*
+ * Simplify "set_ne/eq $0 + br"
+ */
+static int simplify_cond_branch(struct instruction *br, pseudo_t cond, struct instruction *def, pseudo_t *pp)
+{
+	use_pseudo(br, *pp, &br->cond);
+	remove_usage(cond, &br->cond);
+	if (def->opcode == OP_SET_EQ) {
+		struct basic_block *true = br->bb_true;
+		struct basic_block *false = br->bb_false;
+		br->bb_false = true;
+		br->bb_true = false;
+	}
+	return REPEAT_CSE;
+}
+
+static int simplify_branch(struct instruction *insn)
+{
+	pseudo_t cond = insn->cond;
+
+	/* Constant conditional */
+	if (constant(cond)) {
+		insert_branch(insn->bb, insn, cond->value ? insn->bb_true : insn->bb_false);
+		return REPEAT_CSE;
+	}
+
+	/* Same target? */
+	if (insn->bb_true == insn->bb_false) {
+		struct basic_block *bb = insn->bb;
+		struct basic_block *target = insn->bb_false;
+		remove_bb_from_list(&target->parents, bb, 1);
+		remove_bb_from_list(&bb->children, target, 1);
+		insn->bb_false = NULL;
+		kill_use(&insn->cond);
+		insn->cond = NULL;
+		insn->opcode = OP_BR;
+		return REPEAT_CSE;
+	}
+
+	/* Conditional on a SETNE $0 or SETEQ $0 */
+	if (cond->type == PSEUDO_REG) {
+		struct instruction *def = cond->def;
+
+		if (def->opcode == OP_SET_NE || def->opcode == OP_SET_EQ) {
+			if (constant(def->src1) && !def->src1->value)
+				return simplify_cond_branch(insn, cond, def, &def->src2);
+			if (constant(def->src2) && !def->src2->value)
+				return simplify_cond_branch(insn, cond, def, &def->src1);
+		}
+		if (def->opcode == OP_SEL) {
+			if (constant(def->src2) && constant(def->src3)) {
+				long long val1 = def->src2->value;
+				long long val2 = def->src3->value;
+				if (!val1 && !val2) {
+					insert_branch(insn->bb, insn, insn->bb_false);
+					return REPEAT_CSE;
+				}
+				if (val1 && val2) {
+					insert_branch(insn->bb, insn, insn->bb_true);
+					return REPEAT_CSE;
+				}
+				if (val2) {
+					struct basic_block *true = insn->bb_true;
+					struct basic_block *false = insn->bb_false;
+					insn->bb_false = true;
+					insn->bb_true = false;
+				}
+				use_pseudo(insn, def->src1, &insn->cond);
+				remove_usage(cond, &insn->cond);
+				return REPEAT_CSE;
+			}
+		}
+		if (def->opcode == OP_CAST || def->opcode == OP_SCAST) {
+			int orig_size = def->orig_type ? def->orig_type->bit_size : 0;
+			if (def->size > orig_size) {
+				use_pseudo(insn, def->src, &insn->cond);
+				remove_usage(cond, &insn->cond);
+				return REPEAT_CSE;
+			}
+		}
+	}
+	return 0;
+}
+
+static int simplify_switch(struct instruction *insn)
+{
+	pseudo_t cond = insn->cond;
+	long long val;
+	struct multijmp *jmp;
+
+	if (!constant(cond))
+		return 0;
+	val = insn->cond->value;
+
+	FOR_EACH_PTR(insn->multijmp_list, jmp) {
+		/* Default case */
+		if (jmp->begin > jmp->end)
+			goto found;
+		if (val >= jmp->begin && val <= jmp->end)
+			goto found;
+	} END_FOR_EACH_PTR(jmp);
+	warning(insn->pos, "Impossible case statement");
+	return 0;
+
+found:
+	insert_branch(insn->bb, insn, jmp->target);
+	return REPEAT_CSE;
+}
+
+int simplify_instruction(struct instruction *insn)
+{
+	if (!insn->bb)
+		return 0;
+	switch (insn->opcode) {
+	case OP_ADD: case OP_MULS:
+	case OP_AND: case OP_OR: case OP_XOR:
+	case OP_AND_BOOL: case OP_OR_BOOL:
+		if (simplify_binop(insn))
+			return REPEAT_CSE;
+		if (simplify_commutative_binop(insn))
+			return REPEAT_CSE;
+		return simplify_associative_binop(insn);
+
+	case OP_MULU:
+	case OP_SET_EQ: case OP_SET_NE:
+		if (simplify_binop(insn))
+			return REPEAT_CSE;
+		return simplify_commutative_binop(insn);
+
+	case OP_SUB:
+	case OP_DIVU: case OP_DIVS:
+	case OP_MODU: case OP_MODS:
+	case OP_SHL:
+	case OP_LSR: case OP_ASR:
+	case OP_SET_LE: case OP_SET_GE:
+	case OP_SET_LT: case OP_SET_GT:
+	case OP_SET_B:  case OP_SET_A:
+	case OP_SET_BE: case OP_SET_AE:
+		return simplify_binop(insn);
+
+	case OP_NOT: case OP_NEG:
+		return simplify_unop(insn);
+	case OP_LOAD: case OP_STORE:
+		return simplify_memop(insn);
+	case OP_SYMADDR:
+		if (dead_insn(insn, NULL, NULL, NULL))
+			return REPEAT_CSE | REPEAT_SYMBOL_CLEANUP;
+		return replace_with_pseudo(insn, insn->symbol);
+	case OP_CAST:
+	case OP_SCAST:
+	case OP_FPCAST:
+	case OP_PTRCAST:
+		return simplify_cast(insn);
+	case OP_PHI:
+		if (dead_insn(insn, NULL, NULL, NULL)) {
+			kill_use_list(insn->phi_list);
+			return REPEAT_CSE;
+		}
+		return clean_up_phi(insn);
+	case OP_PHISOURCE:
+		if (dead_insn(insn, &insn->phi_src, NULL, NULL))
+			return REPEAT_CSE;
+		break;
+	case OP_SEL:
+		return simplify_select(insn);
+	case OP_CBR:
+		return simplify_branch(insn);
+	case OP_SWITCH:
+		return simplify_switch(insn);
+	case OP_RANGE:
+		return simplify_range(insn);
+	}
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/smatch.c b/usr/src/tools/smatch/src/smatch.c
new file mode 100644
index 0000000000..0675284796
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch.c
@@ -0,0 +1,359 @@
+/*
+ * Copyright (C) 2006 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <libgen.h>
+#include "smatch.h"
+#include "check_list.h"
+
+char *option_debug_check = (char *)"";
+char *option_project_str = (char *)"smatch_generic";
+static char *option_db_file = (char *)"smatch_db.sqlite";
+enum project_type option_project = PROJ_NONE;
+char *bin_dir;
+char *data_dir;
+int option_no_data = 0;
+int option_spammy = 0;
+int option_info = 0;
+int option_full_path = 0;
+int option_param_mapper = 0;
+int option_call_tree = 0;
+int option_no_db = 0;
+int option_enable = 0;
+int option_disable = 0;
+int option_debug_related;
+int option_file_output;
+int option_time;
+int option_mem;
+char *option_datadir_str;
+int option_fatal_checks;
+int option_succeed;
+
+FILE *sm_outfd;
+FILE *sql_outfd;
+FILE *caller_info_fd;
+
+int sm_nr_errors;
+int sm_nr_checks;
+
+bool __silence_warnings_for_stmt;
+
+const char *progname;
+
+typedef void (*reg_func) (int id);
+#define CK(_x) {.name = #_x, .func = &_x, .enabled = 0},
+static struct reg_func_info {
+	const char *name;
+	reg_func func;
+	int enabled;
+} reg_funcs[] = {
+	{NULL, NULL},
+#include "check_list.h"
+};
+#undef CK
+int num_checks = ARRAY_SIZE(reg_funcs) - 1;
+
+const char *check_name(unsigned short id)
+{
+	if (id >= ARRAY_SIZE(reg_funcs))
+		return "internal";
+
+	return reg_funcs[id].name;
+}
+
+int id_from_name(const char *name)
+{
+	int i;
+
+	for (i = 1; i < ARRAY_SIZE(reg_funcs); i++) {
+		if (!strcmp(name, reg_funcs[i].name))
+			return i;
+	}
+	return 0;
+}
+
+static void show_checks(void)
+{
+	int i;
+
+	for (i = 1; i < ARRAY_SIZE(reg_funcs); i++) {
+		if (!strncmp(reg_funcs[i].name, "check_", 6))
+			printf("%3d. %s\n", i, reg_funcs[i].name);
+	}
+	exit(0);
+}
+
+static void enable_disable_checks(char *s, bool enable)
+{
+	char buf[128];
+	char *next;
+	int i;
+
+	do {
+		next = strchr(s, ',');
+		if (next) {
+			*next = '\0';
+			next++;
+		}
+		if (*s == '\0')
+			return;
+		if (strncmp(s, "check_", 6) == 0)
+			snprintf(buf, sizeof(buf), "%s", s);
+		else
+			snprintf(buf, sizeof(buf), "check_%s", s);
+
+
+		for (i = 1; i < ARRAY_SIZE(reg_funcs); i++) {
+			if (strcmp(reg_funcs[i].name, buf) == 0) {
+				reg_funcs[i].enabled = (enable == true) ? 1 : -1;
+				break;
+			}
+		}
+
+		if (i == ARRAY_SIZE(reg_funcs))
+			sm_fatal("'%s' not found", s);
+
+	} while ((s = next));
+}
+
+static void help(void)
+{
+	printf("Usage:  smatch [smatch arguments][sparse arguments] file.c\n");
+	printf("--project=<name> or -p=<name>: project specific tests\n");
+	printf("--succeed: don't exit with an error\n");
+	printf("--spammy:  print superfluous crap.\n");
+	printf("--info:  print info used to fill smatch_data/.\n");
+	printf("--debug:  print lots of debug output.\n");
+	printf("--param-mapper:  enable param_mapper output.\n");
+	printf("--no-data:  do not use the /smatch_data/ directory.\n");
+	printf("--data=<dir>: overwrite path to default smatch data directory.\n");
+	printf("--full-path:  print the full pathname.\n");
+	printf("--debug-implied:  print debug output about implications.\n");
+	printf("--assume-loops:  assume loops always go through at least once.\n");
+	printf("--two-passes:  use a two pass system for each function.\n");
+	printf("--file-output:  instead of printing stdout, print to \"file.c.smatch_out\".\n");
+	printf("--fatal-checks: check output is treated as an error.\n");
+	printf("--help:  print this helpful message.\n");
+	exit(1);
+}
+
+static int match_option(const char *arg, const char *option)
+{
+	char *str;
+	char *tmp;
+	int ret = 0;
+
+	str = malloc(strlen(option) + 3);
+	snprintf(str, strlen(option) + 3, "--%s", option);
+	tmp = str;
+	while (*tmp) {
+		if (*tmp == '_')
+			*tmp = '-';
+		tmp++;
+	}
+	if (!strcmp(arg, str))
+		ret = 1;
+	free(str);
+	return ret;
+}
+
+#define OPTION(_x) do {					\
+	if (match_option((*argvp)[1], #_x)) { 		\
+		option_##_x = 1;			\
+	}                                               \
+} while (0)
+
+void parse_args(int *argcp, char ***argvp)
+{
+	int i;
+
+	for (i = 1 ; i < *argcp; i++) {
+		if (!strcmp((*argvp)[i], "--help"))
+			help();
+
+		if (!strcmp((*argvp)[i], "--show-checks"))
+			show_checks();
+
+		if (!strncmp((*argvp)[i], "--project=", 10))
+			option_project_str = (*argvp)[i] + 10;
+
+		if (!strncmp((*argvp)[i], "-p=", 3))
+			option_project_str = (*argvp)[i] + 3;
+
+		if (!strncmp((*argvp)[i], "--db-file=", 10))
+			option_db_file = (*argvp)[i] + 10;
+
+		if (!strncmp((*argvp)[i], "--data=", 7))
+			option_datadir_str = (*argvp)[i] + 7;
+
+		if (!strncmp((*argvp)[i], "--debug=", 8))
+			option_debug_check = (*argvp)[i] + 8;
+
+		if (strncmp((*argvp)[i], "--trace=", 8) == 0)
+			trace_variable = (*argvp)[i] + 8;
+
+		if (strncmp((*argvp)[i], "--enable=", 9) == 0) {
+			enable_disable_checks((*argvp)[i] + 9, 1);
+			option_enable = 1;
+		}
+
+		if (strncmp((*argvp)[i], "--disable=", 10) == 0) {
+			enable_disable_checks((*argvp)[i] + 10, 0);
+			option_enable = 1;
+			option_disable = 1;
+		}
+
+		OPTION(fatal_checks);
+		OPTION(spammy);
+		OPTION(info);
+		OPTION(debug);
+		OPTION(debug_implied);
+		OPTION(debug_related);
+		OPTION(assume_loops);
+		OPTION(no_data);
+		OPTION(two_passes);
+		OPTION(full_path);
+		OPTION(param_mapper);
+		OPTION(call_tree);
+		OPTION(file_output);
+		OPTION(time);
+		OPTION(mem);
+		OPTION(no_db);
+		OPTION(succeed);
+	}
+
+	if (strcmp(option_project_str, "smatch_generic") != 0)
+		option_project = PROJ_UNKNOWN;
+
+	if (strcmp(option_project_str, "kernel") == 0)
+		option_project = PROJ_KERNEL;
+	else if (strcmp(option_project_str, "wine") == 0)
+		option_project = PROJ_WINE;
+	else if (strcmp(option_project_str, "illumos_kernel") == 0)
+		option_project = PROJ_ILLUMOS_KERNEL;
+	else if (strcmp(option_project_str, "illumos_user") == 0)
+		option_project = PROJ_ILLUMOS_USER;
+}
+
+static char *read_bin_filename(void)
+{
+	char filename[PATH_MAX] = {};
+	char proc[PATH_MAX];
+
+	pid_t pid = getpid();
+	sprintf(proc, "/proc/%d/exe", pid);
+	if (readlink(proc, filename, PATH_MAX) < 0)
+		return NULL;
+	return alloc_string(filename);
+}
+
+static char *get_bin_dir(char *arg0)
+{
+	char *orig;
+
+	orig = read_bin_filename();
+	if (!orig)
+		orig = alloc_string(arg0);
+	return dirname(orig);
+}
+
+static char *get_data_dir(char *arg0)
+{
+	char buf[256];
+	char *dir;
+
+	if (option_no_data)
+		return NULL;
+
+	if (option_datadir_str) {
+		if (access(option_datadir_str, R_OK))
+			sm_warning("%s is not accessible -- ignored.",
+					option_datadir_str);
+		else
+			return alloc_string(option_datadir_str);
+	}
+
+	strncpy(buf, "smatch_data/", sizeof(buf));
+	dir = alloc_string(buf);
+	if (!access(dir, R_OK))
+		return dir;
+
+	strncpy(buf, bin_dir, 254);
+
+	buf[255] = '\0';
+	strncat(buf, "/smatch_data/", 254 - strlen(buf));
+	dir = alloc_string(buf);
+	if (!access(dir, R_OK))
+		return dir;
+	free_string(dir);
+	snprintf(buf, 254, "%s/smatch_data/", SMATCHDATADIR);
+	dir = alloc_string(buf);
+	if (!access(dir, R_OK))
+		return dir;
+
+	sm_warning("%s is not accessible.", dir);
+	sm_warning("Use --no-data or --data to suppress this message.");
+	return NULL;
+}
+
+int main(int argc, char **argv)
+{
+	int i;
+	reg_func func;
+
+	sm_outfd = stdout;
+	sql_outfd = stdout;
+	caller_info_fd = stdout;
+
+	progname = argv[0];
+
+	parse_args(&argc, &argv);
+
+	if (argc < 2)
+		help();
+
+	/* this gets set back to zero when we parse the first function */
+	final_pass = 1;
+
+	bin_dir = get_bin_dir(argv[0]);
+	data_dir = get_data_dir(argv[0]);
+
+	allocate_hook_memory();
+	create_function_hook_hash();
+	open_smatch_db(option_db_file);
+	for (i = 1; i < ARRAY_SIZE(reg_funcs); i++) {
+		func = reg_funcs[i].func;
+		/* The script IDs start at 1.
+		   0 is used for internal stuff. */
+		if (!option_enable || reg_funcs[i].enabled == 1 ||
+		    (option_disable && reg_funcs[i].enabled != -1) ||
+		    strncmp(reg_funcs[i].name, "register_", 9) == 0)
+			func(i);
+	}
+
+	smatch(argc, argv);
+	free_string(data_dir);
+
+	if (option_succeed)
+		return 0;
+	if (sm_nr_errors > 0)
+		return 1;
+	if (sm_nr_checks > 0 && option_fatal_checks)
+		return 1;
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/smatch.h b/usr/src/tools/smatch/src/smatch.h
new file mode 100644
index 0000000000..b276ec125d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch.h
@@ -0,0 +1,1293 @@
+/*
+ * Copyright (C) 2006 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#ifndef   	SMATCH_H_
+# define   	SMATCH_H_
+
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <sys/time.h>
+#include <sqlite3.h>
+#include "lib.h"
+#include "allocate.h"
+#include "scope.h"
+#include "parse.h"
+#include "expression.h"
+#include "avl.h"
+
+typedef struct {
+	struct symbol *type;
+	union {
+		long long value;
+		unsigned long long uvalue;
+	};
+} sval_t;
+
+typedef long long mtag_t;
+
+struct smatch_state {
+	const char *name;
+	void *data;
+};
+#define STATE(_x) static struct smatch_state _x = { .name = #_x }
+extern struct smatch_state undefined;
+extern struct smatch_state ghost;
+extern struct smatch_state merged;
+extern struct smatch_state true_state;
+extern struct smatch_state false_state;
+DECLARE_ALLOCATOR(smatch_state);
+
+static inline void *INT_PTR(int i)
+{
+	return (void *)(long)i;
+}
+
+static inline int PTR_INT(void *p)
+{
+	return (int)(long)p;
+}
+
+struct tracker {
+	char *name;
+	struct symbol *sym;
+	unsigned short owner;
+};
+DECLARE_ALLOCATOR(tracker);
+DECLARE_PTR_LIST(tracker_list, struct tracker);
+DECLARE_PTR_LIST(stree_stack, struct stree);
+
+/* The first 3 struct members must match struct tracker */
+struct sm_state {
+	const char *name;
+	struct symbol *sym;
+	unsigned short owner;
+	unsigned short merged:1;
+	unsigned short skip_implications:1;
+	unsigned int nr_children;
+	unsigned int line;
+  	struct smatch_state *state;
+	struct stree *pool;
+	struct sm_state *left;
+	struct sm_state *right;
+	struct state_list *possible;
+};
+
+struct var_sym {
+	char *var;
+	struct symbol *sym;
+};
+DECLARE_ALLOCATOR(var_sym);
+DECLARE_PTR_LIST(var_sym_list, struct var_sym);
+
+struct constraint {
+	int op;
+	int id;
+};
+DECLARE_PTR_LIST(constraint_list, struct constraint);
+
+enum hook_type {
+	EXPR_HOOK,
+	STMT_HOOK,
+	STMT_HOOK_AFTER,
+	SYM_HOOK,
+	STRING_HOOK,
+	DECLARATION_HOOK,
+	ASSIGNMENT_HOOK,
+	ASSIGNMENT_HOOK_AFTER,
+	RAW_ASSIGNMENT_HOOK,
+	GLOBAL_ASSIGNMENT_HOOK,
+	LOGIC_HOOK,
+	CONDITION_HOOK,
+	PRELOOP_HOOK,
+	SELECT_HOOK,
+	WHOLE_CONDITION_HOOK,
+	FUNCTION_CALL_HOOK_BEFORE,
+	FUNCTION_CALL_HOOK,
+	CALL_HOOK_AFTER_INLINE,
+	FUNCTION_CALL_HOOK_AFTER_DB,
+	CALL_ASSIGNMENT_HOOK,
+	MACRO_ASSIGNMENT_HOOK,
+	BINOP_HOOK,
+	OP_HOOK,
+	DEREF_HOOK,
+	CASE_HOOK,
+	ASM_HOOK,
+	CAST_HOOK,
+	SIZEOF_HOOK,
+	BASE_HOOK,
+	FUNC_DEF_HOOK,
+	AFTER_DEF_HOOK,
+	END_FUNC_HOOK,
+	AFTER_FUNC_HOOK,
+	RETURN_HOOK,
+	INLINE_FN_START,
+	INLINE_FN_END,
+	END_FILE_HOOK,
+	NUM_HOOKS,
+};
+
+#define TRUE 1
+#define FALSE 0
+
+struct range_list;
+
+void add_hook(void *func, enum hook_type type);
+typedef struct smatch_state *(merge_func_t)(struct smatch_state *s1, struct smatch_state *s2);
+typedef struct smatch_state *(unmatched_func_t)(struct sm_state *state);
+void add_merge_hook(int client_id, merge_func_t *func);
+void add_unmatched_state_hook(int client_id, unmatched_func_t *func);
+void add_pre_merge_hook(int client_id, void (*hook)(struct sm_state *sm));
+typedef void (scope_hook)(void *data);
+void add_scope_hook(scope_hook *hook, void *data);
+typedef void (func_hook)(const char *fn, struct expression *expr, void *data);
+typedef void (implication_hook)(const char *fn, struct expression *call_expr,
+				struct expression *assign_expr, void *data);
+typedef void (return_implies_hook)(struct expression *call_expr,
+				   int param, char *key, char *value);
+typedef int (implied_return_hook)(struct expression *call_expr, void *info, struct range_list **rl);
+void add_function_hook(const char *look_for, func_hook *call_back, void *data);
+
+void add_function_assign_hook(const char *look_for, func_hook *call_back,
+			      void *info);
+void add_implied_return_hook(const char *look_for,
+			     implied_return_hook *call_back,
+			     void *info);
+void add_macro_assign_hook(const char *look_for, func_hook *call_back,
+			      void *info);
+void add_macro_assign_hook_extra(const char *look_for, func_hook *call_back,
+			      void *info);
+void return_implies_state(const char *look_for, long long start, long long end,
+			 implication_hook *call_back, void *info);
+void select_return_states_hook(int type, return_implies_hook *callback);
+void select_return_states_before(void (*fn)(void));
+void select_return_states_after(void (*fn)(void));
+int get_implied_return(struct expression *expr, struct range_list **rl);
+void allocate_hook_memory(void);
+
+struct modification_data {
+	struct smatch_state *prev;
+	struct expression *cur;
+};
+
+typedef void (modification_hook)(struct sm_state *sm, struct expression *mod_expr);
+void add_modification_hook(int owner, modification_hook *call_back);
+void add_modification_hook_late(int owner, modification_hook *call_back);
+struct smatch_state *get_modification_state(struct expression *expr);
+
+int outside_of_function(void);
+const char *get_filename(void);
+const char *get_base_file(void);
+char *get_function(void);
+int get_lineno(void);
+extern int final_pass;
+extern struct symbol *cur_func_sym;
+extern int option_debug;
+extern int local_debug;
+extern int option_info;
+extern int option_spammy;
+extern char *trace_variable;
+extern struct stree *global_states;
+int is_skipped_function(void);
+int is_silenced_function(void);
+
+/* smatch_impossible.c */
+int is_impossible_path(void);
+void set_path_impossible(void);
+
+extern FILE *sm_outfd;
+extern FILE *sql_outfd;
+extern FILE *caller_info_fd;
+extern int sm_nr_checks;
+extern int sm_nr_errors;
+extern const char *progname;
+
+/*
+ * How to use these routines:
+ *
+ * sm_fatal(): an internal error of some kind that should immediately exit
+ * sm_ierror(): an internal error
+ * sm_perror(): an internal error from parsing input source
+ * sm_error(): an error from input source
+ * sm_warning(): a warning from input source
+ * sm_info(): info message (from option_info)
+ * sm_debug(): debug message
+ * sm_msg(): other message (please avoid using this)
+ */
+
+#define sm_printf(msg...) do { if (final_pass || option_debug || local_debug) fprintf(sm_outfd, msg); } while (0)
+
+static inline void sm_prefix(void)
+{
+	sm_printf("%s: %s:%d %s() ", progname, get_filename(), get_lineno(), get_function());
+}
+
+static inline void print_implied_debug_msg();
+
+extern bool __silence_warnings_for_stmt;
+
+#define sm_print_msg(type, msg...) \
+do {                                                           \
+	print_implied_debug_msg();                             \
+	if (!final_pass && !option_debug && !local_debug)      \
+		break;                                         \
+	if (__silence_warnings_for_stmt && !option_debug && !local_debug) \
+		break;					       \
+	if (!option_info && is_silenced_function())	       \
+		break;					       \
+	sm_prefix();					       \
+	if (type == 1) {				       \
+		sm_printf("warn: ");			       \
+		sm_nr_checks++;			    	       \
+	} else if (type == 2) {				       \
+		sm_printf("error: ");			       \
+		sm_nr_checks++;				       \
+	} else if (type == 3) {				       \
+		sm_printf("parse error: ");		       \
+		sm_nr_errors++;				       \
+	}						       \
+        sm_printf(msg);                                        \
+        sm_printf("\n");                                       \
+} while (0)
+
+#define sm_msg(msg...) do { sm_print_msg(0, msg); } while (0)
+
+#define local_debug(msg...)					\
+do {								\
+	if (local_debug)					\
+		sm_msg(msg);					\
+} while (0)
+
+extern char *implied_debug_msg;
+static inline void print_implied_debug_msg(void)
+{
+	static struct symbol *last_printed = NULL;
+
+	if (!implied_debug_msg)
+		return;
+	if (last_printed == cur_func_sym)
+		return;
+	last_printed = cur_func_sym;
+	sm_msg("%s", implied_debug_msg);
+}
+
+#define sm_debug(msg...) do { if (option_debug) sm_printf(msg); } while (0)
+
+#define sm_info(msg...) do {					\
+	if (option_debug || (option_info && final_pass)) {	\
+		sm_prefix();					\
+		sm_printf("info: ");				\
+		sm_printf(msg);					\
+		sm_printf("\n");				\
+	}							\
+} while(0)
+
+#define sm_warning(msg...) do { sm_print_msg(1, msg); } while (0)
+#define sm_error(msg...) do { sm_print_msg(2, msg); } while (0)
+#define sm_perror(msg...) do { sm_print_msg(3, msg); } while (0)
+
+static inline void sm_fatal(const char *fmt, ...)
+{
+	va_list args;
+
+	va_start(args, fmt);
+	vfprintf(sm_outfd, fmt, args);
+	va_end(args);
+
+	fprintf(sm_outfd, "\n");
+
+	exit(1);
+}
+
+static inline void sm_ierror(const char *fmt, ...)
+{
+	va_list args;
+
+	sm_nr_errors++;
+
+	fprintf(sm_outfd, "internal error: ");
+
+	va_start(args, fmt);
+	vfprintf(sm_outfd, fmt, args);
+	va_end(args);
+
+	fprintf(sm_outfd, "\n");
+}
+#define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
+
+struct smatch_state *__get_state(int owner, const char *name, struct symbol *sym);
+struct smatch_state *get_state(int owner, const char *name, struct symbol *sym);
+struct smatch_state *get_state_expr(int owner, struct expression *expr);
+struct state_list *get_possible_states(int owner, const char *name,
+				       struct symbol *sym);
+struct state_list *get_possible_states_expr(int owner, struct expression *expr);
+struct sm_state *set_state(int owner, const char *name, struct symbol *sym,
+	       struct smatch_state *state);
+struct sm_state *set_state_expr(int owner, struct expression *expr,
+		struct smatch_state *state);
+void delete_state(int owner, const char *name, struct symbol *sym);
+void delete_state_expr(int owner, struct expression *expr);
+void __delete_all_states_sym(struct symbol *sym);
+void set_true_false_states(int owner, const char *name, struct symbol *sym,
+			   struct smatch_state *true_state,
+			   struct smatch_state *false_state);
+void set_true_false_states_expr(int owner, struct expression *expr,
+			   struct smatch_state *true_state,
+			   struct smatch_state *false_state);
+
+struct stree *get_all_states_from_stree(int owner, struct stree *source);
+struct stree *get_all_states_stree(int id);
+struct stree *__get_cur_stree(void);
+int is_reachable(void);
+void add_get_state_hook(void (*fn)(int owner, const char *name, struct symbol *sym));
+
+/* smatch_helper.c */
+DECLARE_PTR_LIST(int_stack, int);
+char *alloc_string(const char *str);
+void free_string(char *str);
+void append(char *dest, const char *data, int buff_len);
+void remove_parens(char *str);
+struct smatch_state *alloc_state_num(int num);
+struct smatch_state *alloc_state_str(const char *name);
+struct smatch_state *alloc_state_expr(struct expression *expr);
+struct expression *get_argument_from_call_expr(struct expression_list *args,
+					       int num);
+
+char *expr_to_var(struct expression *expr);
+struct symbol *expr_to_sym(struct expression *expr);
+char *expr_to_str(struct expression *expr);
+char *expr_to_str_sym(struct expression *expr,
+				     struct symbol **sym_ptr);
+char *expr_to_var_sym(struct expression *expr,
+			     struct symbol **sym_ptr);
+char *expr_to_known_chunk_sym(struct expression *expr, struct symbol **sym);
+char *expr_to_chunk_sym_vsl(struct expression *expr, struct symbol **sym, struct var_sym_list **vsl);
+int get_complication_score(struct expression *expr);
+
+int sym_name_is(const char *name, struct expression *expr);
+int get_const_value(struct expression *expr, sval_t *sval);
+int get_value(struct expression *expr, sval_t *val);
+int get_implied_value(struct expression *expr, sval_t *val);
+int get_implied_min(struct expression *expr, sval_t *sval);
+int get_implied_max(struct expression *expr, sval_t *val);
+int get_hard_max(struct expression *expr, sval_t *sval);
+int get_fuzzy_min(struct expression *expr, sval_t *min);
+int get_fuzzy_max(struct expression *expr, sval_t *max);
+int get_absolute_min(struct expression *expr, sval_t *sval);
+int get_absolute_max(struct expression *expr, sval_t *sval);
+int parse_call_math(struct expression *expr, char *math, sval_t *val);
+int parse_call_math_rl(struct expression *call, char *math, struct range_list **rl);
+char *get_value_in_terms_of_parameter_math(struct expression *expr);
+char *get_value_in_terms_of_parameter_math_var_sym(const char *var, struct symbol *sym);
+int is_zero(struct expression *expr);
+int known_condition_true(struct expression *expr);
+int known_condition_false(struct expression *expr);
+int implied_condition_true(struct expression *expr);
+int implied_condition_false(struct expression *expr);
+int can_integer_overflow(struct symbol *type, struct expression *expr);
+void clear_math_cache(void);
+
+int is_array(struct expression *expr);
+struct expression *get_array_base(struct expression *expr);
+struct expression *get_array_offset(struct expression *expr);
+const char *show_state(struct smatch_state *state);
+struct statement *get_expression_statement(struct expression *expr);
+struct expression *strip_parens(struct expression *expr);
+struct expression *strip_expr(struct expression *expr);
+struct expression *strip_expr_set_parent(struct expression *expr);
+void scoped_state(int my_id, const char *name, struct symbol *sym);
+int is_error_return(struct expression *expr);
+int getting_address(void);
+int get_struct_and_member(struct expression *expr, const char **type, const char **member);
+char *get_member_name(struct expression *expr);
+char *get_fnptr_name(struct expression *expr);
+int cmp_pos(struct position pos1, struct position pos2);
+int positions_eq(struct position pos1, struct position pos2);
+struct statement *get_current_statement(void);
+struct statement *get_prev_statement(void);
+struct expression *get_last_expr_from_expression_stmt(struct expression *expr);
+int get_param_num_from_sym(struct symbol *sym);
+int get_param_num(struct expression *expr);
+int ms_since(struct timeval *start);
+int parent_is_gone_var_sym(const char *name, struct symbol *sym);
+int parent_is_gone(struct expression *expr);
+int invert_op(int op);
+int expr_equiv(struct expression *one, struct expression *two);
+void push_int(struct int_stack **stack, int num);
+int pop_int(struct int_stack **stack);
+
+/* smatch_type.c */
+struct symbol *get_real_base_type(struct symbol *sym);
+int type_bytes(struct symbol *type);
+int array_bytes(struct symbol *type);
+struct symbol *get_pointer_type(struct expression *expr);
+struct symbol *get_type(struct expression *expr);
+struct symbol *get_final_type(struct expression *expr);
+struct symbol *get_promoted_type(struct symbol *left, struct symbol *right);
+int type_signed(struct symbol *base_type);
+int expr_unsigned(struct expression *expr);
+int expr_signed(struct expression *expr);
+int returns_unsigned(struct symbol *base_type);
+int is_pointer(struct expression *expr);
+int returns_pointer(struct symbol *base_type);
+sval_t sval_type_max(struct symbol *base_type);
+sval_t sval_type_min(struct symbol *base_type);
+int nr_bits(struct expression *expr);
+int is_void_pointer(struct expression *expr);
+int is_char_pointer(struct expression *expr);
+int is_string(struct expression *expr);
+int is_static(struct expression *expr);
+int is_local_variable(struct expression *expr);
+int types_equiv(struct symbol *one, struct symbol *two);
+int fn_static(void);
+const char *global_static();
+struct symbol *cur_func_return_type(void);
+struct symbol *get_arg_type(struct expression *fn, int arg);
+struct symbol *get_member_type_from_key(struct expression *expr, const char *key);
+struct symbol *get_arg_type_from_key(struct expression *fn, int param, struct expression *arg, const char *key);
+int is_struct(struct expression *expr);
+char *type_to_str(struct symbol *type);
+
+/* smatch_ignore.c */
+void add_ignore(int owner, const char *name, struct symbol *sym);
+int is_ignored(int owner, const char *name, struct symbol *sym);
+void add_ignore_expr(int owner, struct expression *expr);
+int is_ignored_expr(int owner, struct expression *expr);
+
+/* smatch_var_sym */
+struct var_sym *alloc_var_sym(const char *var, struct symbol *sym);
+struct var_sym_list *expr_to_vsl(struct expression *expr);
+void add_var_sym(struct var_sym_list **list, const char *var, struct symbol *sym);
+void add_var_sym_expr(struct var_sym_list **list, struct expression *expr);
+void del_var_sym(struct var_sym_list **list, const char *var, struct symbol *sym);
+int in_var_sym_list(struct var_sym_list *list, const char *var, struct symbol *sym);
+struct var_sym_list *clone_var_sym_list(struct var_sym_list *from_vsl);
+void merge_var_sym_list(struct var_sym_list **dest, struct var_sym_list *src);
+struct var_sym_list *combine_var_sym_lists(struct var_sym_list *one, struct var_sym_list *two);
+int var_sym_lists_equiv(struct var_sym_list *one, struct var_sym_list *two);
+void free_var_sym_list(struct var_sym_list **list);
+void free_var_syms_and_list(struct var_sym_list **list);
+
+/* smatch_tracker */
+struct tracker *alloc_tracker(int owner, const char *name, struct symbol *sym);
+void add_tracker(struct tracker_list **list, int owner, const char *name,
+		struct symbol *sym);
+void add_tracker_expr(struct tracker_list **list, int owner, struct expression *expr);
+void del_tracker(struct tracker_list **list, int owner, const char *name,
+		struct symbol *sym);
+int in_tracker_list(struct tracker_list *list, int owner, const char *name,
+		struct symbol *sym);
+void free_tracker_list(struct tracker_list **list);
+void free_trackers_and_list(struct tracker_list **list);
+
+/* smatch_conditions */
+int in_condition(void);
+
+/* smatch_flow.c */
+
+extern int __in_fake_assign;
+extern int __in_fake_parameter_assign;
+extern int __in_fake_struct_assign;
+extern int in_fake_env;
+void smatch (int argc, char **argv);
+int inside_loop(void);
+int definitely_inside_loop(void);
+struct expression *get_switch_expr(void);
+int in_expression_statement(void);
+void __process_post_op_stack(void);
+void __split_expr(struct expression *expr);
+void __split_label_stmt(struct statement *stmt);
+void __split_stmt(struct statement *stmt);
+extern int __in_function_def;
+extern int option_assume_loops;
+extern int option_two_passes;
+extern int option_no_db;
+extern int option_file_output;
+extern int option_time;
+extern struct expression_list *big_expression_stack;
+extern struct expression_list *big_condition_stack;
+extern struct statement_list *big_statement_stack;
+int is_assigned_call(struct expression *expr);
+int inlinable(struct expression *expr);
+extern int __inline_call;
+extern struct expression *__inline_fn;
+extern int __in_pre_condition;
+extern int __bail_on_rest_of_function;
+extern struct statement *__prev_stmt;
+extern struct statement *__cur_stmt;
+extern struct statement *__next_stmt;
+void init_fake_env(void);
+void end_fake_env(void);
+int time_parsing_function(void);
+
+/* smatch_struct_assignment.c */
+struct expression *get_faked_expression(void);
+void __fake_struct_member_assignments(struct expression *expr);
+
+/* smatch_project.c */
+int is_no_inline_function(const char *function);
+
+/* smatch_conditions */
+void __split_whole_condition(struct expression *expr);
+void __handle_logic(struct expression *expr);
+int is_condition(struct expression *expr);
+int __handle_condition_assigns(struct expression *expr);
+int __handle_select_assigns(struct expression *expr);
+int __handle_expr_statement_assigns(struct expression *expr);
+
+/* smatch_implied.c */
+extern int option_debug_implied;
+extern int option_debug_related;
+struct range_list_stack;
+void param_limit_implications(struct expression *expr, int param, char *key, char *value);
+struct stree *__implied_case_stree(struct expression *switch_expr,
+				   struct range_list *case_rl,
+				   struct range_list_stack **remaining_cases,
+				   struct stree **raw_stree);
+void overwrite_states_using_pool(struct sm_state *gate_sm, struct sm_state *pool_sm);
+int assume(struct expression *expr);
+void end_assume(void);
+int impossible_assumption(struct expression *left, int op, sval_t sval);
+
+/* smatch_extras.c */
+#define SMATCH_EXTRA 5 /* this is my_id from smatch extra set in smatch.c */
+extern int RETURN_ID;
+
+struct data_range {
+	sval_t min;
+	sval_t max;
+};
+
+#define MTAG_ALIAS_BIT (1ULL << 63)
+#define MTAG_OFFSET_MASK 0xfffULL
+
+extern long long valid_ptr_min, valid_ptr_max;
+extern sval_t valid_ptr_min_sval, valid_ptr_max_sval;
+extern struct range_list *valid_ptr_rl;
+static const sval_t array_min_sval = {
+	.type = &ptr_ctype,
+	{.value = 100000},
+};
+static const sval_t array_max_sval = {
+	.type = &ptr_ctype,
+	{.value = 199999},
+};
+static const sval_t text_seg_min = {
+	.type = &ptr_ctype,
+	{.value = 100000000},
+};
+static const sval_t text_seg_max = {
+	.type = &ptr_ctype,
+	{.value = 177777777},
+};
+static const sval_t data_seg_min = {
+	.type = &ptr_ctype,
+	{.value = 200000000},
+};
+static const sval_t data_seg_max = {
+	.type = &ptr_ctype,
+	{.value = 277777777},
+};
+static const sval_t bss_seg_min = {
+	.type = &ptr_ctype,
+	{.value = 300000000},
+};
+static const sval_t bss_seg_max = {
+	.type = &ptr_ctype,
+	{.value = 377777777},
+};
+static const sval_t stack_seg_min = {
+	.type = &ptr_ctype,
+	{.value = 400000000},
+};
+static const sval_t stack_seg_max = {
+	.type = &ptr_ctype,
+	{.value = 477777777},
+};
+static const sval_t kmalloc_seg_min = {
+	.type = &ptr_ctype,
+	{.value = 500000000},
+};
+static const sval_t kmalloc_seg_max = {
+	.type = &ptr_ctype,
+	{.value = 577777777},
+};
+static const sval_t vmalloc_seg_min = {
+	.type = &ptr_ctype,
+	{.value = 600000000},
+};
+static const sval_t vmalloc_seg_max = {
+	.type = &ptr_ctype,
+	{.value = 677777777},
+};
+static const sval_t fn_ptr_min = {
+	.type = &ptr_ctype,
+	{.value = 700000000},
+};
+static const sval_t fn_ptr_max = {
+	.type = &ptr_ctype,
+	{.value = 777777777},
+};
+
+char *get_other_name_sym(const char *name, struct symbol *sym, struct symbol **new_sym);
+char *map_call_to_other_name_sym(const char *name, struct symbol *sym, struct symbol **new_sym);
+char *map_long_to_short_name_sym(const char *name, struct symbol *sym, struct symbol **new_sym);
+char *map_long_to_short_name_sym_nostack(const char *name, struct symbol *sym, struct symbol **new_sym);
+
+#define STRLEN_MAX_RET 1010101
+
+/* smatch_absolute.c */
+int get_absolute_min_helper(struct expression *expr, sval_t *sval);
+int get_absolute_max_helper(struct expression *expr, sval_t *sval);
+
+/* smatch_local_values.c */
+int get_local_rl(struct expression *expr, struct range_list **rl);
+int get_local_max_helper(struct expression *expr, sval_t *sval);
+int get_local_min_helper(struct expression *expr, sval_t *sval);
+
+/* smatch_type_value.c */
+int get_db_type_rl(struct expression *expr, struct range_list **rl);
+/* smatch_data_val.c */
+int get_mtag_rl(struct expression *expr, struct range_list **rl);
+/* smatch_array_values.c */
+int get_array_rl(struct expression *expr, struct range_list **rl);
+
+/* smatch_states.c */
+void __swap_cur_stree(struct stree *stree);
+void __push_fake_cur_stree();
+struct stree *__pop_fake_cur_stree();
+void __free_fake_cur_stree();
+void __set_fake_cur_stree_fast(struct stree *stree);
+void __pop_fake_cur_stree_fast(void);
+void __merge_stree_into_cur(struct stree *stree);
+
+int unreachable(void);
+void __set_sm(struct sm_state *sm);
+void __set_sm_cur_stree(struct sm_state *sm);
+void __set_sm_fake_stree(struct sm_state *sm);
+void __set_true_false_sm(struct sm_state *true_state,
+			struct sm_state *false_state);
+void nullify_path(void);
+void __match_nullify_path_hook(const char *fn, struct expression *expr,
+			       void *unused);
+void __unnullify_path(void);
+int __path_is_null(void);
+void save_all_states(void);
+void restore_all_states(void);
+void free_goto_stack(void);
+void clear_all_states(void);
+
+struct sm_state *get_sm_state(int owner, const char *name,
+				struct symbol *sym);
+struct sm_state *get_sm_state_expr(int owner, struct expression *expr);
+void __push_true_states(void);
+void __use_false_states(void);
+void __discard_false_states(void);
+void __merge_false_states(void);
+void __merge_true_states(void);
+
+void __negate_cond_stacks(void);
+void __use_pre_cond_states(void);
+void __use_cond_true_states(void);
+void __use_cond_false_states(void);
+void __push_cond_stacks(void);
+void __fold_in_set_states(void);
+void __free_set_states(void);
+struct stree *__copy_cond_true_states(void);
+struct stree *__copy_cond_false_states(void);
+struct stree *__pop_cond_true_stack(void);
+struct stree *__pop_cond_false_stack(void);
+void __and_cond_states(void);
+void __or_cond_states(void);
+void __save_pre_cond_states(void);
+void __discard_pre_cond_states(void);
+struct stree *__get_true_states(void);
+struct stree *__get_false_states(void);
+void __use_cond_states(void);
+extern struct state_list *__last_base_slist;
+
+void __push_continues(void);
+void __discard_continues(void);
+void __process_continues(void);
+void __merge_continues(void);
+
+void __push_breaks(void);
+void __process_breaks(void);
+int __has_breaks(void);
+void __merge_breaks(void);
+void __use_breaks(void);
+
+void __save_switch_states(struct expression *switch_expr);
+void __discard_switches(void);
+int have_remaining_cases(void);
+void __merge_switches(struct expression *switch_expr, struct range_list *case_rl);
+void __push_default(void);
+void __set_default(void);
+int __pop_default(void);
+
+void __push_conditions(void);
+void __discard_conditions(void);
+
+void __save_gotos(const char *name, struct symbol *sym);
+void __merge_gotos(const char *name, struct symbol *sym);
+
+void __print_cur_stree(void);
+
+/* smatch_hooks.c */
+void __pass_to_client(void *data, enum hook_type type);
+void __pass_to_client_no_data(enum hook_type type);
+void __pass_case_to_client(struct expression *switch_expr,
+			   struct range_list *rl);
+int __has_merge_function(int client_id);
+struct smatch_state *__client_merge_function(int owner,
+					     struct smatch_state *s1,
+					     struct smatch_state *s2);
+struct smatch_state *__client_unmatched_state_function(struct sm_state *sm);
+void call_pre_merge_hook(struct sm_state *sm);
+void __push_scope_hooks(void);
+void __call_scope_hooks(void);
+
+/* smatch_function_hooks.c */
+void create_function_hook_hash(void);
+void __match_initializer_call(struct symbol *sym);
+
+/* smatch_db.c */
+enum info_type {
+	INTERNAL	= 0,
+	/*
+	 * Changing these numbers is a pain.  Don't do it.  If you ever use a
+	 * number it can't be re-used right away so there may be gaps.
+	 * We select these in order by type so if the order matters, then give
+	 * it a number below 100-999,9000-9999 ranges. */
+
+	PARAM_CLEARED	= 101,
+	PARAM_LIMIT	= 103,
+	PARAM_FILTER	= 104,
+
+	PARAM_VALUE	= 1001,
+	BUF_SIZE	= 1002,
+	USER_DATA	= 1003,
+	CAPPED_DATA	= 1004,
+	RETURN_VALUE	= 1005,
+	DEREFERENCE	= 1006,
+	RANGE_CAP	= 1007,
+	LOCK_HELD	= 1008,
+	LOCK_RELEASED	= 1009,
+	ABSOLUTE_LIMITS	= 1010,
+	PARAM_ADD	= 1012,
+	PARAM_FREED	= 1013,
+	DATA_SOURCE	= 1014,
+	FUZZY_MAX	= 1015,
+	STR_LEN		= 1016,
+	ARRAY_LEN	= 1017,
+	CAPABLE		= 1018,
+	NS_CAPABLE	= 1019,
+	CONTAINER	= 1020,
+	CASTED_CALL	= 1021,
+	TYPE_LINK	= 1022,
+	UNTRACKED_PARAM = 1023,
+	CULL_PATH	= 1024,
+	PARAM_SET	= 1025,
+	PARAM_USED	= 1026,
+	BYTE_UNITS      = 1027,
+	COMPARE_LIMIT	= 1028,
+	PARAM_COMPARE	= 1029,
+	CONSTRAINT	= 1031,
+	PASSES_TYPE	= 1032,
+	CONSTRAINT_REQUIRED = 1033,
+	NOSPEC		= 1035,
+	NOSPEC_WB	= 1036,
+	STMT_CNT	= 1037,
+	TERMINATED	= 1038,
+
+	/* put random temporary stuff in the 7000-7999 range for testing */
+	USER_DATA3	= 8017,
+	USER_DATA3_SET	= 9017,
+	NO_OVERFLOW	= 8018,
+	NO_OVERFLOW_SIMPLE = 8019,
+	LOCKED		= 8020,
+	UNLOCKED	= 8021,
+	SET_FS		= 8022,
+	ATOMIC_INC	= 8023,
+	ATOMIC_DEC	= 8024,
+	NO_SIDE_EFFECT  = 8025,
+	FN_ARG_LINK	= 8028,
+	DATA_VALUE	= 8029,
+	ARRAYSIZE_ARG	= 8033,
+	SIZEOF_ARG	= 8034,
+	MEMORY_TAG	= 8036,
+	MTAG_ASSIGN	= 8035,
+	STRING_VALUE	= 8041,
+};
+
+extern struct sqlite3 *smatch_db;
+extern struct sqlite3 *mem_db;
+extern struct sqlite3 *cache_db;
+
+void db_ignore_states(int id);
+void select_caller_info_hook(void (*callback)(const char *name, struct symbol *sym, char *key, char *value), int type);
+void add_member_info_callback(int owner, void (*callback)(struct expression *call, int param, char *printed_name, struct sm_state *sm));
+void add_split_return_callback(void (*fn)(int return_id, char *return_ranges, struct expression *returned_expr));
+void add_returned_member_callback(int owner, void (*callback)(int return_id, char *return_ranges, struct expression *expr, char *printed_name, struct smatch_state *state));
+void select_call_implies_hook(int type, void (*callback)(struct expression *call, struct expression *arg, char *key, char *value));
+void select_return_implies_hook(int type, void (*callback)(struct expression *call, struct expression *arg, char *key, char *value));
+struct range_list *db_return_vals(struct expression *expr);
+struct range_list *db_return_vals_from_str(const char *fn_name);
+char *return_state_to_var_sym(struct expression *expr, int param, const char *key, struct symbol **sym);
+char *get_chunk_from_key(struct expression *arg, char *key, struct symbol **sym, struct var_sym_list **vsl);
+char *get_variable_from_key(struct expression *arg, const char *key, struct symbol **sym);
+const char *state_name_to_param_name(const char *state_name, const char *param_name);
+const char *get_param_name_var_sym(const char *name, struct symbol *sym);
+const char *get_param_name(struct sm_state *sm);
+const char *get_mtag_name_var_sym(const char *state_name, struct symbol *sym);
+const char *get_mtag_name_expr(struct expression *expr);
+char *get_data_info_name(struct expression *expr);
+
+char *escape_newlines(const char *str);
+void sql_exec(struct sqlite3 *db, int (*callback)(void*, int, char**, char**), void *data, const char *sql);
+
+#define sql_helper(db, call_back, data, sql...)					\
+do {										\
+	char sql_txt[1024];							\
+										\
+	sqlite3_snprintf(sizeof(sql_txt), sql_txt, sql);			\
+	sm_debug("debug: %s\n", sql_txt);					\
+	sql_exec(db, call_back, data, sql_txt);					\
+} while (0)
+
+
+#define run_sql(call_back, data, sql...)					\
+do {										\
+	if (option_no_db)							\
+		break;								\
+	sql_helper(smatch_db, call_back, data, sql);				\
+} while (0)
+
+#define mem_sql(call_back, data, sql...)					\
+	sql_helper(mem_db, call_back, data, sql)
+
+#define cache_sql(call_back, data, sql...)					\
+	sql_helper(cache_db, call_back, data, sql)
+
+#define sql_insert_helper(table, db, ignore, late, values...)			\
+do {										\
+	struct sqlite3 *_db = db;						\
+										\
+	if (__inline_fn && !_db)						\
+		_db = mem_db;							\
+	if (_db) {								\
+		char buf[1024];							\
+		char *err, *p = buf;						\
+		int rc;								\
+										\
+		p += snprintf(p, buf + sizeof(buf) - p,				\
+			      "insert %sinto %s values (",			\
+			      ignore ? "or ignore " : "", #table);		\
+		p += snprintf(p, buf + sizeof(buf) - p, values);		\
+		p += snprintf(p, buf + sizeof(buf) - p, ");");			\
+		sm_debug("mem-db: %s\n", buf);					\
+		rc = sqlite3_exec(_db, buf, NULL, NULL, &err);			\
+		if (rc != SQLITE_OK) {						\
+			sm_ierror("SQL error #2: %s", err);			\
+			sm_ierror("SQL: '%s'", buf);				\
+			parse_error = 1;					\
+		}								\
+		break;								\
+	}									\
+	if (option_info) {							\
+		FILE *tmp_fd = sm_outfd;					\
+		sm_outfd = sql_outfd;						\
+		sm_prefix();							\
+	        sm_printf("SQL%s: insert %sinto " #table " values(",		\
+			  late ? "_late" : "", ignore ? "or ignore " : "");	\
+	        sm_printf(values);						\
+	        sm_printf(");\n");						\
+		sm_outfd = tmp_fd;						\
+	}									\
+} while (0)
+
+#define sql_insert(table, values...) sql_insert_helper(table, 0, 0, 0, values);
+#define sql_insert_or_ignore(table, values...) sql_insert_helper(table, 0, 1, 0, values);
+#define sql_insert_late(table, values...) sql_insert_helper(table, 0, 0, 1, values);
+#define sql_insert_cache(table, values...) sql_insert_helper(table, cache_db, 1, 0, values);
+
+char *get_static_filter(struct symbol *sym);
+
+void sql_insert_return_states(int return_id, const char *return_ranges,
+		int type, int param, const char *key, const char *value);
+void sql_insert_caller_info(struct expression *call, int type, int param,
+		const char *key, const char *value);
+void sql_insert_function_ptr(const char *fn, const char *struct_name);
+void sql_insert_return_values(const char *return_values);
+void sql_insert_return_implies(int type, int param, const char *key, const char *value);
+void sql_insert_function_type_size(const char *member, const char *ranges);
+void sql_insert_function_type_info(int type, const char *struct_type, const char *member, const char *value);
+void sql_insert_type_info(int type, const char *member, const char *value);
+void sql_insert_local_values(const char *name, const char *value);
+void sql_insert_function_type_value(const char *type, const char *value);
+void sql_insert_function_type(int param, const char *value);
+void sql_insert_parameter_name(int param, const char *value);
+void sql_insert_data_info(struct expression *data, int type, const char *value);
+void sql_insert_data_info_var_sym(const char *var, struct symbol *sym, int type, const char *value);
+void sql_save_constraint(const char *con);
+void sql_save_constraint_required(const char *data, int op, const char *limit);
+void sql_copy_constraint_required(const char *new_limit, const char *old_limit);
+void sql_insert_fn_ptr_data_link(const char *ptr, const char *data);
+void sql_insert_fn_data_link(struct expression *fn, int type, int param, const char *key, const char *value);
+void sql_insert_mtag_about(mtag_t tag, const char *left_name, const char *right_name);
+void insert_mtag_data(sval_t sval, struct range_list *rl);
+void sql_insert_mtag_map(mtag_t tag, int offset, mtag_t container);
+void sql_insert_mtag_alias(mtag_t orig, mtag_t alias);
+int mtag_map_select_container(mtag_t tag, int offset, mtag_t *container);
+int mtag_map_select_tag(mtag_t container, int offset, mtag_t *tag);
+
+void sql_select_return_states(const char *cols, struct expression *call,
+	int (*callback)(void*, int, char**, char**), void *info);
+void sql_select_call_implies(const char *cols, struct expression *call,
+	int (*callback)(void*, int, char**, char**));
+
+void open_smatch_db(char *db_file);
+
+/* smatch_files.c */
+int open_data_file(const char *filename);
+int open_schema_file(const char *schema);
+struct token *get_tokens_file(const char *filename);
+
+/* smatch.c */
+extern char *option_debug_check;
+extern char *option_project_str;
+extern char *bin_dir;
+extern char *data_dir;
+extern int option_no_data;
+extern int option_full_path;
+extern int option_param_mapper;
+extern int option_call_tree;
+extern int num_checks;
+
+enum project_type {
+	PROJ_NONE,
+	PROJ_KERNEL,
+	PROJ_WINE,
+	PROJ_ILLUMOS_KERNEL,
+	PROJ_ILLUMOS_USER,
+	PROJ_UNKNOWN,
+};
+extern enum project_type option_project;
+const char *check_name(unsigned short id);
+int id_from_name(const char *name);
+
+
+/* smatch_buf_size.c */
+int get_array_size(struct expression *expr);
+int get_array_size_bytes(struct expression *expr);
+int get_array_size_bytes_min(struct expression *expr);
+int get_array_size_bytes_max(struct expression *expr);
+struct range_list *get_array_size_bytes_rl(struct expression *expr);
+int get_real_array_size(struct expression *expr);
+int last_member_is_resizable(struct symbol *type);
+/* smatch_strlen.c */
+int get_implied_strlen(struct expression *expr, struct range_list **rl);
+int get_size_from_strlen(struct expression *expr);
+
+/* smatch_capped.c */
+int is_capped(struct expression *expr);
+int is_capped_var_sym(const char *name, struct symbol *sym);
+
+/* check_user_data.c */
+int is_user_macro(struct expression *expr);
+int is_user_data(struct expression *expr);
+int is_capped_user_data(struct expression *expr);
+int implied_user_data(struct expression *expr, struct range_list **rl);
+struct stree *get_user_stree(void);
+int get_user_rl(struct expression *expr, struct range_list **rl);
+int get_user_rl_spammy(struct expression *expr, struct range_list **rl);
+int is_user_rl(struct expression *expr);
+int get_user_rl_var_sym(const char *name, struct symbol *sym, struct range_list **rl);
+
+/* check_locking.c */
+void print_held_locks();
+
+/* check_assigned_expr.c */
+struct expression *get_assigned_expr(struct expression *expr);
+struct expression *get_assigned_expr_name_sym(const char *name, struct symbol *sym);
+/* smatch_return_to_param.c */
+void __add_return_to_param_mapping(struct expression *assign, const char *return_string);
+char *map_call_to_param_name_sym(struct expression *expr, struct symbol **sym);
+
+/* smatch_comparison.c */
+struct compare_data {
+	/* The ->left and ->right expression pointers might be NULL (I'm lazy) */
+	struct expression *left;
+	const char *left_var;
+	struct var_sym_list *left_vsl;
+	int comparison;
+	struct expression *right;
+	const char *right_var;
+	struct var_sym_list *right_vsl;
+};
+DECLARE_ALLOCATOR(compare_data);
+struct smatch_state *alloc_compare_state(
+		struct expression *left,
+		const char *left_var, struct var_sym_list *left_vsl,
+		int comparison,
+		struct expression *right,
+		const char *right_var, struct var_sym_list *right_vsl);
+int filter_comparison(int orig, int op);
+int merge_comparisons(int one, int two);
+int combine_comparisons(int left_compare, int right_compare);
+int state_to_comparison(struct smatch_state *state);
+struct smatch_state *merge_compare_states(struct smatch_state *s1, struct smatch_state *s2);
+int get_comparison(struct expression *left, struct expression *right);
+int get_comparison_strings(const char *one, const char *two);
+int possible_comparison(struct expression *a, int comparison, struct expression *b);
+struct state_list *get_all_comparisons(struct expression *expr);
+struct state_list *get_all_possible_equal_comparisons(struct expression *expr);
+void __add_return_comparison(struct expression *call, const char *range);
+void __add_comparison_info(struct expression *expr, struct expression *call, const char *range);
+char *get_printed_param_name(struct expression *call, const char *param_name, struct symbol *param_sym);
+char *name_sym_to_param_comparison(const char *name, struct symbol *sym);
+char *expr_equal_to_param(struct expression *expr, int ignore);
+char *expr_lte_to_param(struct expression *expr, int ignore);
+char *expr_param_comparison(struct expression *expr, int ignore);
+int flip_comparison(int op);
+int negate_comparison(int op);
+int remove_unsigned_from_comparison(int op);
+int param_compare_limit_is_impossible(struct expression *expr, int left_param, char *left_key, char *value);
+void filter_by_comparison(struct range_list **rl, int comparison, struct range_list *right);
+struct sm_state *comparison_implication_hook(struct expression *expr,
+			struct state_list **true_stack,
+			struct state_list **false_stack);
+void __compare_param_limit_hook(struct expression *left_expr, struct expression *right_expr,
+				const char *state_name,
+				struct smatch_state *true_state, struct smatch_state *false_state);
+int impossibly_high_comparison(struct expression *expr);
+
+/* smatch_sval.c */
+sval_t *sval_alloc(sval_t sval);
+sval_t *sval_alloc_permanent(sval_t sval);
+sval_t sval_blank(struct expression *expr);
+sval_t sval_type_val(struct symbol *type, long long val);
+sval_t sval_from_val(struct expression *expr, long long val);
+int sval_is_ptr(sval_t sval);
+int sval_unsigned(sval_t sval);
+int sval_signed(sval_t sval);
+int sval_bits(sval_t sval);
+int sval_bits_used(sval_t sval);
+int sval_is_negative(sval_t sval);
+int sval_is_positive(sval_t sval);
+int sval_is_min(sval_t sval);
+int sval_is_max(sval_t sval);
+int sval_is_a_min(sval_t sval);
+int sval_is_a_max(sval_t sval);
+int sval_is_negative_min(sval_t sval);
+int sval_cmp_t(struct symbol *type, sval_t one, sval_t two);
+int sval_cmp_val(sval_t one, long long val);
+sval_t sval_min(sval_t one, sval_t two);
+sval_t sval_max(sval_t one, sval_t two);
+int sval_too_low(struct symbol *type, sval_t sval);
+int sval_too_high(struct symbol *type, sval_t sval);
+int sval_fits(struct symbol *type, sval_t sval);
+sval_t sval_cast(struct symbol *type, sval_t sval);
+sval_t sval_preop(sval_t sval, int op);
+sval_t sval_binop(sval_t left, int op, sval_t right);
+int sval_binop_overflows(sval_t left, int op, sval_t right);
+int sval_binop_overflows_no_sign(sval_t left, int op, sval_t right);
+unsigned long long fls_mask(unsigned long long uvalue);
+unsigned long long sval_fls_mask(sval_t sval);
+const char *sval_to_str(sval_t sval);
+const char *sval_to_numstr(sval_t sval);
+sval_t ll_to_sval(long long val);
+
+/* smatch_string_list.c */
+int list_has_string(struct string_list *str_list, const char *str);
+void insert_string(struct string_list **str_list, const char *str);
+struct string_list *clone_str_list(struct string_list *orig);
+struct string_list *combine_string_lists(struct string_list *one, struct string_list *two);
+
+/* smatch_start_states.c */
+struct stree *get_start_states(void);
+
+/* smatch_recurse.c */
+int has_symbol(struct expression *expr, struct symbol *sym);
+int has_variable(struct expression *expr, struct expression *var);
+int has_inc_dec(struct expression *expr);
+
+/* smatch_stored_conditions.c */
+struct smatch_state *get_stored_condition(struct expression *expr);
+struct expression_list *get_conditions(struct expression *expr);
+struct sm_state *stored_condition_implication_hook(struct expression *expr,
+			struct state_list **true_stack,
+			struct state_list **false_stack);
+
+/* check_string_len.c */
+int get_formatted_string_size(struct expression *call, int arg);
+
+/* smatch_param_set.c */
+int param_was_set(struct expression *expr);
+int param_was_set_var_sym(const char *name, struct symbol *sym);
+/* smatch_param_filter.c */
+int param_has_filter_data(struct sm_state *sm);
+
+/* smatch_links.c */
+void set_up_link_functions(int id, int linkid);
+struct smatch_state *merge_link_states(struct smatch_state *s1, struct smatch_state *s2);
+void store_link(int link_id, const char *name, struct symbol *sym, const char *link_name, struct symbol *link_sym);
+
+/* smatch_auto_copy.c */
+void set_auto_copy(int owner);
+
+/* check_buf_comparison */
+struct expression *get_size_variable(struct expression *buf);
+struct expression *get_array_variable(struct expression *size);
+
+/* smatch_untracked_param.c */
+void mark_untracked(struct expression *expr, int param, const char *key, const char *value);
+void add_untracked_param_hook(void (func)(struct expression *call, int param));
+void mark_all_params_untracked(int return_id, char *return_ranges, struct expression *expr);
+
+/* smatch_strings.c */
+struct state_list *get_strings(struct expression *expr);
+struct expression *fake_string_from_mtag(mtag_t tag);
+
+/* smatch_estate.c */
+int estate_get_single_value(struct smatch_state *state, sval_t *sval);
+
+/* smatch_address.c */
+int get_address_rl(struct expression *expr, struct range_list **rl);
+int get_member_offset(struct symbol *type, const char *member_name);
+int get_member_offset_from_deref(struct expression *expr);
+
+/* for now this is in smatch_used_parameter.c */
+void __get_state_hook(int owner, const char *name, struct symbol *sym);
+
+/* smatch_buf_comparison.c */
+int db_var_is_array_limit(struct expression *array, const char *name, struct var_sym_list *vsl);
+
+struct stree *get_all_return_states(void);
+struct stree_stack *get_all_return_strees(void);
+int on_atomic_dec_path(void);
+int was_inced(const char *name, struct symbol *sym);
+
+/* smatch_constraints.c */
+char *get_constraint_str(struct expression *expr);
+struct constraint_list *get_constraints(struct expression *expr);
+char *unmet_constraint(struct expression *data, struct expression *offset);
+char *get_required_constraint(const char *data_str);
+
+/* smatch_container_of.c */
+int get_param_from_container_of(struct expression *expr);
+int get_offset_from_container_of(struct expression *expr);
+
+/* smatch_mtag.c */
+int get_string_mtag(struct expression *expr, mtag_t *tag);
+int get_toplevel_mtag(struct symbol *sym, mtag_t *tag);
+int get_mtag(struct expression *expr, mtag_t *tag);
+int get_mtag_offset(struct expression *expr, mtag_t *tag, int *offset);
+int create_mtag_alias(mtag_t tag, struct expression *expr, mtag_t *new);
+int expr_to_mtag_offset(struct expression *expr, mtag_t *tag, int *offset);
+void update_mtag_data(struct expression *expr);
+int get_mtag_sval(struct expression *expr, sval_t *sval);
+int get_mtag_addr_sval(struct expression *expr, sval_t *sval);
+
+/* Trinity fuzzer stuff */
+const char *get_syscall_arg_type(struct symbol *sym);
+
+/* smatch_mem_tracker.c */
+extern int option_mem;
+unsigned long get_max_memory(void);
+
+/* check_is_nospec.c */
+bool is_nospec(struct expression *expr);
+
+/* smatch_nul_terminator.c */
+bool is_nul_terminated(struct expression *expr);
+
+static inline int type_bits(struct symbol *type)
+{
+	if (!type)
+		return 0;
+	if (type->type == SYM_PTR)  /* Sparse doesn't set this for &pointers */
+		return bits_in_pointer;
+	if (type->type == SYM_ARRAY)
+		return bits_in_pointer;
+	if (!type->examined)
+		examine_symbol_type(type);
+	return type->bit_size;
+}
+
+static inline bool type_is_ptr(struct symbol *type)
+{
+	return type && (type->type == SYM_PTR || type->type == SYM_ARRAY);
+}
+
+static inline int type_unsigned(struct symbol *base_type)
+{
+	if (!base_type)
+		return 0;
+	if (base_type->ctype.modifiers & MOD_UNSIGNED)
+		return 1;
+	return 0;
+}
+
+static inline int type_positive_bits(struct symbol *type)
+{
+	if (!type)
+		return 0;
+	if (type->type == SYM_ARRAY)
+		return bits_in_pointer - 1;
+	if (type_unsigned(type))
+		return type_bits(type);
+	return type_bits(type) - 1;
+}
+
+static inline int sval_positive_bits(sval_t sval)
+{
+	return type_positive_bits(sval.type);
+}
+
+/*
+ * Returns -1 if one is smaller, 0 if they are the same and 1 if two is larger.
+ */
+static inline int sval_cmp(sval_t one, sval_t two)
+{
+	struct symbol *type;
+
+	type = one.type;
+	if (sval_positive_bits(two) > sval_positive_bits(one))
+		type = two.type;
+	if (type_bits(type) < 31)
+		type = &int_ctype;
+
+	one = sval_cast(type, one);
+	two = sval_cast(type, two);
+
+	if (type_unsigned(type)) {
+		if (one.uvalue < two.uvalue)
+			return -1;
+		if (one.uvalue == two.uvalue)
+			return 0;
+		return 1;
+	}
+	/* fix me handle type promotion and unsigned values */
+	if (one.value < two.value)
+		return -1;
+	if (one.value == two.value)
+		return 0;
+	return 1;
+}
+
+#endif 	    /* !SMATCH_H_ */
diff --git a/usr/src/tools/smatch/src/smatch_about_fn_ptr_arg.c b/usr/src/tools/smatch/src/smatch_about_fn_ptr_arg.c
new file mode 100644
index 0000000000..347833f7d2
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_about_fn_ptr_arg.c
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Say you have assign a function to a function pointer and you assign a
+ * pointer to the data argument then we want to record some information about
+ * the argument.  Right now what I mainly want to record is the type of it, I
+ * guess.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+#include <ctype.h>
+
+static int my_id;
+
+static int assigns_parameters(struct expression *fn, struct expression *arg)
+{
+	int fn_param, arg_param;
+	char buf[32];
+
+	fn_param = get_param_num(fn);
+	if (fn_param < 0)
+		return 0;
+
+	arg_param = get_param_num(arg);
+	if (arg_param < 0)
+		return 0;
+
+	snprintf(buf, sizeof(buf), "%d", arg_param);
+	sql_insert_return_implies(FN_ARG_LINK, fn_param, "$", buf);
+	return 1;
+}
+
+static void link_function_arg(struct expression *fn, int param, struct expression *arg)
+{
+	struct symbol *type;
+
+	if (!fn || !arg)
+		return;
+	if (assigns_parameters(fn, arg))
+		return;
+
+	type = get_type(arg);
+	if (!type || type->type != SYM_PTR)
+		return;
+	type = get_real_base_type(type);
+	if (!type)
+		return;
+	// FIXME: param shouldn't always be 0?
+	sql_insert_fn_data_link(fn, PASSES_TYPE, param, "$", type_to_str(type));
+}
+
+char *next_param_name;
+struct symbol *next_param_sym;
+struct expression *next_fn;
+static void match_assign_param(struct expression *expr)
+{
+	struct symbol *sym;
+	char *name;
+
+	if (!next_param_name)
+		return;
+
+	name = expr_to_var_sym(expr->left, &sym);
+	if (!name || !sym) {
+		free_string(name);
+		return;
+	}
+
+	if (sym != next_param_sym ||
+	    strcmp(name, next_param_name) != 0)
+		return;
+
+	link_function_arg(next_fn, 0, strip_expr(expr->right));
+
+	next_param_name = 0;
+	next_param_sym = NULL;
+	next_fn = NULL;
+}
+
+static int get_arg_ptr(void *_arg_ptr, int argc, char **argv, char **azColName)
+{
+	char **arg_ptr = _arg_ptr;
+
+	*arg_ptr = NULL;
+	if (argc != 1)
+		return 0;
+	*arg_ptr = alloc_string(argv[0]);
+	return 0;
+}
+
+static char *get_data_member(char *fn_member, struct expression *expr, struct symbol **sym)
+{
+	struct symbol *tmp_sym;
+	char *fn_str;
+	char *arg_ptr = NULL;
+	char *end_type;
+	int len_ptr, len_str;
+	char buf[128];
+
+	*sym = NULL;
+	run_sql(get_arg_ptr, &arg_ptr,
+		"select data from fn_ptr_data_link where fn_ptr = '%s';", fn_member);
+	if (!arg_ptr)
+		return NULL;
+	end_type = strchr(arg_ptr, '>');
+	if (!end_type)
+		return NULL;
+	end_type++;
+	fn_str = expr_to_var_sym(expr, &tmp_sym);
+	if (!fn_str || !tmp_sym)
+		return NULL;
+	len_ptr = strlen(fn_member);
+	len_str = strlen(fn_str);
+	while (len_str > 0 && len_ptr > 0) {
+		if (fn_str[len_str - 1] != fn_member[len_ptr - 1])
+			break;
+		if (fn_str[len_str - 1] == '>')
+			break;
+		len_str--;
+		len_ptr--;
+	}
+
+	strncpy(buf, fn_str, sizeof(buf));
+	snprintf(buf + len_str, sizeof(buf) - len_str, end_type);
+	*sym = tmp_sym;
+	return alloc_string(buf);
+}
+
+static void match_assign_function(struct expression *expr)
+{
+	struct expression *right, *arg;
+	struct symbol *sym;
+	char *data_member;
+	struct symbol *type;
+	char *member_name;
+
+	right = strip_expr(expr->right);
+	if (right->type == EXPR_PREOP && right->op == '&')
+		right = strip_expr(right->unop);
+
+	type = get_type(right);
+	if (type && type->type == SYM_PTR)
+		type = get_real_base_type(type);
+	if (!type || type->type != SYM_FN)
+		return;
+
+	member_name = get_member_name(expr->left);
+	if (!member_name)
+		return;
+
+	data_member = get_data_member(member_name, expr->left, &sym);
+	if (!data_member || !sym) {
+		free_string(data_member);
+		data_member = NULL;
+	}
+
+	arg = get_assigned_expr_name_sym(data_member, sym);
+	if (arg) {
+		link_function_arg(right, 0, arg);
+	} else {
+		next_param_name = data_member;
+		next_param_sym = sym;
+		next_fn = right;
+	}
+}
+
+static int is_recursive_call(struct expression *call)
+{
+	if (call->fn->type != EXPR_SYMBOL)
+		return 0;
+	if (call->fn->symbol == cur_func_sym)
+		return 1;
+	return 0;
+}
+
+static void check_passes_fn_and_data(struct expression *call, struct expression *fn, char *key, char *value)
+{
+	struct expression *arg;
+	struct symbol *type;
+	int data_nr;
+
+	if (is_recursive_call(call))
+		return;
+
+	type = get_type(fn);
+	if (!type || type->type != SYM_FN)
+		return;
+
+	if (!isdigit(value[0]))
+		return;
+	data_nr = atoi(value);
+	arg = get_argument_from_call_expr(call->args, data_nr);
+	if (!arg)
+		return;
+	link_function_arg(fn, 0, arg);
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	next_param_sym = NULL;
+	next_fn = NULL;
+}
+
+void register_about_fn_ptr_arg(int id)
+{
+	my_id = id;
+
+	if (0 && !option_info)
+		return;
+	add_hook(match_assign_param, ASSIGNMENT_HOOK);
+	add_hook(match_assign_function, ASSIGNMENT_HOOK);
+	select_return_implies_hook(FN_ARG_LINK, &check_passes_fn_and_data);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_address.c b/usr/src/tools/smatch/src/smatch_address.c
new file mode 100644
index 0000000000..5c48e05fdb
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_address.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2015 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static bool is_non_null_array(struct expression *expr)
+{
+	struct symbol *type;
+	struct symbol *sym;
+	struct symbol *tmp;
+	int i;
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_ARRAY)
+		return 0;
+	if (expr->type == EXPR_SYMBOL)
+		return 1;
+	if (implied_not_equal(expr, 0))
+		return 1;
+
+	/* verify that it's not the first member of the struct */
+	if (expr->type != EXPR_DEREF || !expr->member)
+		return 0;
+	sym = expr_to_sym(expr);
+	if (!sym)
+		return 0;
+	type = get_real_base_type(sym);
+	if (!type || type->type != SYM_PTR)
+		return 0;
+	type = get_real_base_type(type);
+	if (type->type != SYM_STRUCT)
+		return 0;
+
+	i = 0;
+	FOR_EACH_PTR(type->symbol_list, tmp) {
+		i++;
+		if (!tmp->ident)
+			continue;
+		if (strcmp(expr->member->name, tmp->ident->name) == 0) {
+			if (i == 1)
+				return 0;
+			return 1;
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+int get_member_offset(struct symbol *type, const char *member_name)
+{
+	struct symbol *tmp;
+	int offset;
+
+	if (!type || type->type != SYM_STRUCT)
+		return -1;
+
+	offset = 0;
+	FOR_EACH_PTR(type->symbol_list, tmp) {
+		offset = ALIGN(offset, tmp->ctype.alignment);
+		if (tmp->ident &&
+		    strcmp(member_name, tmp->ident->name) == 0) {
+			return offset;
+		}
+		offset += type_bytes(tmp);
+	} END_FOR_EACH_PTR(tmp);
+	return -1;
+}
+
+int get_member_offset_from_deref(struct expression *expr)
+{
+	struct symbol *type;
+	struct ident *member;
+	int offset;
+
+	if (expr->type != EXPR_DEREF)  /* hopefully, this doesn't happen */
+		return -1;
+
+	if (expr->member_offset >= 0)
+		return expr->member_offset;
+
+	member = expr->member;
+	if (!member)
+		return -1;
+
+	type = get_type(expr->deref);
+	if (!type || type->type != SYM_STRUCT)
+		return -1;
+
+	offset = get_member_offset(type, member->name);
+	if (offset >= 0)
+		expr->member_offset = offset;
+	return offset;
+}
+
+static struct range_list *filter_unknown_negatives(struct range_list *rl)
+{
+	struct data_range *first;
+	struct range_list *filter = NULL;
+
+	first = first_ptr_list((struct ptr_list *)rl);
+
+	if (sval_is_min(first->min) &&
+	    sval_is_negative(first->max) &&
+	    first->max.value == -1) {
+		add_ptr_list(&filter, first);
+		return rl_filter(rl, filter);
+	}
+
+	return rl;
+}
+
+static void add_offset_to_pointer(struct range_list **rl, int offset)
+{
+	sval_t min, max, remove, sval;
+	struct range_list *orig = *rl;
+
+	/*
+	 * Ha ha.  Treating zero as a special case means I'm correct at least a
+	 * tiny fraction of the time.  Which is better than nothing.
+	 *
+	 */
+	if (offset == 0)
+		return;
+
+	/*
+	 * This function doesn't necessarily work how you might expect...
+	 *
+	 * Say you have s64min-(-1),1-s64max and you add 8 then I guess what
+	 * we want to say is maybe something like 9-s64max.  This shows that the
+	 * min it could be is 9 which is potentially useful information.  But
+	 * if we start with (-12),5000000-57777777 and we add 8 then we'd want
+	 * the result to be (-4),5000008-57777777 but (-4),5000000-57777777 is
+	 * also probably acceptable.  If you start with s64min-s64max then the
+	 * result should be 8-s64max.
+	 *
+	 */
+
+	/* We do the math on void pointer type, because this isn't "&v + 16" it
+	 * is &v->sixteenth_byte.
+	 */
+	orig = cast_rl(&ptr_ctype, orig);
+	min = sval_type_min(&ptr_ctype);
+	min.value = offset;
+	max = sval_type_max(&ptr_ctype);
+
+	if (!orig || is_whole_rl(orig)) {
+		*rl = alloc_rl(min, max);
+		return;
+	}
+
+	orig = filter_unknown_negatives(orig);
+	/*
+	 * FIXME:  This is not really accurate but we're a bit screwed anyway
+	 * when we start doing pointer math with error pointers so it's probably
+	 * not important.
+	 *
+	 */
+	if (sval_is_negative(rl_min(orig)))
+		return;
+
+	/* no wrap around */
+	max.uvalue = rl_max(orig).uvalue;
+	if (max.uvalue > sval_type_max(&ptr_ctype).uvalue - offset) {
+		remove = sval_type_max(&ptr_ctype);
+		remove.uvalue -= offset;
+		orig = remove_range(orig, remove, max);
+	}
+
+	sval.type = &int_ctype;
+	sval.value = offset;
+
+	*rl = rl_binop(orig, '+', alloc_rl(sval, sval));
+}
+
+static struct range_list *where_allocated_rl(struct symbol *sym)
+{
+	if (!sym)
+		return NULL;
+
+	if (sym->ctype.modifiers & (MOD_TOPLEVEL | MOD_STATIC)) {
+		if (sym->initializer)
+			return alloc_rl(data_seg_min, data_seg_max);
+		else
+			return alloc_rl(bss_seg_min, bss_seg_max);
+	}
+	return alloc_rl(stack_seg_min, stack_seg_max);
+}
+
+int get_address_rl(struct expression *expr, struct range_list **rl)
+{
+	expr = strip_expr(expr);
+	if (!expr)
+		return 0;
+
+	if (expr->type == EXPR_STRING) {
+		*rl = alloc_rl(text_seg_min, text_seg_max);
+		return 1;
+	}
+
+	if (expr->type == EXPR_PREOP && expr->op == '&') {
+		struct expression *unop;
+
+		unop = strip_expr(expr->unop);
+		if (unop->type == EXPR_SYMBOL) {
+			*rl = where_allocated_rl(unop->symbol);
+			return 1;
+		}
+
+		if (unop->type == EXPR_DEREF) {
+			int offset = get_member_offset_from_deref(unop);
+
+			unop = strip_expr(unop->unop);
+			if (unop->type == EXPR_SYMBOL) {
+				*rl = where_allocated_rl(unop->symbol);
+			} else if (unop->type == EXPR_PREOP && unop->op == '*') {
+				unop = strip_expr(unop->unop);
+				get_absolute_rl(unop, rl);
+			} else {
+				return 0;
+			}
+
+			add_offset_to_pointer(rl, offset);
+			return 1;
+		}
+
+		return 0;
+	}
+
+	if (is_non_null_array(expr)) {
+		*rl = alloc_rl(array_min_sval, array_max_sval);
+		return 1;
+	}
+
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/smatch_annotate.c b/usr/src/tools/smatch/src/smatch_annotate.c
new file mode 100644
index 0000000000..c027d1fa98
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_annotate.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * A place to add function annotations for common functions.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int param_caps_return(struct expression *call, void *_arg, struct range_list **res)
+{
+	int arg = PTR_INT(_arg);
+	struct expression *expr;
+	struct range_list *rl;
+
+	expr = get_argument_from_call_expr(call->args, arg);
+	if (get_implied_rl(expr, &rl) && rl_max(rl).value != 0)
+		*res = alloc_rl(sval_type_val(rl_type(rl), 0), rl_max(rl));
+	return 1;
+}
+
+void register_annotate(int id)
+{
+	/*
+	 * Technically snprintf() returns the number of bytes which *would* have
+	 * been printed.  I do try caclulating that in check_snprintf().  But
+	 * it probably works better to assume the limitter is accurate.
+	 */
+	add_implied_return_hook("snprintf", &param_caps_return, INT_PTR(1));
+
+}
diff --git a/usr/src/tools/smatch/src/smatch_array_values.c b/usr/src/tools/smatch/src/smatch_array_values.c
new file mode 100644
index 0000000000..7627cebc2f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_array_values.c
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2018 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+struct db_info {
+	int count;
+	struct symbol *type;
+	struct range_list *rl;
+};
+
+static int get_vals(void *_db_info, int argc, char **argv, char **azColName)
+{
+	struct db_info *db_info = _db_info;
+	struct range_list *rl;
+
+	str_to_rl(db_info->type, argv[0], &rl);
+	db_info->rl = rl_union(db_info->rl, rl);
+
+	return 0;
+}
+
+static int is_file_local(struct expression *array)
+{
+	struct symbol *sym = NULL;
+	char *name;
+
+	name = expr_to_str_sym(array, &sym);
+	free_string(name);
+	if (!sym)
+		return 0;
+
+	if ((sym->ctype.modifiers & MOD_TOPLEVEL) &&
+	    (sym->ctype.modifiers & MOD_STATIC))
+		return 1;
+	return 0;
+}
+
+static char *get_toplevel_name(struct expression *array)
+{
+	char *name;
+	char buf[128];
+
+	if (is_array(array))
+		array = get_array_base(array);
+
+	if (!array || array->type != EXPR_SYMBOL)
+		return NULL;
+	if (!is_file_local(array))
+		return NULL;
+
+	name = expr_to_str(array);
+	snprintf(buf, sizeof(buf), "%s[]", name);
+	free_string(name);
+
+	return alloc_sname(buf);
+}
+
+static char *get_member_array(struct expression *array)
+{
+	char *name;
+	char buf[128];
+
+	name = get_member_name(array);
+	if (!name)
+		return NULL;
+	snprintf(buf, sizeof(buf), "%s[]", name);
+	free_string(name);
+	return alloc_sname(buf);
+}
+
+static char *get_array_name(struct expression *array)
+{
+	struct symbol *type;
+	char *name;
+
+	type = get_type(array);
+	if (!type || type->type != SYM_ARRAY)
+		return NULL;
+
+	name = get_toplevel_name(array);
+	if (name)
+		return name;
+	name = get_member_array(array);
+	if (name)
+		return name;
+
+	return NULL;
+}
+
+int get_array_rl(struct expression *expr, struct range_list **rl)
+{
+	struct expression *array;
+	struct symbol *type;
+	struct db_info db_info = {};
+	char *name;
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_BASETYPE)
+		return 0;
+	db_info.type = type;
+
+	array = get_array_base(expr);
+	name = get_array_name(array);
+	if (!name)
+		return 0;
+
+	if (is_file_local(array)) {
+		run_sql(&get_vals, &db_info,
+			"select value from sink_info where file = '%s' and static = 1 and sink_name = '%s' and type = %d;",
+			get_filename(), name, DATA_VALUE);
+	} else {
+		run_sql(&get_vals, &db_info,
+			"select value from sink_info where sink_name = '%s' and type = %d limit 10;",
+			name, DATA_VALUE);
+	}
+	if (!db_info.rl || db_info.count >= 10)
+		return 0;
+
+	*rl = db_info.rl;
+	return 1;
+}
+
+static struct range_list *get_saved_rl(struct symbol *type, char *name)
+{
+	struct db_info db_info = {.type = type};
+
+	cache_sql(&get_vals, &db_info, "select value from sink_info where sink_name = '%s' and type = %d;",
+		  name, DATA_VALUE);
+	return db_info.rl;
+}
+
+static void update_cache(char *name, int is_static, struct range_list *rl)
+{
+	cache_sql(NULL, NULL, "delete from sink_info where sink_name = '%s' and type = %d;",
+		  name, DATA_VALUE);
+	cache_sql(NULL, NULL, "insert into sink_info values ('%s', %d, '%s', %d, '', '%s');",
+		  get_filename(), is_static, name, DATA_VALUE, show_rl(rl));
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *left, *array;
+	struct range_list *orig_rl, *rl;
+	struct symbol *type;
+	char *name;
+
+	type = get_type(expr->right);
+	if (!type || type->type != SYM_BASETYPE)
+		return;
+
+	left = strip_expr(expr->left);
+	if (!is_array(left))
+		return;
+	array = get_array_base(left);
+	name = get_array_name(array);
+	if (!name)
+		return;
+
+	if (expr->op != '=') {
+		rl = alloc_whole_rl(type);
+	} else {
+		get_absolute_rl(expr->right, &rl);
+		rl = cast_rl(type, rl);
+		orig_rl = get_saved_rl(type, name);
+		rl = rl_union(orig_rl, rl);
+	}
+
+	update_cache(name, is_file_local(array), rl);
+}
+
+void register_array_values(int id)
+{
+	my_id = id;
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_assign, GLOBAL_ASSIGNMENT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_assigned_expr.c b/usr/src/tools/smatch/src/smatch_assigned_expr.c
new file mode 100644
index 0000000000..b0c2c4f767
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_assigned_expr.c
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is not a check.  It just saves an struct expression pointer 
+ * whenever something is assigned.  This can be used later on by other scripts.
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+int check_assigned_expr_id;
+static int my_id;
+static int link_id;
+
+static void undef(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &undefined);
+}
+
+struct expression *get_assigned_expr(struct expression *expr)
+{
+	struct smatch_state *state;
+
+	state = get_state_expr(my_id, expr);
+	if (!state)
+		return NULL;
+	return (struct expression *)state->data;
+}
+
+struct expression *get_assigned_expr_name_sym(const char *name, struct symbol *sym)
+{
+	struct smatch_state *state;
+
+	state = get_state(my_id, name, sym);
+	if (!state)
+		return NULL;
+	return (struct expression *)state->data;
+}
+
+static void match_assignment(struct expression *expr)
+{
+	struct symbol *left_sym, *right_sym;
+	char *left_name = NULL;
+	char *right_name = NULL;
+
+	if (expr->op != '=')
+		return;
+	if (is_fake_call(expr->right))
+		return;
+	if (__in_fake_struct_assign) {
+		struct range_list *rl;
+
+		if (!get_implied_rl(expr->right, &rl))
+			return;
+		if (is_whole_rl(rl))
+			return;
+	}
+
+	left_name = expr_to_var_sym(expr->left, &left_sym);
+	if (!left_name || !left_sym)
+		goto free;
+	set_state(my_id, left_name, left_sym, alloc_state_expr(strip_expr(expr->right)));
+
+	right_name = expr_to_var_sym(expr->right, &right_sym);
+	if (!right_name || !right_sym)
+		goto free;
+
+	store_link(link_id, right_name, right_sym, left_name, left_sym);
+
+free:
+	free_string(left_name);
+	free_string(right_name);
+}
+
+static void record_param_assignment(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg, *right;
+	struct symbol *sym;
+	char *name;
+	char *p;
+	int right_param;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (!expr || expr->type != EXPR_CALL)
+		return;
+
+	p = strstr(value, "[$");
+	if (!p)
+		return;
+
+	p += 2;
+	right_param = strtol(p, &p, 10);
+	if (*p != ']')
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	right = get_argument_from_call_expr(expr->args, right_param);
+	if (!right || !arg)
+		return;
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	set_state(my_id, name, sym, alloc_state_expr(right));
+free:
+	free_string(name);
+}
+
+void register_assigned_expr(int id)
+{
+	my_id = check_assigned_expr_id = id;
+	add_hook(&match_assignment, ASSIGNMENT_HOOK_AFTER);
+	add_modification_hook(my_id, &undef);
+	select_return_states_hook(PARAM_SET, &record_param_assignment);
+}
+
+void register_assigned_expr_links(int id)
+{
+	link_id = id;
+	db_ignore_states(link_id);
+	set_up_link_functions(my_id, link_id);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_auto_copy.c b/usr/src/tools/smatch/src/smatch_auto_copy.c
new file mode 100644
index 0000000000..098404e66d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_auto_copy.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static int *auto_copy;
+
+void set_auto_copy(int owner)
+{
+	if (owner <= 1 || owner > num_checks) {
+		sm_ierror("bogus set_auto_copy()");
+		return;
+	}
+	auto_copy[owner] = 1;
+}
+
+static void match_assign(struct expression *expr)
+{
+	char *left_name = NULL;
+	char *right_name = NULL;
+	struct symbol *left_sym, *right_sym;
+	struct state_list *slist = NULL;
+	struct sm_state *sm;
+
+	left_name = expr_to_var_sym(expr->left, &left_sym);
+	if (!left_name || !left_sym)
+		goto free;
+	right_name = expr_to_var_sym(expr->right, &right_sym);
+	if (!right_name || !right_sym)
+		goto free;
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (sm->owner <= 1 || sm->owner > num_checks)
+			continue;
+		if (!auto_copy[sm->owner])
+			continue;
+		if (right_sym != sm->sym)
+			continue;
+		if (strcmp(right_name, sm->name) != 0)
+			continue;
+		add_ptr_list(&slist, sm);
+	} END_FOR_EACH_SM(sm);
+
+
+	FOR_EACH_PTR(slist, sm) {
+		set_state(sm->owner, left_name, left_sym, sm->state);
+	} END_FOR_EACH_PTR(sm);
+
+free:
+	free_slist(&slist);
+	free_string(left_name);
+	free_string(right_name);
+}
+
+void register_auto_copy(int id)
+{
+	my_id = id;
+	auto_copy = malloc((num_checks + 1) * sizeof(*auto_copy));
+	memset(auto_copy, 0, (num_checks + 1) * sizeof(*auto_copy));
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_buf_comparison.c b/usr/src/tools/smatch/src/smatch_buf_comparison.c
new file mode 100644
index 0000000000..d142817a99
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_buf_comparison.c
@@ -0,0 +1,605 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The point here is to store that a buffer has x bytes even if we don't know
+ * the value of x.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int size_id;
+static int link_id;
+
+/*
+ * We need this for code which does:
+ *
+ *     if (size)
+ *         foo = malloc(size);
+ *
+ * We want to record that the size of "foo" is "size" even after the merge.
+ *
+ */
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	struct expression *size_expr;
+	sval_t sval;
+
+	if (!sm->state->data)
+		return &undefined;
+	size_expr = sm->state->data;
+	if (!get_implied_value(size_expr, &sval) || sval.value != 0)
+		return &undefined;
+	return sm->state;
+}
+
+static struct smatch_state *merge_links(struct smatch_state *s1, struct smatch_state *s2)
+{
+	struct expression *expr1, *expr2;
+
+	expr1 = s1->data;
+	expr2 = s2->data;
+
+	if (expr1 && expr2 && expr_equiv(expr1, expr2))
+		return s1;
+	return &merged;
+}
+
+static void match_link_modify(struct sm_state *sm, struct expression *mod_expr)
+{
+	struct expression *expr;
+	struct sm_state *tmp;
+
+	expr = sm->state->data;
+	if (expr) {
+		set_state_expr(size_id, expr, &undefined);
+		set_state(link_id, sm->name, sm->sym, &undefined);
+		return;
+	}
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		expr = tmp->state->data;
+		if (expr)
+			set_state_expr(size_id, expr, &undefined);
+	} END_FOR_EACH_PTR(tmp);
+	set_state(link_id, sm->name, sm->sym, &undefined);
+}
+
+static struct smatch_state *alloc_expr_state(struct expression *expr)
+{
+	struct smatch_state *state;
+	char *name;
+
+	state = __alloc_smatch_state(0);
+	expr = strip_expr(expr);
+	name = expr_to_str(expr);
+	state->name = alloc_sname(name);
+	free_string(name);
+	state->data = expr;
+	return state;
+}
+
+static int bytes_per_element(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+
+	if (type->type != SYM_PTR && type->type != SYM_ARRAY)
+		return 0;
+
+	type = get_base_type(type);
+	return type_bytes(type);
+}
+
+static void db_save_type_links(struct expression *array, struct expression *size)
+{
+	const char *array_name;
+
+	array_name = get_data_info_name(array);
+	if (!array_name)
+		array_name = "";
+	sql_insert_data_info(size, ARRAY_LEN, array_name);
+}
+
+static void match_alloc_helper(struct expression *pointer, struct expression *size)
+{
+	struct expression *tmp;
+	struct sm_state *sm;
+	sval_t sval;
+	int cnt = 0;
+
+	pointer = strip_expr(pointer);
+	size = strip_expr(size);
+	if (!size || !pointer)
+		return;
+
+	while ((tmp = get_assigned_expr(size))) {
+		size = strip_expr(tmp);
+		if (cnt++ > 5)
+			break;
+	}
+
+	if (size->type == EXPR_BINOP && size->op == '*') {
+		struct expression *mult_left, *mult_right;
+
+		mult_left = strip_expr(size->left);
+		mult_right = strip_expr(size->right);
+
+		if (get_implied_value(mult_left, &sval) &&
+		    sval.value == bytes_per_element(pointer))
+			size = mult_right;
+		else if (get_implied_value(mult_right, &sval) &&
+		    sval.value == bytes_per_element(pointer))
+			size = mult_left;
+		else
+			return;
+	}
+
+	/* Only save links to variables, not fixed sizes */
+	if (get_value(size, &sval))
+		return;
+
+	db_save_type_links(pointer, size);
+	sm = set_state_expr(size_id, pointer, alloc_expr_state(size));
+	if (!sm)
+		return;
+	set_state_expr(link_id, size, alloc_expr_state(pointer));
+}
+
+static void match_alloc(const char *fn, struct expression *expr, void *_size_arg)
+{
+	int size_arg = PTR_INT(_size_arg);
+	struct expression *pointer, *call, *arg;
+
+	pointer = strip_expr(expr->left);
+	call = strip_expr(expr->right);
+	arg = get_argument_from_call_expr(call->args, size_arg);
+	match_alloc_helper(pointer, arg);
+}
+
+static void match_calloc(const char *fn, struct expression *expr, void *_start_arg)
+{
+	int start_arg = PTR_INT(_start_arg);
+	struct expression *pointer, *call, *arg;
+	struct sm_state *tmp;
+	sval_t sval;
+
+	pointer = strip_expr(expr->left);
+	call = strip_expr(expr->right);
+	arg = get_argument_from_call_expr(call->args, start_arg);
+	if (get_implied_value(arg, &sval) &&
+	    sval.value == bytes_per_element(pointer))
+		arg = get_argument_from_call_expr(call->args, start_arg + 1);
+
+	db_save_type_links(pointer, arg);
+	tmp = set_state_expr(size_id, pointer, alloc_expr_state(arg));
+	if (!tmp)
+		return;
+	set_state_expr(link_id, arg, alloc_expr_state(pointer));
+}
+
+struct expression *get_size_variable(struct expression *buf)
+{
+	struct smatch_state *state;
+
+	state = get_state_expr(size_id, buf);
+	if (state)
+		return state->data;
+	return NULL;
+}
+
+struct expression *get_array_variable(struct expression *size)
+{
+	struct smatch_state *state;
+
+	state = get_state_expr(link_id, size);
+	if (state)
+		return state->data;
+	return NULL;
+}
+
+static void array_check(struct expression *expr)
+{
+	struct expression *array;
+	struct expression *size;
+	struct expression *offset;
+	char *array_str, *offset_str;
+
+	expr = strip_expr(expr);
+	if (!is_array(expr))
+		return;
+
+	array = get_array_base(expr);
+	size = get_size_variable(array);
+	if (!size)
+		return;
+	offset = get_array_offset(expr);
+	if (!possible_comparison(size, SPECIAL_EQUAL, offset))
+		return;
+
+	array_str = expr_to_str(array);
+	offset_str = expr_to_str(offset);
+	sm_warning("potentially one past the end of array '%s[%s]'", array_str, offset_str);
+	free_string(array_str);
+	free_string(offset_str);
+}
+
+struct db_info {
+	char *name;
+	int ret;
+};
+
+static int db_limitter_callback(void *_info, int argc, char **argv, char **azColName)
+{
+	struct db_info *info = _info;
+
+	/*
+	 * If possible the limitters are tied to the struct they limit.  If we
+	 * aren't sure which struct they limit then we use them as limitters for
+	 * everything.
+	 */
+	if (!info->name || argv[0][0] == '\0' || strcmp(info->name, argv[0]) == 0)
+		info->ret = 1;
+	return 0;
+}
+
+static char *vsl_to_data_info_name(const char *name, struct var_sym_list *vsl)
+{
+	struct var_sym *vs;
+	struct symbol *type;
+	static char buf[80];
+	const char *p;
+
+	if (ptr_list_size((struct ptr_list *)vsl) != 1)
+		return NULL;
+	vs = first_ptr_list((struct ptr_list *)vsl);
+
+	type = get_real_base_type(vs->sym);
+	if (!type || type->type != SYM_PTR)
+		goto top_level_name;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_STRUCT)
+		goto top_level_name;
+	if (!type->ident)
+		goto top_level_name;
+
+	p = name;
+	while ((name = strstr(p, "->")))
+		p = name + 2;
+
+	snprintf(buf, sizeof(buf),"(struct %s)->%s", type->ident->name, p);
+	return alloc_sname(buf);
+
+top_level_name:
+	if (!(vs->sym->ctype.modifiers & MOD_TOPLEVEL))
+		return NULL;
+	if (vs->sym->ctype.modifiers & MOD_STATIC)
+		snprintf(buf, sizeof(buf),"static %s", name);
+	else
+		snprintf(buf, sizeof(buf),"global %s", name);
+	return alloc_sname(buf);
+}
+
+int db_var_is_array_limit(struct expression *array, const char *name, struct var_sym_list *vsl)
+{
+	char *size_name;
+	char *array_name = get_data_info_name(array);
+	struct db_info db_info = {.name = array_name,};
+
+	size_name = vsl_to_data_info_name(name, vsl);
+	if (!size_name)
+		return 0;
+
+	run_sql(db_limitter_callback, &db_info,
+		"select value from data_info where type = %d and data = '%s';",
+		ARRAY_LEN, size_name);
+
+	return db_info.ret;
+}
+
+static int known_access_ok_comparison(struct expression *expr)
+{
+	struct expression *array;
+	struct expression *size;
+	struct expression *offset;
+	int comparison;
+
+	array = get_array_base(expr);
+	size = get_size_variable(array);
+	if (!size)
+		return 0;
+	offset = get_array_offset(expr);
+	comparison = get_comparison(size, offset);
+	if (comparison == '>' || comparison == SPECIAL_UNSIGNED_GT)
+		return 1;
+
+	return 0;
+}
+
+static int known_access_ok_numbers(struct expression *expr)
+{
+	struct expression *array;
+	struct expression *offset;
+	sval_t max;
+	int size;
+
+	array = get_array_base(expr);
+	offset = get_array_offset(expr);
+
+	size = get_array_size(array);
+	if (size <= 0)
+		return 0;
+
+	get_absolute_max(offset, &max);
+	if (max.uvalue < size)
+		return 1;
+	return 0;
+}
+
+static void array_check_data_info(struct expression *expr)
+{
+	struct expression *array;
+	struct expression *offset;
+	struct state_list *slist;
+	struct sm_state *sm;
+	struct compare_data *comp;
+	char *offset_name;
+	const char *equal_name = NULL;
+
+	expr = strip_expr(expr);
+	if (!is_array(expr))
+		return;
+
+	if (known_access_ok_numbers(expr))
+		return;
+	if (known_access_ok_comparison(expr))
+		return;
+
+	array = get_array_base(expr);
+	offset = get_array_offset(expr);
+	offset_name = expr_to_var(offset);
+	if (!offset_name)
+		return;
+	slist = get_all_possible_equal_comparisons(offset);
+	if (!slist)
+		goto free;
+
+	FOR_EACH_PTR(slist, sm) {
+		comp = sm->state->data;
+		if (strcmp(comp->left_var, offset_name) == 0) {
+			if (db_var_is_array_limit(array, comp->right_var, comp->right_vsl)) {
+				equal_name = comp->right_var;
+				break;
+			}
+		} else if (strcmp(comp->right_var, offset_name) == 0) {
+			if (db_var_is_array_limit(array, comp->left_var, comp->left_vsl)) {
+				equal_name = comp->left_var;
+				break;
+			}
+		}
+	} END_FOR_EACH_PTR(sm);
+
+	if (equal_name) {
+		char *array_name = expr_to_str(array);
+
+		sm_warning("potential off by one '%s[]' limit '%s'", array_name, equal_name);
+		free_string(array_name);
+	}
+
+free:
+	free_slist(&slist);
+	free_string(offset_name);
+}
+
+static void add_allocation_function(const char *func, void *call_back, int param)
+{
+	add_function_assign_hook(func, call_back, INT_PTR(param));
+}
+
+static char *buf_size_param_comparison(struct expression *array, struct expression_list *args)
+{
+	struct expression *arg;
+	struct expression *size;
+	static char buf[32];
+	int i;
+
+	size = get_size_variable(array);
+	if (!size)
+		return NULL;
+
+	i = -1;
+	FOR_EACH_PTR(args, arg) {
+		i++;
+		if (arg == array)
+			continue;
+		if (!expr_equiv(arg, size))
+			continue;
+		snprintf(buf, sizeof(buf), "==$%d", i);
+		return buf;
+	} END_FOR_EACH_PTR(arg);
+
+	return NULL;
+}
+
+static void match_call(struct expression *call)
+{
+	struct expression *arg;
+	char *compare;
+	int param;
+
+	param = -1;
+	FOR_EACH_PTR(call->args, arg) {
+		param++;
+		if (!is_pointer(arg))
+			continue;
+		compare = buf_size_param_comparison(arg, call->args);
+		if (!compare)
+			continue;
+		sql_insert_caller_info(call, ARRAY_LEN, param, "$", compare);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static int get_param(int param, char **name, struct symbol **sym)
+{
+	struct symbol *arg;
+	int i;
+
+	i = 0;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
+		/*
+		 * this is a temporary hack to work around a bug (I think in sparse?)
+		 * 2.6.37-rc1:fs/reiserfs/journal.o
+		 * If there is a function definition without parameter name found
+		 * after a function implementation then it causes a crash.
+		 * int foo() {}
+		 * int bar(char *);
+		 */
+		if (arg->ident->name < (char *)100)
+			continue;
+		if (i == param) {
+			*name = arg->ident->name;
+			*sym = arg;
+			return TRUE;
+		}
+		i++;
+	} END_FOR_EACH_PTR(arg);
+
+	return FALSE;
+}
+
+static void set_param_compare(const char *array_name, struct symbol *array_sym, char *key, char *value)
+{
+	struct expression *array_expr;
+	struct expression *size_expr;
+	struct symbol *size_sym;
+	char *size_name;
+	long param;
+	struct sm_state *tmp;
+
+	if (strncmp(value, "==$", 3) != 0)
+		return;
+	param = strtol(value + 3, NULL, 10);
+	if (!get_param(param, &size_name, &size_sym))
+		return;
+	array_expr = symbol_expression(array_sym);
+	size_expr = symbol_expression(size_sym);
+
+	tmp = set_state_expr(size_id, array_expr, alloc_expr_state(size_expr));
+	if (!tmp)
+		return;
+	set_state_expr(link_id, size_expr, alloc_expr_state(array_expr));
+}
+
+static void set_arraysize_arg(const char *array_name, struct symbol *array_sym, char *key, char *value)
+{
+	struct expression *array_expr;
+	struct expression *size_expr;
+	struct symbol *size_sym;
+	char *size_name;
+	long param;
+	struct sm_state *tmp;
+
+	param = strtol(key, NULL, 10);
+	if (!get_param(param, &size_name, &size_sym))
+		return;
+	array_expr = symbol_expression(array_sym);
+	size_expr = symbol_expression(size_sym);
+
+	tmp = set_state_expr(size_id, array_expr, alloc_expr_state(size_expr));
+	if (!tmp)
+		return;
+	set_state_expr(link_id, size_expr, alloc_expr_state(array_expr));
+}
+
+static void munge_start_states(struct statement *stmt)
+{
+	struct state_list *slist = NULL;
+	struct sm_state *sm;
+	struct sm_state *poss;
+
+	FOR_EACH_MY_SM(size_id, __get_cur_stree(), sm) {
+		if (sm->state != &merged)
+			continue;
+		/*
+		 * screw it.  let's just assume that if one caller passes the
+		 * size then they all do.
+		 */
+		FOR_EACH_PTR(sm->possible, poss) {
+			if (poss->state != &merged &&
+			    poss->state != &undefined) {
+				add_ptr_list(&slist, poss);
+				break;
+			}
+		} END_FOR_EACH_PTR(poss);
+	} END_FOR_EACH_SM(sm);
+
+	FOR_EACH_PTR(slist, sm) {
+		set_state(size_id, sm->name, sm->sym, sm->state);
+	} END_FOR_EACH_PTR(sm);
+
+	free_slist(&slist);
+}
+
+void register_buf_comparison(int id)
+{
+	size_id = id;
+
+	add_unmatched_state_hook(size_id, &unmatched_state);
+
+	add_allocation_function("malloc", &match_alloc, 0);
+	add_allocation_function("memdup", &match_alloc, 1);
+	add_allocation_function("realloc", &match_alloc, 1);
+	if (option_project == PROJ_KERNEL) {
+		add_allocation_function("kmalloc", &match_alloc, 0);
+		add_allocation_function("kzalloc", &match_alloc, 0);
+		add_allocation_function("vmalloc", &match_alloc, 0);
+		add_allocation_function("__vmalloc", &match_alloc, 0);
+		add_allocation_function("sock_kmalloc", &match_alloc, 1);
+		add_allocation_function("kmemdup", &match_alloc, 1);
+		add_allocation_function("kmemdup_user", &match_alloc, 1);
+		add_allocation_function("dma_alloc_attrs", &match_alloc, 1);
+		add_allocation_function("pci_alloc_consistent", &match_alloc, 1);
+		add_allocation_function("pci_alloc_coherent", &match_alloc, 1);
+		add_allocation_function("devm_kmalloc", &match_alloc, 1);
+		add_allocation_function("devm_kzalloc", &match_alloc, 1);
+		add_allocation_function("kcalloc", &match_calloc, 0);
+		add_allocation_function("devm_kcalloc", &match_calloc, 1);
+		add_allocation_function("kmalloc_array", &match_calloc, 0);
+		add_allocation_function("krealloc", &match_alloc, 1);
+	}
+
+	add_hook(&array_check, OP_HOOK);
+	add_hook(&array_check_data_info, OP_HOOK);
+
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+	select_caller_info_hook(set_param_compare, ARRAY_LEN);
+	select_caller_info_hook(set_arraysize_arg, ARRAYSIZE_ARG);
+	add_hook(&munge_start_states, AFTER_DEF_HOOK);
+}
+
+void register_buf_comparison_links(int id)
+{
+	link_id = id;
+	add_merge_hook(link_id, &merge_links);
+	add_modification_hook(link_id, &match_link_modify);
+}
diff --git a/usr/src/tools/smatch/src/smatch_buf_size.c b/usr/src/tools/smatch/src/smatch_buf_size.c
new file mode 100644
index 0000000000..0c7f34947b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_buf_size.c
@@ -0,0 +1,935 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+#include "smatch_function_hashtable.h"
+
+#define UNKNOWN_SIZE (-1)
+
+static int my_size_id;
+
+static DEFINE_HASHTABLE_INSERT(insert_func, char, int);
+static DEFINE_HASHTABLE_SEARCH(search_func, char, int);
+static struct hashtable *allocation_funcs;
+
+static char *get_fn_name(struct expression *expr)
+{
+	if (expr->type != EXPR_CALL)
+		return NULL;
+	if (expr->fn->type != EXPR_SYMBOL)
+		return NULL;
+	return expr_to_var(expr->fn);
+}
+
+static int is_allocation_function(struct expression *expr)
+{
+	char *func;
+	int ret = 0;
+
+	func = get_fn_name(expr);
+	if (!func)
+		return 0;
+	if (search_func(allocation_funcs, func))
+		ret = 1;
+	free_string(func);
+	return ret;
+}
+
+static void add_allocation_function(const char *func, void *call_back, int param)
+{
+	insert_func(allocation_funcs, (char *)func, (int *)1);
+	add_function_assign_hook(func, call_back, INT_PTR(param));
+}
+
+static int estate_to_size(struct smatch_state *state)
+{
+	sval_t sval;
+
+	if (!state || !estate_rl(state))
+		return 0;
+	sval = estate_max(state);
+	return sval.value;
+}
+
+static struct smatch_state *size_to_estate(int size)
+{
+	sval_t sval;
+
+	sval.type = &int_ctype;
+	sval.value = size;
+
+	return alloc_estate_sval(sval);
+}
+
+static struct range_list *size_to_rl(int size)
+{
+	sval_t sval;
+
+	sval.type = &int_ctype;
+	sval.value = size;
+
+	return alloc_rl(sval, sval);
+}
+
+static struct smatch_state *unmatched_size_state(struct sm_state *sm)
+{
+	return size_to_estate(UNKNOWN_SIZE);
+}
+
+static void set_size_undefined(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(sm->owner, sm->name, sm->sym, size_to_estate(UNKNOWN_SIZE));
+}
+
+static struct smatch_state *merge_size_func(struct smatch_state *s1, struct smatch_state *s2)
+{
+	return merge_estates(s1, s2);
+}
+
+void set_param_buf_size(const char *name, struct symbol *sym, char *key, char *value)
+{
+	struct range_list *rl = NULL;
+	struct smatch_state *state;
+	char fullname[256];
+
+	if (strncmp(key, "$", 1) != 0)
+		return;
+
+	snprintf(fullname, 256, "%s%s", name, key + 1);
+
+	str_to_rl(&int_ctype, value, &rl);
+	if (!rl || is_whole_rl(rl))
+		return;
+	state = alloc_estate_rl(rl);
+	set_state(my_size_id, fullname, sym, state);
+}
+
+static int bytes_per_element(struct expression *expr)
+{
+	struct symbol *type;
+
+	if (!expr)
+		return 0;
+	if (expr->type == EXPR_STRING)
+		return 1;
+	if (expr->type == EXPR_PREOP && expr->op == '&') {
+		type = get_type(expr->unop);
+		if (type && type->type == SYM_ARRAY)
+			expr = expr->unop;
+	}
+	type = get_type(expr);
+	if (!type)
+		return 0;
+
+	if (type->type != SYM_PTR && type->type != SYM_ARRAY)
+		return 0;
+
+	type = get_base_type(type);
+	return type_bytes(type);
+}
+
+static int bytes_to_elements(struct expression *expr, int bytes)
+{
+	int bpe;
+
+	bpe = bytes_per_element(expr);
+	if (bpe == 0)
+		return 0;
+	return bytes / bpe;
+}
+
+static int elements_to_bytes(struct expression *expr, int elements)
+{
+	int bpe;
+
+	bpe = bytes_per_element(expr);
+	return elements * bpe;
+}
+
+static int get_initializer_size(struct expression *expr)
+{
+	switch (expr->type) {
+	case EXPR_STRING:
+		return expr->string->length;
+	case EXPR_INITIALIZER: {
+		struct expression *tmp;
+		int i = 0;
+
+		FOR_EACH_PTR(expr->expr_list, tmp) {
+			if (tmp->type == EXPR_INDEX) {
+				if (tmp->idx_to >= i)
+					i = tmp->idx_to;
+				else
+					continue;
+			}
+
+			i++;
+		} END_FOR_EACH_PTR(tmp);
+		return i;
+	}
+	case EXPR_SYMBOL:
+		return get_array_size(expr);
+	}
+	return 0;
+}
+
+static struct range_list *db_size_rl;
+static int db_size_callback(void *unused, int argc, char **argv, char **azColName)
+{
+	struct range_list *tmp = NULL;
+
+	if (!db_size_rl) {
+		str_to_rl(&int_ctype, argv[0], &db_size_rl);
+	} else {
+		str_to_rl(&int_ctype, argv[0], &tmp);
+		db_size_rl = rl_union(db_size_rl, tmp);
+	}
+	return 0;
+}
+
+static struct range_list *size_from_db_type(struct expression *expr)
+{
+	int this_file_only = 0;
+	char *name;
+
+	name = get_member_name(expr);
+	if (!name && is_static(expr)) {
+		name = expr_to_var(expr);
+		this_file_only = 1;
+	}
+	if (!name)
+		return NULL;
+
+	if (this_file_only) {
+		db_size_rl = NULL;
+		run_sql(db_size_callback, NULL,
+			"select size from function_type_size where type = '%s' and file = '%s';",
+			name, get_filename());
+		if (db_size_rl)
+			return db_size_rl;
+		return NULL;
+	}
+
+	db_size_rl = NULL;
+	run_sql(db_size_callback, NULL,
+		"select size from type_size where type = '%s';",
+		name);
+	return db_size_rl;
+}
+
+static struct range_list *size_from_db_symbol(struct expression *expr)
+{
+	struct symbol *sym;
+
+	if (expr->type != EXPR_SYMBOL)
+		return NULL;
+	sym = expr->symbol;
+	if (!sym || !sym->ident ||
+	    !(sym->ctype.modifiers & MOD_TOPLEVEL) ||
+	    sym->ctype.modifiers & MOD_STATIC)
+		return NULL;
+
+	db_size_rl = NULL;
+	run_sql(db_size_callback, NULL,
+		"select value from data_info where file = 'extern' and data = '%s' and type = %d;",
+		sym->ident->name, BUF_SIZE);
+	return db_size_rl;
+}
+
+static struct range_list *size_from_db(struct expression *expr)
+{
+	struct range_list *rl;
+
+	rl = size_from_db_symbol(expr);
+	if (rl)
+		return rl;
+	return size_from_db_type(expr);
+}
+
+static void db_returns_buf_size(struct expression *expr, int param, char *unused, char *math)
+{
+	struct expression *call;
+	struct range_list *rl;
+
+	if (expr->type != EXPR_ASSIGNMENT)
+		return;
+	call = strip_expr(expr->right);
+
+	if (!parse_call_math_rl(call, math, &rl))
+		return;
+	rl = cast_rl(&int_ctype, rl);
+	set_state_expr(my_size_id, expr->left, alloc_estate_rl(rl));
+}
+
+static int get_real_array_size_from_type(struct symbol *type)
+{
+	sval_t sval;
+
+	if (!type)
+		return 0;
+	if (!type || type->type != SYM_ARRAY)
+		return 0;
+
+	if (!get_implied_value(type->array_size, &sval))
+		return 0;
+
+	return sval.value;
+}
+
+int get_real_array_size(struct expression *expr)
+{
+	if (!expr)
+		return 0;
+	if (expr->type == EXPR_PREOP && expr->op == '&')
+		expr = expr->unop;
+	if (expr->type == EXPR_BINOP) /* array elements foo[5] */
+		return 0;
+	return get_real_array_size_from_type(get_type(expr));
+}
+
+static int get_size_from_initializer(struct expression *expr)
+{
+	if (expr->type != EXPR_SYMBOL || !expr->symbol || !expr->symbol->initializer)
+		return 0;
+	if (expr->symbol->initializer == expr) /* int a = a; */
+		return 0;
+	return get_initializer_size(expr->symbol->initializer);
+}
+
+static struct range_list *get_stored_size_bytes(struct expression *expr)
+{
+	struct smatch_state *state;
+
+	state = get_state_expr(my_size_id, expr);
+	if (!state)
+		return NULL;
+	return estate_rl(state);
+}
+
+static int get_bytes_from_address(struct expression *expr)
+{
+	struct symbol *type;
+	int ret;
+
+	if (!option_spammy)
+		return 0;
+	if (expr->type != EXPR_PREOP || expr->op != '&')
+		return 0;
+	type = get_type(expr);
+	if (!type)
+		return 0;
+
+	if (type->type == SYM_PTR)
+		type = get_base_type(type);
+
+	ret = type_bytes(type);
+	if (ret == 1)
+		return 0;  /* ignore char pointers */
+
+	return ret;
+}
+
+static struct expression *remove_addr_fluff(struct expression *expr)
+{
+	struct expression *tmp;
+	sval_t sval;
+
+	expr = strip_expr(expr);
+
+	/* remove '&' and '*' operations that cancel */
+	while (expr && expr->type == EXPR_PREOP && expr->op == '&') {
+		tmp = strip_expr(expr->unop);
+		if (tmp->type != EXPR_PREOP)
+			break;
+		if (tmp->op != '*')
+			break;
+		expr = strip_expr(tmp->unop);
+	}
+
+	if (!expr)
+		return NULL;
+
+	/* "foo + 0" is just "foo" */
+	if (expr->type == EXPR_BINOP && expr->op == '+' &&
+	    get_value(expr->right, &sval) && sval.value == 0)
+		return expr->left;
+
+	return expr;
+}
+
+static int is_last_member_of_struct(struct symbol *sym, struct ident *member)
+{
+	struct symbol *tmp;
+	int i;
+
+	i = 0;
+	FOR_EACH_PTR_REVERSE(sym->symbol_list, tmp) {
+		if (i++ || !tmp->ident)
+			return 0;
+		if (tmp->ident == member)
+			return 1;
+		return 0;
+	} END_FOR_EACH_PTR_REVERSE(tmp);
+
+	return 0;
+}
+
+int last_member_is_resizable(struct symbol *sym)
+{
+	struct symbol *last_member;
+	struct symbol *type;
+	sval_t sval;
+
+	if (!sym || sym->type != SYM_STRUCT)
+		return 0;
+
+	last_member = last_ptr_list((struct ptr_list *)sym->symbol_list);
+	if (!last_member || !last_member->ident)
+		return 0;
+
+	type = get_real_base_type(last_member);
+	if (type->type == SYM_STRUCT)
+		return last_member_is_resizable(type);
+	if (type->type != SYM_ARRAY)
+		return 0;
+
+	if (!get_implied_value(type->array_size, &sval))
+		return 0;
+
+	if (sval.value != 0 && sval.value != 1)
+		return 0;
+
+	return 1;
+}
+
+static int get_stored_size_end_struct_bytes(struct expression *expr)
+{
+	struct symbol *sym;
+	struct symbol *base_sym;
+	struct smatch_state *state;
+
+	if (expr->type == EXPR_BINOP) /* array elements foo[5] */
+		return 0;
+
+	if (expr->type == EXPR_PREOP && expr->op == '&')
+		expr = strip_parens(expr->unop);
+
+	sym = expr_to_sym(expr);
+	if (!sym || !sym->ident)
+		return 0;
+	if (!type_bytes(sym))
+		return 0;
+	if (sym->type != SYM_NODE)
+		return 0;
+
+	base_sym = get_real_base_type(sym);
+	if (!base_sym || base_sym->type != SYM_PTR)
+		return 0;
+	base_sym = get_real_base_type(base_sym);
+	if (!base_sym || base_sym->type != SYM_STRUCT)
+		return 0;
+
+	if (!is_last_member_of_struct(base_sym, expr->member))
+		return 0;
+	if (!last_member_is_resizable(base_sym))
+		return 0;
+
+	state = get_state(my_size_id, sym->ident->name, sym);
+	if (!estate_to_size(state))
+		return 0;
+
+	return estate_to_size(state) - type_bytes(base_sym) + type_bytes(get_type(expr));
+}
+
+static struct range_list *alloc_int_rl(int value)
+{
+	sval_t sval = {
+		.type = &int_ctype,
+		{.value = value},
+	};
+
+	return alloc_rl(sval, sval);
+}
+
+struct range_list *get_array_size_bytes_rl(struct expression *expr)
+{
+	struct range_list *ret = NULL;
+	int size;
+
+	expr = remove_addr_fluff(expr);
+	if (!expr)
+		return NULL;
+
+	/* "BAR" */
+	if (expr->type == EXPR_STRING)
+		return alloc_int_rl(expr->string->length);
+
+	if (expr->type == EXPR_BINOP && expr->op == '+') {
+		sval_t offset;
+		struct symbol *type;
+		int bytes;
+
+		if (!get_implied_value(expr->right, &offset))
+			return NULL;
+		type = get_type(expr->left);
+		if (!type)
+			return NULL;
+		if (type->type != SYM_ARRAY && type->type != SYM_PTR)
+			return NULL;
+		type = get_real_base_type(type);
+		bytes = type_bytes(type);
+		if (bytes == 0)
+			return NULL;
+		offset.value *= bytes;
+		size = get_array_size_bytes(expr->left);
+		if (size <= 0)
+			return NULL;
+		return alloc_int_rl(size - offset.value);
+	}
+
+	/* buf[4] */
+	size = get_real_array_size(expr);
+	if (size)
+		return alloc_int_rl(elements_to_bytes(expr, size));
+
+	/* buf = malloc(1024); */
+	ret = get_stored_size_bytes(expr);
+	if (ret)
+		return ret;
+
+	size = get_stored_size_end_struct_bytes(expr);
+	if (size)
+		return alloc_int_rl(size);
+
+	/* char *foo = "BAR" */
+	size = get_size_from_initializer(expr);
+	if (size)
+		return alloc_int_rl(elements_to_bytes(expr, size));
+
+	size = get_bytes_from_address(expr);
+	if (size)
+		return alloc_int_rl(size);
+
+	ret = size_from_db(expr);
+	if (ret)
+		return ret;
+
+	return NULL;
+}
+
+int get_array_size_bytes(struct expression *expr)
+{
+	struct range_list *rl;
+	sval_t sval;
+
+	rl = get_array_size_bytes_rl(expr);
+	if (!rl_to_sval(rl, &sval))
+		return 0;
+	if (sval.uvalue >= INT_MAX)
+		return 0;
+	return sval.value;
+}
+
+int get_array_size_bytes_max(struct expression *expr)
+{
+	struct range_list *rl;
+	sval_t bytes;
+
+	rl = get_array_size_bytes_rl(expr);
+	if (!rl)
+		return 0;
+	bytes = rl_min(rl);
+	if (bytes.value < 0)
+		return 0;
+	bytes = rl_max(rl);
+	if (bytes.uvalue >= INT_MAX)
+		return 0;
+	return bytes.value;
+}
+
+int get_array_size_bytes_min(struct expression *expr)
+{
+	struct range_list *rl;
+	struct data_range *range;
+
+	rl = get_array_size_bytes_rl(expr);
+	if (!rl)
+		return 0;
+
+	FOR_EACH_PTR(rl, range) {
+		if (range->min.value <= 0)
+			return 0;
+		if (range->max.value <= 0)
+			return 0;
+		if (range->min.uvalue >= INT_MAX)
+			return 0;
+		return range->min.value;
+	} END_FOR_EACH_PTR(range);
+
+	return 0;
+}
+
+int get_array_size(struct expression *expr)
+{
+	if (!expr)
+		return 0;
+	return bytes_to_elements(expr, get_array_size_bytes_max(expr));
+}
+
+static struct expression *strip_ampersands(struct expression *expr)
+{
+	struct symbol *type;
+
+	if (expr->type != EXPR_PREOP)
+		return expr;
+	if (expr->op != '&')
+		return expr;
+	type = get_type(expr->unop);
+	if (!type || type->type != SYM_ARRAY)
+		return expr;
+	return expr->unop;
+}
+
+static void info_record_alloction(struct expression *buffer, struct range_list *rl)
+{
+	char *name;
+
+	if (!option_info)
+		return;
+
+	name = get_member_name(buffer);
+	if (!name && is_static(buffer))
+		name = expr_to_var(buffer);
+	if (!name)
+		return;
+	if (rl && !is_whole_rl(rl))
+		sql_insert_function_type_size(name, show_rl(rl));
+	else
+		sql_insert_function_type_size(name, "(-1)");
+
+	free_string(name);
+}
+
+static void store_alloc(struct expression *expr, struct range_list *rl)
+{
+	struct symbol *type;
+
+	rl = clone_rl(rl); // FIXME!!!
+	set_state_expr(my_size_id, expr, alloc_estate_rl(rl));
+
+	type = get_type(expr);
+	if (!type)
+		return;
+	if (type->type != SYM_PTR)
+		return;
+	type = get_real_base_type(type);
+	if (!type)
+		return;
+	if (type == &void_ctype)
+		return;
+	if (type->type != SYM_BASETYPE && type->type != SYM_PTR)
+		return;
+
+	info_record_alloction(expr, rl);
+}
+
+static void match_array_assignment(struct expression *expr)
+{
+	struct expression *left;
+	struct expression *right;
+	char *left_member, *right_member;
+	struct range_list *rl;
+	sval_t sval;
+
+	if (expr->op != '=')
+		return;
+	left = strip_expr(expr->left);
+	right = strip_expr(expr->right);
+	right = strip_ampersands(right);
+
+	if (!is_pointer(left))
+		return;
+	if (is_allocation_function(right))
+		return;
+
+	left_member = get_member_name(left);
+	right_member = get_member_name(right);
+	if (left_member && right_member && strcmp(left_member, right_member) == 0) {
+		free_string(left_member);
+		free_string(right_member);
+		return;
+	}
+	free_string(left_member);
+	free_string(right_member);
+
+	if (get_implied_value(right, &sval) && sval.value == 0) {
+		rl = alloc_int_rl(0);
+		goto store;
+	}
+
+	rl = get_array_size_bytes_rl(right);
+	if (!rl && __in_fake_assign)
+		return;
+
+store:
+	store_alloc(left, rl);
+}
+
+static void match_alloc(const char *fn, struct expression *expr, void *_size_arg)
+{
+	int size_arg = PTR_INT(_size_arg);
+	struct expression *right;
+	struct expression *arg;
+	struct range_list *rl;
+
+	right = strip_expr(expr->right);
+	arg = get_argument_from_call_expr(right->args, size_arg);
+	get_absolute_rl(arg, &rl);
+	rl = cast_rl(&int_ctype, rl);
+	store_alloc(expr->left, rl);
+}
+
+static void match_calloc(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *right;
+	struct expression *arg;
+	sval_t elements;
+	sval_t size;
+
+	right = strip_expr(expr->right);
+	arg = get_argument_from_call_expr(right->args, 0);
+	if (!get_implied_value(arg, &elements))
+		return; // FIXME!!!
+	arg = get_argument_from_call_expr(right->args, 1);
+	if (get_implied_value(arg, &size))
+		store_alloc(expr->left, size_to_rl(elements.value * size.value));
+	else
+		store_alloc(expr->left, size_to_rl(-1));
+}
+
+static void match_page(const char *fn, struct expression *expr, void *_unused)
+{
+	sval_t page_size = {
+		.type = &int_ctype,
+		{.value = 4096},
+	};
+
+	store_alloc(expr->left, alloc_rl(page_size, page_size));
+}
+
+static void match_strndup(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *fn_expr;
+	struct expression *size_expr;
+	sval_t size;
+
+	fn_expr = strip_expr(expr->right);
+	size_expr = get_argument_from_call_expr(fn_expr->args, 1);
+	if (get_implied_max(size_expr, &size)) {
+		size.value++;
+		store_alloc(expr->left, size_to_rl(size.value));
+	} else {
+		store_alloc(expr->left, size_to_rl(-1));
+	}
+
+}
+
+static void match_alloc_pages(const char *fn, struct expression *expr, void *_order_arg)
+{
+	int order_arg = PTR_INT(_order_arg);
+	struct expression *right;
+	struct expression *arg;
+	sval_t sval;
+
+	right = strip_expr(expr->right);
+	arg = get_argument_from_call_expr(right->args, order_arg);
+	if (!get_implied_value(arg, &sval))
+		return;
+	if (sval.value < 0 || sval.value > 10)
+		return;
+
+	sval.type = &int_ctype;
+	sval.value = 1 << sval.value;
+	sval.value *= 4096;
+
+	store_alloc(expr->left, alloc_rl(sval, sval));
+}
+
+static int is_type_bytes(struct range_list *rl, struct expression *arg)
+{
+	struct symbol *type;
+	sval_t sval;
+
+	if (!rl_to_sval(rl, &sval))
+		return 0;
+
+	type = get_type(arg);
+	if (!type)
+		return 0;
+	if (type->type != SYM_PTR)
+		return 0;
+	type = get_real_base_type(type);
+	if (type->type != SYM_STRUCT &&
+	    type->type != SYM_UNION)
+		return 0;
+	if (sval.value != type_bytes(type))
+		return 0;
+	return 1;
+}
+
+static void match_call(struct expression *expr)
+{
+	struct expression *arg;
+	struct symbol *type;
+	struct range_list *rl;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+		type = get_type(arg);
+		if (!type || (type->type != SYM_PTR && type->type != SYM_ARRAY))
+			continue;
+		rl = get_array_size_bytes_rl(arg);
+		if (!rl)
+			continue;
+		if (is_whole_rl(rl))
+			continue;
+		if (is_type_bytes(rl, arg))
+			continue;
+		sql_insert_caller_info(expr, BUF_SIZE, i, "$", show_rl(rl));
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
+{
+	if (sm->state == &merged ||
+	    strcmp(sm->state->name, "(-1)") == 0 ||
+	    strcmp(sm->state->name, "empty") == 0 ||
+	    strcmp(sm->state->name, "0") == 0)
+		return;
+	sql_insert_caller_info(call, BUF_SIZE, param, printed_name, sm->state->name);
+}
+
+/*
+ * This is slightly (very) weird because half of this stuff is handled in
+ * smatch_parse_call_math.c which is poorly named.  But anyway, add some buf
+ * sizes here.
+ *
+ */
+static void print_returned_allocations(int return_id, char *return_ranges, struct expression *expr)
+{
+	char buf[16];
+	int size;
+
+	size = get_array_size_bytes(expr);
+	if (!size)
+		return;
+
+	snprintf(buf, sizeof(buf), "%d", size);
+	sql_insert_return_states(return_id, return_ranges, BUF_SIZE, -1, "", buf);
+}
+
+static void record_global_size(struct symbol *sym)
+{
+	int bytes;
+	char buf[16];
+
+	if (!sym->ident)
+		return;
+
+	if (!(sym->ctype.modifiers & MOD_TOPLEVEL) ||
+	    sym->ctype.modifiers & MOD_STATIC)
+		return;
+
+	bytes = get_array_size_bytes(symbol_expression(sym));
+	if (bytes <= 1)
+		return;
+
+	snprintf(buf, sizeof(buf), "%d", bytes);
+	sql_insert_data_info_var_sym(sym->ident->name, sym, BUF_SIZE, buf);
+}
+
+void register_buf_size(int id)
+{
+	my_size_id = id;
+
+	add_unmatched_state_hook(my_size_id, &unmatched_size_state);
+
+	select_caller_info_hook(set_param_buf_size, BUF_SIZE);
+	select_return_states_hook(BUF_SIZE, &db_returns_buf_size);
+	add_split_return_callback(print_returned_allocations);
+
+	allocation_funcs = create_function_hashtable(100);
+	add_allocation_function("malloc", &match_alloc, 0);
+	add_allocation_function("calloc", &match_calloc, 0);
+	add_allocation_function("memdup", &match_alloc, 1);
+	add_allocation_function("realloc", &match_alloc, 1);
+	if (option_project == PROJ_KERNEL) {
+		add_allocation_function("kmalloc", &match_alloc, 0);
+		add_allocation_function("kmalloc_node", &match_alloc, 0);
+		add_allocation_function("kzalloc", &match_alloc, 0);
+		add_allocation_function("kzalloc_node", &match_alloc, 0);
+		add_allocation_function("vmalloc", &match_alloc, 0);
+		add_allocation_function("__vmalloc", &match_alloc, 0);
+		add_allocation_function("kcalloc", &match_calloc, 0);
+		add_allocation_function("kmalloc_array", &match_calloc, 0);
+		add_allocation_function("drm_malloc_ab", &match_calloc, 0);
+		add_allocation_function("drm_calloc_large", &match_calloc, 0);
+		add_allocation_function("sock_kmalloc", &match_alloc, 1);
+		add_allocation_function("kmemdup", &match_alloc, 1);
+		add_allocation_function("kmemdup_user", &match_alloc, 1);
+		add_allocation_function("dma_alloc_attrs", &match_alloc, 1);
+		add_allocation_function("pci_alloc_consistent", &match_alloc, 1);
+		add_allocation_function("pci_alloc_coherent", &match_alloc, 1);
+		add_allocation_function("devm_kmalloc", &match_alloc, 1);
+		add_allocation_function("devm_kzalloc", &match_alloc, 1);
+		add_allocation_function("krealloc", &match_alloc, 1);
+		add_allocation_function("__alloc_bootmem", &match_alloc, 0);
+		add_allocation_function("alloc_bootmem", &match_alloc, 0);
+		add_allocation_function("kmap", &match_page, 0);
+		add_allocation_function("get_zeroed_page", &match_page, 0);
+		add_allocation_function("alloc_pages", &match_alloc_pages, 1);
+		add_allocation_function("alloc_pages_current", &match_alloc_pages, 1);
+		add_allocation_function("__get_free_pages", &match_alloc_pages, 1);
+	}
+
+	add_allocation_function("strndup", match_strndup, 0);
+	if (option_project == PROJ_KERNEL)
+		add_allocation_function("kstrndup", match_strndup, 0);
+
+	add_modification_hook(my_size_id, &set_size_undefined);
+
+	add_merge_hook(my_size_id, &merge_size_func);
+
+	if (option_info)
+		add_hook(record_global_size, BASE_HOOK);
+}
+
+void register_buf_size_late(int id)
+{
+	/* has to happen after match_alloc() */
+	add_hook(&match_array_assignment, ASSIGNMENT_HOOK);
+
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+	add_member_info_callback(my_size_id, struct_member_callback);
+}
diff --git a/usr/src/tools/smatch/src/smatch_capped.c b/usr/src/tools/smatch/src/smatch_capped.c
new file mode 100644
index 0000000000..a42303d4b7
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_capped.c
@@ -0,0 +1,310 @@
+/*
+ * Copyright (C) 2011 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is trying to make a list of the variables which
+ * have capped values.  Sometimes we don't know what the
+ * cap is, for example if we are comparing variables but
+ * we don't know the values of the variables.  In that
+ * case we only know that our variable is capped and we
+ * sort that information here.
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(capped);
+STATE(uncapped);
+
+static void set_uncapped(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, &uncapped);
+}
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	struct smatch_state *state;
+
+	state = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+	if (state && !estate_is_whole(state))
+		return &capped;
+	return &uncapped;
+}
+
+static int is_capped_macro(struct expression *expr)
+{
+	char *name;
+
+	name = get_macro_name(expr->pos);
+	if (!name)
+		return 0;
+
+	if (strcmp(name, "min") == 0)
+		return 1;
+	if (strcmp(name, "MIN") == 0)
+		return 1;
+	if (strcmp(name, "min_t") == 0)
+		return 1;
+
+	return 0;
+}
+
+int is_capped(struct expression *expr)
+{
+	sval_t dummy;
+
+	expr = strip_expr(expr);
+	while (expr && expr->type == EXPR_POSTOP) {
+		expr = strip_expr(expr->unop);
+	}
+	if (!expr)
+		return 0;
+
+	if (get_hard_max(expr, &dummy))
+		return 1;
+
+	if (is_capped_macro(expr))
+		return 1;
+
+	if (expr->type == EXPR_BINOP) {
+		struct range_list *left_rl, *right_rl;
+
+		if (expr->op == '&')
+			return 1;
+		if (expr->op == SPECIAL_RIGHTSHIFT)
+			return 1;
+		if (expr->op == '%')
+			return is_capped(expr->right);
+		if (!is_capped(expr->left))
+			return 0;
+		if (expr->op == '/')
+			return 1;
+		if (!is_capped(expr->right))
+			return 0;
+		if (expr->op == '*') {
+			get_absolute_rl(expr->left, &left_rl);
+			get_absolute_rl(expr->right, &right_rl);
+			if (sval_is_negative(rl_min(left_rl)) ||
+			    sval_is_negative(rl_min(right_rl)))
+				return 0;
+		}
+		return 1;
+	}
+	if (get_state_expr(my_id, expr) == &capped)
+		return 1;
+	return 0;
+}
+
+int is_capped_var_sym(const char *name, struct symbol *sym)
+{
+	if (get_state(my_id, name, sym) == &capped)
+		return 1;
+	return 0;
+}
+
+void set_param_capped_data(const char *name, struct symbol *sym, char *key, char *value)
+{
+	char fullname[256];
+
+	if (strncmp(key, "$", 1))
+		return;
+	snprintf(fullname, 256, "%s%s", name, key + 1);
+	set_state(my_id, fullname, sym, &capped);
+}
+
+static void match_condition(struct expression *expr)
+{
+	struct smatch_state *left_true = NULL;
+	struct smatch_state *left_false = NULL;
+	struct smatch_state *right_true = NULL;
+	struct smatch_state *right_false = NULL;
+
+
+	if (expr->type != EXPR_COMPARE)
+		return;
+
+	switch (expr->op) {
+	case '<':
+	case SPECIAL_LTE:
+	case SPECIAL_UNSIGNED_LT:
+	case SPECIAL_UNSIGNED_LTE:
+		left_true = &capped;
+		right_false = &capped;
+		break;
+	case '>':
+	case SPECIAL_GTE:
+	case SPECIAL_UNSIGNED_GT:
+	case SPECIAL_UNSIGNED_GTE:
+		left_false = &capped;
+		right_true = &capped;
+		break;
+	case SPECIAL_EQUAL:
+		left_true = &capped;
+		right_true = &capped;
+		break;
+	case SPECIAL_NOTEQUAL:
+		left_false = &capped;
+		right_false = &capped;
+		break;
+
+	default:
+		return;
+	}
+
+	set_true_false_states_expr(my_id, expr->left, left_true, left_false);
+	set_true_false_states_expr(my_id, expr->right, right_true, right_false);
+}
+
+static void match_assign(struct expression *expr)
+{
+	if (is_capped(expr->right)) {
+		set_state_expr(my_id, expr->left, &capped);
+	} else {
+		if (get_state_expr(my_id, expr->left))
+			set_state_expr(my_id, expr->left, &uncapped);
+	}
+}
+
+static void match_caller_info(struct expression *expr)
+{
+	struct expression *tmp;
+	sval_t sval;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, tmp) {
+		i++;
+		if (get_implied_value(tmp, &sval))
+			continue;
+		if (!is_capped(tmp))
+			continue;
+		sql_insert_caller_info(expr, CAPPED_DATA, i, "$", "1");
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
+{
+	struct smatch_state *estate;
+	sval_t sval;
+
+	if (sm->state != &capped)
+		return;
+	estate = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+	if (estate_get_single_value(estate, &sval))
+		return;
+	sql_insert_caller_info(call, CAPPED_DATA, param, printed_name, "1");
+}
+
+static void print_return_implies_capped(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct smatch_state *orig, *estate;
+	struct sm_state *sm;
+	struct symbol *ret_sym;
+	const char *param_name;
+	char *return_str;
+	int param;
+	sval_t sval;
+	bool return_found = false;
+
+	expr = strip_expr(expr);
+	return_str = expr_to_str(expr);
+	ret_sym = expr_to_sym(expr);
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (sm->state != &capped)
+			continue;
+
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+
+		estate = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+		if (estate_get_single_value(estate, &sval))
+			continue;
+
+		orig = get_state_stree(get_start_states(), my_id, sm->name, sm->sym);
+		if (orig == &capped)
+			continue;
+
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+
+		sql_insert_return_states(return_id, return_ranges, CAPPED_DATA,
+					 param, param_name, "1");
+	} END_FOR_EACH_SM(sm);
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (!ret_sym)
+			break;
+		if (ret_sym != sm->sym)
+			continue;
+
+		param_name = state_name_to_param_name(sm->name, return_str);
+		if (!param_name)
+			continue;
+		if (strcmp(param_name, "$") == 0)
+			return_found = true;
+		sql_insert_return_states(return_id, return_ranges, CAPPED_DATA,
+					 -1, param_name, "1");
+	} END_FOR_EACH_SM(sm);
+
+	if (return_found)
+		goto free_string;
+
+	if (option_project == PROJ_KERNEL && get_function() &&
+	    strstr(get_function(), "nla_get_"))
+		sql_insert_return_states(return_id, return_ranges, CAPPED_DATA,
+					 -1, "$", "1");
+
+free_string:
+	free_string(return_str);
+}
+
+static void db_return_states_capped(struct expression *expr, int param, char *key, char *value)
+{
+	char *name;
+	struct symbol *sym;
+
+	name = return_state_to_var_sym(expr, param, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	set_state(my_id, name, sym, &capped);
+free:
+	free_string(name);
+}
+
+void register_capped(int id)
+{
+	my_id = id;
+
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	select_caller_info_hook(set_param_capped_data, CAPPED_DATA);
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_modification_hook(my_id, &set_uncapped);
+
+	add_hook(&match_caller_info, FUNCTION_CALL_HOOK);
+	add_member_info_callback(my_id, struct_member_callback);
+
+	add_split_return_callback(print_return_implies_capped);
+	select_return_states_hook(CAPPED_DATA, &db_return_states_capped);
+}
diff --git a/usr/src/tools/smatch/src/smatch_common_functions.c b/usr/src/tools/smatch/src/smatch_common_functions.c
new file mode 100644
index 0000000000..7c3446ec97
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_common_functions.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int match_strlen(struct expression *call, void *unused, struct range_list **rl)
+{
+	struct expression *str;
+	unsigned long max;
+
+	str = get_argument_from_call_expr(call->args, 0);
+	if (get_implied_strlen(str, rl) && sval_is_positive(rl_min(*rl))) {
+		*rl = cast_rl(&ulong_ctype, *rl);
+		return 1;
+	}
+	/* smatch_strlen.c is not very complete */
+	max = get_array_size_bytes_max(str);
+	if (max == 0) {
+		*rl = alloc_rl(sval_type_val(&ulong_ctype, 0),
+			       sval_type_val(&ulong_ctype, STRLEN_MAX_RET));
+	} else {
+		max--;
+		*rl = alloc_rl(sval_type_val(&ulong_ctype, 0),
+			       sval_type_val(&ulong_ctype, max));
+	}
+	return 1;
+}
+
+static int match_strnlen(struct expression *call, void *unused, struct range_list **rl)
+{
+	struct expression *limit;
+	sval_t fixed;
+	sval_t bound;
+	sval_t ulong_max = sval_type_val(&ulong_ctype, ULONG_MAX);
+
+	match_strlen(call, NULL, rl);
+	limit = get_argument_from_call_expr(call->args, 1);
+	if (!get_implied_max(limit, &bound))
+		return 1;
+	if (sval_cmp(bound, ulong_max) == 0)
+		return 1;
+	if (rl_to_sval(*rl, &fixed) && sval_cmp(fixed, bound) >= 0) {
+		*rl = alloc_rl(bound, bound);
+		return 1;
+	}
+
+	bound.value++;
+	*rl = remove_range(*rl, bound, ulong_max);
+
+	return 1;
+}
+
+static int match_sprintf(struct expression *call, void *_arg, struct range_list **rl)
+{
+	int str_arg = PTR_INT(_arg);
+	int size;
+
+	size = get_formatted_string_size(call, str_arg);
+	if (size <= 0) {
+		*rl = alloc_whole_rl(&ulong_ctype);
+	} else {
+		/* FIXME:  This is bogus.  get_formatted_string_size() should be
+		   returning a range_list.  Also it should not add the NUL. */
+		size--;
+		*rl = alloc_rl(ll_to_sval(0), ll_to_sval(size));
+	}
+	return 1;
+}
+
+void register_common_functions(int id)
+{
+	/*
+	 * When you add a new function here, then don't forget to delete it from
+	 * the database and smatch_data/.
+	 */
+	add_implied_return_hook("strlen", &match_strlen, NULL);
+	add_implied_return_hook("strnlen", &match_strnlen, NULL);
+	add_implied_return_hook("sprintf", &match_sprintf, INT_PTR(1));
+	add_implied_return_hook("snprintf", &match_sprintf, INT_PTR(2));
+}
diff --git a/usr/src/tools/smatch/src/smatch_comparison.c b/usr/src/tools/smatch/src/smatch_comparison.c
new file mode 100644
index 0000000000..51b4a45487
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_comparison.c
@@ -0,0 +1,2620 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The point here is to store the relationships between two variables.
+ * Ie:  y > x.
+ * To do that we create a state with the two variables in alphabetical order:
+ * ->name = "x vs y" and the state would be "<".  On the false path the state
+ * would be ">=".
+ *
+ * Part of the trick of it is that if x or y is modified then we need to reset
+ * the state.  We need to keep a list of all the states which depend on x and
+ * all the states which depend on y.  The link_id code handles this.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int compare_id;
+static int link_id;
+static int inc_dec_id;
+static int inc_dec_link_id;
+
+static void add_comparison(struct expression *left, int comparison, struct expression *right);
+
+/* for handling for loops */
+STATE(start);
+STATE(incremented);
+
+ALLOCATOR(compare_data, "compare data");
+
+static struct symbol *vsl_to_sym(struct var_sym_list *vsl)
+{
+	struct var_sym *vs;
+
+	if (!vsl)
+		return NULL;
+	if (ptr_list_size((struct ptr_list *)vsl) != 1)
+		return NULL;
+	vs = first_ptr_list((struct ptr_list *)vsl);
+	return vs->sym;
+}
+
+struct smatch_state *alloc_compare_state(
+		struct expression *left,
+		const char *left_var, struct var_sym_list *left_vsl,
+		int comparison,
+		struct expression *right,
+		const char *right_var, struct var_sym_list *right_vsl)
+{
+	struct smatch_state *state;
+	struct compare_data *data;
+
+	state = __alloc_smatch_state(0);
+	state->name = alloc_sname(show_special(comparison));
+	data = __alloc_compare_data(0);
+	data->left = left;
+	data->left_var = alloc_sname(left_var);
+	data->left_vsl = clone_var_sym_list(left_vsl);
+	data->comparison = comparison;
+	data->right = right;
+	data->right_var = alloc_sname(right_var);
+	data->right_vsl = clone_var_sym_list(right_vsl);
+	state->data = data;
+	return state;
+}
+
+int state_to_comparison(struct smatch_state *state)
+{
+	if (!state || !state->data)
+		return 0;
+	return ((struct compare_data *)state->data)->comparison;
+}
+
+/*
+ * flip_comparison() reverses the op left and right.  So "x >= y" becomes "y <= x".
+ */
+int flip_comparison(int op)
+{
+	switch (op) {
+	case 0:
+		return 0;
+	case '<':
+		return '>';
+	case SPECIAL_UNSIGNED_LT:
+		return SPECIAL_UNSIGNED_GT;
+	case SPECIAL_LTE:
+		return SPECIAL_GTE;
+	case SPECIAL_UNSIGNED_LTE:
+		return SPECIAL_UNSIGNED_GTE;
+	case SPECIAL_EQUAL:
+		return SPECIAL_EQUAL;
+	case SPECIAL_NOTEQUAL:
+		return SPECIAL_NOTEQUAL;
+	case SPECIAL_GTE:
+		return SPECIAL_LTE;
+	case SPECIAL_UNSIGNED_GTE:
+		return SPECIAL_UNSIGNED_LTE;
+	case '>':
+		return '<';
+	case SPECIAL_UNSIGNED_GT:
+		return SPECIAL_UNSIGNED_LT;
+	default:
+		sm_perror("unhandled comparison %d", op);
+		return op;
+	}
+}
+
+int negate_comparison(int op)
+{
+	switch (op) {
+	case 0:
+		return 0;
+	case '<':
+		return SPECIAL_GTE;
+	case SPECIAL_UNSIGNED_LT:
+		return SPECIAL_UNSIGNED_GTE;
+	case SPECIAL_LTE:
+		return '>';
+	case SPECIAL_UNSIGNED_LTE:
+		return SPECIAL_UNSIGNED_GT;
+	case SPECIAL_EQUAL:
+		return SPECIAL_NOTEQUAL;
+	case SPECIAL_NOTEQUAL:
+		return SPECIAL_EQUAL;
+	case SPECIAL_GTE:
+		return '<';
+	case SPECIAL_UNSIGNED_GTE:
+		return SPECIAL_UNSIGNED_LT;
+	case '>':
+		return SPECIAL_LTE;
+	case SPECIAL_UNSIGNED_GT:
+		return SPECIAL_UNSIGNED_LTE;
+	default:
+		sm_perror("unhandled comparison %d", op);
+		return op;
+	}
+}
+
+static int rl_comparison(struct range_list *left_rl, struct range_list *right_rl)
+{
+	sval_t left_min, left_max, right_min, right_max;
+	struct symbol *type = &int_ctype;
+
+	if (!left_rl || !right_rl)
+		return 0;
+
+	if (type_positive_bits(rl_type(left_rl)) > type_positive_bits(type))
+		type = rl_type(left_rl);
+	if (type_positive_bits(rl_type(right_rl)) > type_positive_bits(type))
+		type = rl_type(right_rl);
+
+	left_rl = cast_rl(type, left_rl);
+	right_rl = cast_rl(type, right_rl);
+
+	left_min = rl_min(left_rl);
+	left_max = rl_max(left_rl);
+	right_min = rl_min(right_rl);
+	right_max = rl_max(right_rl);
+
+	if (left_min.value == left_max.value &&
+	    right_min.value == right_max.value &&
+	    left_min.value == right_min.value)
+		return SPECIAL_EQUAL;
+
+	if (sval_cmp(left_max, right_min) < 0)
+		return '<';
+	if (sval_cmp(left_max, right_min) == 0)
+		return SPECIAL_LTE;
+	if (sval_cmp(left_min, right_max) > 0)
+		return '>';
+	if (sval_cmp(left_min, right_max) == 0)
+		return SPECIAL_GTE;
+
+	return 0;
+}
+
+static int comparison_from_extra(struct expression *a, struct expression *b)
+{
+	struct range_list *left, *right;
+
+	if (!get_implied_rl(a, &left))
+		return 0;
+	if (!get_implied_rl(b, &right))
+		return 0;
+
+	return rl_comparison(left, right);
+}
+
+static struct range_list *get_orig_rl(struct var_sym_list *vsl)
+{
+	struct symbol *sym;
+	struct smatch_state *state;
+
+	if (!vsl)
+		return NULL;
+	sym = vsl_to_sym(vsl);
+	if (!sym || !sym->ident)
+		return NULL;
+	state = get_orig_estate(sym->ident->name, sym);
+	return estate_rl(state);
+}
+
+static struct smatch_state *unmatched_comparison(struct sm_state *sm)
+{
+	struct compare_data *data = sm->state->data;
+	struct range_list *left_rl, *right_rl;
+	int op;
+
+	if (!data)
+		return &undefined;
+
+	if (strstr(data->left_var, " orig"))
+		left_rl = get_orig_rl(data->left_vsl);
+	else if (!get_implied_rl_var_sym(data->left_var, vsl_to_sym(data->left_vsl), &left_rl))
+		return &undefined;
+
+	if (strstr(data->right_var, " orig"))
+		right_rl = get_orig_rl(data->right_vsl);
+	else if (!get_implied_rl_var_sym(data->right_var, vsl_to_sym(data->right_vsl), &right_rl))
+		return &undefined;
+
+	op = rl_comparison(left_rl, right_rl);
+	if (op)
+		return alloc_compare_state(
+				data->left, data->left_var, data->left_vsl,
+				op,
+				data->right, data->right_var, data->right_vsl);
+
+	return &undefined;
+}
+
+/* remove_unsigned_from_comparison() is obviously a hack. */
+int remove_unsigned_from_comparison(int op)
+{
+	switch (op) {
+	case SPECIAL_UNSIGNED_LT:
+		return '<';
+	case SPECIAL_UNSIGNED_LTE:
+		return SPECIAL_LTE;
+	case SPECIAL_UNSIGNED_GTE:
+		return SPECIAL_GTE;
+	case SPECIAL_UNSIGNED_GT:
+		return '>';
+	default:
+		return op;
+	}
+}
+
+/*
+ * This is for when you merge states "a < b" and "a == b", the result is that
+ * we can say for sure, "a <= b" after the merge.
+ */
+int merge_comparisons(int one, int two)
+{
+	int LT, EQ, GT;
+
+	if (!one || !two)
+		return 0;
+
+	one = remove_unsigned_from_comparison(one);
+	two = remove_unsigned_from_comparison(two);
+
+	if (one == two)
+		return one;
+
+	LT = EQ = GT = 0;
+
+	switch (one) {
+	case '<':
+		LT = 1;
+		break;
+	case SPECIAL_LTE:
+		LT = 1;
+		EQ = 1;
+		break;
+	case SPECIAL_EQUAL:
+		EQ = 1;
+		break;
+	case SPECIAL_GTE:
+		GT = 1;
+		EQ = 1;
+		break;
+	case '>':
+		GT = 1;
+	}
+
+	switch (two) {
+	case '<':
+		LT = 1;
+		break;
+	case SPECIAL_LTE:
+		LT = 1;
+		EQ = 1;
+		break;
+	case SPECIAL_EQUAL:
+		EQ = 1;
+		break;
+	case SPECIAL_GTE:
+		GT = 1;
+		EQ = 1;
+		break;
+	case '>':
+		GT = 1;
+	}
+
+	if (LT && EQ && GT)
+		return 0;
+	if (LT && EQ)
+		return SPECIAL_LTE;
+	if (LT && GT)
+		return SPECIAL_NOTEQUAL;
+	if (LT)
+		return '<';
+	if (EQ && GT)
+		return SPECIAL_GTE;
+	if (GT)
+		return '>';
+	return 0;
+}
+
+/*
+ * This is for if you have "a < b" and "b <= c".  Or in other words,
+ * "a < b <= c".  You would call this like get_combined_comparison('<', '<=').
+ * The return comparison would be '<'.
+ *
+ * This function is different from merge_comparisons(), for example:
+ * merge_comparison('<', '==') returns '<='
+ * get_combined_comparison('<', '==') returns '<'
+ */
+int combine_comparisons(int left_compare, int right_compare)
+{
+	int LT, EQ, GT;
+
+	left_compare = remove_unsigned_from_comparison(left_compare);
+	right_compare = remove_unsigned_from_comparison(right_compare);
+
+	LT = EQ = GT = 0;
+
+	switch (left_compare) {
+	case '<':
+		LT++;
+		break;
+	case SPECIAL_LTE:
+		LT++;
+		EQ++;
+		break;
+	case SPECIAL_EQUAL:
+		return right_compare;
+	case SPECIAL_GTE:
+		GT++;
+		EQ++;
+		break;
+	case '>':
+		GT++;
+	}
+
+	switch (right_compare) {
+	case '<':
+		LT++;
+		break;
+	case SPECIAL_LTE:
+		LT++;
+		EQ++;
+		break;
+	case SPECIAL_EQUAL:
+		return left_compare;
+	case SPECIAL_GTE:
+		GT++;
+		EQ++;
+		break;
+	case '>':
+		GT++;
+	}
+
+	if (LT == 2) {
+		if (EQ == 2)
+			return SPECIAL_LTE;
+		return '<';
+	}
+
+	if (GT == 2) {
+		if (EQ == 2)
+			return SPECIAL_GTE;
+		return '>';
+	}
+	return 0;
+}
+
+int filter_comparison(int orig, int op)
+{
+	if (orig == op)
+		return orig;
+
+	orig = remove_unsigned_from_comparison(orig);
+	op = remove_unsigned_from_comparison(op);
+
+	switch (orig) {
+	case 0:
+		return op;
+	case '<':
+		switch (op) {
+		case '<':
+		case SPECIAL_LTE:
+		case SPECIAL_NOTEQUAL:
+			return '<';
+		}
+		return 0;
+	case SPECIAL_LTE:
+		switch (op) {
+		case '<':
+		case SPECIAL_LTE:
+		case SPECIAL_EQUAL:
+			return op;
+		case SPECIAL_NOTEQUAL:
+			return '<';
+		}
+		return 0;
+	case SPECIAL_EQUAL:
+		switch (op) {
+		case SPECIAL_LTE:
+		case SPECIAL_EQUAL:
+		case SPECIAL_GTE:
+		case SPECIAL_UNSIGNED_LTE:
+		case SPECIAL_UNSIGNED_GTE:
+			return SPECIAL_EQUAL;
+		}
+		return 0;
+	case SPECIAL_NOTEQUAL:
+		switch (op) {
+		case '<':
+		case SPECIAL_LTE:
+			return '<';
+		case SPECIAL_UNSIGNED_LT:
+		case SPECIAL_UNSIGNED_LTE:
+			return SPECIAL_UNSIGNED_LT;
+		case SPECIAL_NOTEQUAL:
+			return op;
+		case '>':
+		case SPECIAL_GTE:
+			return '>';
+		case SPECIAL_UNSIGNED_GT:
+		case SPECIAL_UNSIGNED_GTE:
+			return SPECIAL_UNSIGNED_GT;
+		}
+		return 0;
+	case SPECIAL_GTE:
+		switch (op) {
+		case SPECIAL_LTE:
+			return SPECIAL_EQUAL;
+		case '>':
+		case SPECIAL_GTE:
+		case SPECIAL_EQUAL:
+			return op;
+		case SPECIAL_NOTEQUAL:
+			return '>';
+		}
+		return 0;
+	case '>':
+		switch (op) {
+		case '>':
+		case SPECIAL_GTE:
+		case SPECIAL_NOTEQUAL:
+			return '>';
+		}
+		return 0;
+	case SPECIAL_UNSIGNED_LT:
+		switch (op) {
+		case SPECIAL_UNSIGNED_LT:
+		case SPECIAL_UNSIGNED_LTE:
+		case SPECIAL_NOTEQUAL:
+			return SPECIAL_UNSIGNED_LT;
+		}
+		return 0;
+	case SPECIAL_UNSIGNED_LTE:
+		switch (op) {
+		case SPECIAL_UNSIGNED_LT:
+		case SPECIAL_UNSIGNED_LTE:
+		case SPECIAL_EQUAL:
+			return op;
+		case SPECIAL_NOTEQUAL:
+			return SPECIAL_UNSIGNED_LT;
+		case SPECIAL_UNSIGNED_GTE:
+			return SPECIAL_EQUAL;
+		}
+		return 0;
+	case SPECIAL_UNSIGNED_GTE:
+		switch (op) {
+		case SPECIAL_UNSIGNED_LTE:
+			return SPECIAL_EQUAL;
+		case SPECIAL_NOTEQUAL:
+			return SPECIAL_UNSIGNED_GT;
+		case SPECIAL_EQUAL:
+		case SPECIAL_UNSIGNED_GTE:
+		case SPECIAL_UNSIGNED_GT:
+			return op;
+		}
+		return 0;
+	case SPECIAL_UNSIGNED_GT:
+		switch (op) {
+		case SPECIAL_UNSIGNED_GT:
+		case SPECIAL_UNSIGNED_GTE:
+		case SPECIAL_NOTEQUAL:
+			return SPECIAL_UNSIGNED_GT;
+		}
+		return 0;
+	}
+	return 0;
+}
+
+static void pre_merge_hook(struct sm_state *sm)
+{
+	struct compare_data *data = sm->state->data;
+	int other;
+
+	if (!data)
+		return;
+	other = get_comparison(data->left, data->right);
+	if (!other)
+		return;
+
+	set_state(compare_id, sm->name, NULL,
+		  alloc_compare_state(data->left, data->left_var, data->left_vsl,
+				      other,
+				      data->right, data->right_var, data->right_vsl));
+}
+
+struct smatch_state *merge_compare_states(struct smatch_state *s1, struct smatch_state *s2)
+{
+	struct compare_data *data = s1->data;
+	int op;
+
+	op = merge_comparisons(state_to_comparison(s1), state_to_comparison(s2));
+	if (op)
+		return alloc_compare_state(
+				data->left, data->left_var, data->left_vsl,
+				op,
+				data->right, data->right_var, data->right_vsl);
+	return &undefined;
+}
+
+static struct smatch_state *alloc_link_state(struct string_list *links)
+{
+	struct smatch_state *state;
+	static char buf[256];
+	char *tmp;
+	int i;
+
+	state = __alloc_smatch_state(0);
+
+	i = 0;
+	FOR_EACH_PTR(links, tmp) {
+		if (!i++) {
+			snprintf(buf, sizeof(buf), "%s", tmp);
+		} else {
+			append(buf, ", ", sizeof(buf));
+			append(buf, tmp, sizeof(buf));
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+	state->name = alloc_sname(buf);
+	state->data = links;
+	return state;
+}
+
+static void save_start_states(struct statement *stmt)
+{
+	struct symbol *param;
+	char orig[64];
+	char state_name[128];
+	struct smatch_state *state;
+	struct string_list *links;
+	char *link;
+
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, param) {
+		struct var_sym_list *left_vsl = NULL;
+		struct var_sym_list *right_vsl = NULL;
+
+		if (!param->ident)
+			continue;
+		snprintf(orig, sizeof(orig), "%s orig", param->ident->name);
+		snprintf(state_name, sizeof(state_name), "%s vs %s", param->ident->name, orig);
+		add_var_sym(&left_vsl, param->ident->name, param);
+		add_var_sym(&right_vsl, orig, param);
+		state = alloc_compare_state(
+				NULL, param->ident->name, left_vsl,
+				SPECIAL_EQUAL,
+				NULL, alloc_sname(orig), right_vsl);
+		set_state(compare_id, state_name, NULL, state);
+
+		link = alloc_sname(state_name);
+		links = NULL;
+		insert_string(&links, link);
+		state = alloc_link_state(links);
+		set_state(link_id, param->ident->name, param, state);
+	} END_FOR_EACH_PTR(param);
+}
+
+static struct smatch_state *merge_links(struct smatch_state *s1, struct smatch_state *s2)
+{
+	struct smatch_state *ret;
+	struct string_list *links;
+
+	links = combine_string_lists(s1->data, s2->data);
+	ret = alloc_link_state(links);
+	return ret;
+}
+
+static void save_link_var_sym(const char *var, struct symbol *sym, const char *link)
+{
+	struct smatch_state *old_state, *new_state;
+	struct string_list *links;
+	char *new;
+
+	old_state = get_state(link_id, var, sym);
+	if (old_state)
+		links = clone_str_list(old_state->data);
+	else
+		links = NULL;
+
+	new = alloc_sname(link);
+	insert_string(&links, new);
+
+	new_state = alloc_link_state(links);
+	set_state(link_id, var, sym, new_state);
+}
+
+static void match_inc(struct sm_state *sm)
+{
+	struct string_list *links;
+	struct smatch_state *state, *new;
+	struct compare_data *data;
+	char *tmp;
+	int flip;
+	int op;
+
+	links = sm->state->data;
+
+	FOR_EACH_PTR(links, tmp) {
+		state = get_state(compare_id, tmp, NULL);
+		if (!state)
+			continue;
+		data = state->data;
+		if (!data)
+			continue;
+
+		flip = 0;
+		if (strncmp(sm->name, tmp, strlen(sm->name)) != 0 ||
+		    tmp[strlen(sm->name)] != ' ')
+			flip = 1;
+
+		op = state_to_comparison(state);
+
+		switch (flip ? flip_comparison(op) : op) {
+		case SPECIAL_EQUAL:
+		case SPECIAL_GTE:
+		case SPECIAL_UNSIGNED_GTE:
+		case '>':
+		case SPECIAL_UNSIGNED_GT:
+			new = alloc_compare_state(
+					data->left, data->left_var, data->left_vsl,
+					flip ? '<' : '>',
+					data->right, data->right_var, data->right_vsl);
+			set_state(compare_id, tmp, NULL, new);
+			break;
+		case '<':
+		case SPECIAL_UNSIGNED_LT:
+			new = alloc_compare_state(
+					data->left, data->left_var, data->left_vsl,
+					flip ? SPECIAL_GTE : SPECIAL_LTE,
+					data->right, data->right_var, data->right_vsl);
+			set_state(compare_id, tmp, NULL, new);
+			break;
+		default:
+			set_state(compare_id, tmp, NULL, &undefined);
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void match_dec(struct sm_state *sm)
+{
+	struct string_list *links;
+	struct smatch_state *state;
+	char *tmp;
+
+	links = sm->state->data;
+
+	FOR_EACH_PTR(links, tmp) {
+		state = get_state(compare_id, tmp, NULL);
+
+		switch (state_to_comparison(state)) {
+		case SPECIAL_EQUAL:
+		case SPECIAL_LTE:
+		case SPECIAL_UNSIGNED_LTE:
+		case '<':
+		case SPECIAL_UNSIGNED_LT: {
+			struct compare_data *data = state->data;
+			struct smatch_state *new;
+
+			new = alloc_compare_state(
+					data->left, data->left_var, data->left_vsl,
+					'<',
+					data->right, data->right_var, data->right_vsl);
+			set_state(compare_id, tmp, NULL, new);
+			break;
+			}
+		default:
+			set_state(compare_id, tmp, NULL, &undefined);
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void match_inc_dec(struct sm_state *sm, struct expression *mod_expr)
+{
+	/*
+	 * if (foo > bar) then ++foo is also > bar.
+	 */
+	if (!mod_expr)
+		return;
+	if (mod_expr->type != EXPR_PREOP && mod_expr->type != EXPR_POSTOP)
+		return;
+
+	if (mod_expr->op == SPECIAL_INCREMENT)
+		match_inc(sm);
+	else if (mod_expr->op == SPECIAL_DECREMENT)
+		match_dec(sm);
+}
+
+static int is_self_assign(struct expression *expr)
+{
+	if (!expr || expr->type != EXPR_ASSIGNMENT || expr->op != '=')
+		return 0;
+	return expr_equiv(expr->left, expr->right);
+}
+
+static void match_modify(struct sm_state *sm, struct expression *mod_expr)
+{
+	struct string_list *links;
+	char *tmp;
+
+	if (mod_expr && is_self_assign(mod_expr))
+		return;
+
+	/* handled by match_inc_dec() */
+	if (mod_expr &&
+	    ((mod_expr->type == EXPR_PREOP || mod_expr->type == EXPR_POSTOP) &&
+	     (mod_expr->op == SPECIAL_INCREMENT || mod_expr->op == SPECIAL_DECREMENT)))
+		return;
+
+	links = sm->state->data;
+
+	FOR_EACH_PTR(links, tmp) {
+		set_state(compare_id, tmp, NULL, &undefined);
+	} END_FOR_EACH_PTR(tmp);
+	set_state(link_id, sm->name, sm->sym, &undefined);
+}
+
+static void match_preop(struct expression *expr)
+{
+	struct expression *parent;
+	struct range_list *left, *right;
+	int op;
+
+	/*
+	 * This is an important special case.  Say you have:
+	 *
+	 * 	if (++j == limit)
+	 *
+	 * Assume that we know the range of limit is higher than the start
+	 * value for "j".  Then the first thing that we process is the ++j.  We
+	 * have not comparison states set up so it doesn't get caught by the
+	 * modification hook.  But it does get caught by smatch_extra which sets
+	 * j to unknown then we parse the "j == limit" and sets false to != but
+	 * really we want false to be <.
+	 *
+	 * So what we do is we set j < limit here, then the match_modify catches
+	 * it and we do a match_inc_dec().
+	 *
+	 */
+
+	if (expr->type != EXPR_PREOP ||
+	    (expr->op != SPECIAL_INCREMENT && expr->op != SPECIAL_DECREMENT))
+		return;
+
+	parent = expr_get_parent_expr(expr);
+	if (!parent)
+		return;
+	if (parent->type != EXPR_COMPARE || parent->op != SPECIAL_EQUAL)
+		return;
+	if (parent->left != expr)
+		return;
+
+	if (!get_implied_rl(expr->unop, &left) ||
+	   !get_implied_rl(parent->right, &right))
+		return;
+
+	op = rl_comparison(left, right);
+	if (!op)
+		return;
+
+	add_comparison(expr->unop, op, parent->right);
+}
+
+static char *chunk_to_var_sym(struct expression *expr, struct symbol **sym)
+{
+	expr = strip_expr(expr);
+	if (!expr)
+		return NULL;
+	if (sym)
+		*sym = NULL;
+
+	if (expr->type == EXPR_PREOP &&
+	    (expr->op == SPECIAL_INCREMENT ||
+	     expr->op == SPECIAL_DECREMENT))
+		expr = strip_expr(expr->unop);
+
+	if (expr->type == EXPR_CALL) {
+		char buf[64];
+
+		snprintf(buf, sizeof(buf), "return %p", expr);
+		return alloc_string(buf);
+	}
+
+	return expr_to_chunk_sym_vsl(expr, sym, NULL);
+}
+
+static char *chunk_to_var(struct expression *expr)
+{
+	return chunk_to_var_sym(expr, NULL);
+}
+
+static struct smatch_state *get_state_chunk(int owner, struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	struct smatch_state *ret;
+
+	name = chunk_to_var_sym(expr, &sym);
+	if (!name)
+		return NULL;
+
+	ret = get_state(owner, name, sym);
+	free_string(name);
+	return ret;
+}
+
+static void save_link(struct expression *expr, char *link)
+{
+	char *var;
+	struct symbol *sym;
+
+	expr = strip_expr(expr);
+	if (expr->type == EXPR_BINOP) {
+		char *chunk;
+
+		chunk = chunk_to_var(expr);
+		if (!chunk)
+			return;
+
+		save_link(expr->left, link);
+		save_link(expr->right, link);
+		save_link_var_sym(chunk, NULL, link);
+		return;
+	}
+
+	var = chunk_to_var_sym(expr, &sym);
+	if (!var)
+		return;
+
+	save_link_var_sym(var, sym, link);
+	free_string(var);
+}
+
+static int get_orig_comparison(struct stree *pre_stree, const char *left, const char *right)
+{
+	struct smatch_state *state;
+	struct compare_data *data;
+	int flip = 0;
+	char state_name[256];
+
+	if (strcmp(left, right) > 0) {
+		const char *tmp = right;
+
+		flip = 1;
+		right = left;
+		left = tmp;
+	}
+
+	snprintf(state_name, sizeof(state_name), "%s vs %s", left, right);
+	state = get_state_stree(pre_stree, compare_id, state_name, NULL);
+	if (!state || !state->data)
+		return 0;
+	data = state->data;
+	if (flip)
+		return flip_comparison(data->comparison);
+	return data->comparison;
+
+}
+
+static int have_common_var_sym(struct var_sym_list *left_vsl, struct var_sym_list *right_vsl)
+{
+	struct var_sym *tmp;
+
+	FOR_EACH_PTR(left_vsl, tmp) {
+		if (in_var_sym_list(right_vsl, tmp->var, tmp->sym))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+/*
+ * The idea here is that we take a comparison "a < b" and then we look at all
+ * the things which "b" is compared against "b < c" and we say that that implies
+ * a relationship "a < c".
+ *
+ * The names here about because the comparisons are organized like this
+ * "a < b < c".
+ *
+ */
+static void update_tf_links(struct stree *pre_stree,
+			    struct expression *left_expr,
+			    const char *left_var, struct var_sym_list *left_vsl,
+			    int left_comparison, int left_false_comparison,
+			    const char *mid_var, struct var_sym_list *mid_vsl,
+			    struct string_list *links)
+{
+	struct smatch_state *state;
+	struct smatch_state *true_state, *false_state;
+	struct compare_data *data;
+	struct expression *right_expr;
+	const char *right_var;
+	struct var_sym_list *right_vsl;
+	int orig_comparison;
+	int right_comparison;
+	int true_comparison;
+	int false_comparison;
+	char *tmp;
+	char state_name[256];
+	struct var_sym *vs;
+
+	FOR_EACH_PTR(links, tmp) {
+		state = get_state_stree(pre_stree, compare_id, tmp, NULL);
+		if (!state || !state->data)
+			continue;
+		data = state->data;
+		right_comparison = data->comparison;
+		right_expr = data->right;
+		right_var = data->right_var;
+		right_vsl = data->right_vsl;
+		if (strcmp(mid_var, right_var) == 0) {
+			right_expr = data->left;
+			right_var = data->left_var;
+			right_vsl = data->left_vsl;
+			right_comparison = flip_comparison(right_comparison);
+		}
+		if (have_common_var_sym(left_vsl, right_vsl))
+			continue;
+
+		orig_comparison = get_orig_comparison(pre_stree, left_var, right_var);
+
+		true_comparison = combine_comparisons(left_comparison, right_comparison);
+		false_comparison = combine_comparisons(left_false_comparison, right_comparison);
+
+		true_comparison = filter_comparison(orig_comparison, true_comparison);
+		false_comparison = filter_comparison(orig_comparison, false_comparison);
+
+		if (strcmp(left_var, right_var) > 0) {
+		  	struct expression *tmp_expr = left_expr;
+			const char *tmp_var = left_var;
+			struct var_sym_list *tmp_vsl = left_vsl;
+
+			left_expr = right_expr;
+			left_var = right_var;
+			left_vsl = right_vsl;
+			right_expr = tmp_expr;
+			right_var = tmp_var;
+			right_vsl = tmp_vsl;
+			true_comparison = flip_comparison(true_comparison);
+			false_comparison = flip_comparison(false_comparison);
+		}
+
+		if (!true_comparison && !false_comparison)
+			continue;
+
+		if (true_comparison)
+			true_state = alloc_compare_state(
+					left_expr, left_var, left_vsl,
+					true_comparison,
+					right_expr, right_var, right_vsl);
+		else
+			true_state = NULL;
+		if (false_comparison)
+			false_state = alloc_compare_state(
+					left_expr, left_var, left_vsl,
+					false_comparison,
+					right_expr, right_var, right_vsl);
+		else
+			false_state = NULL;
+
+		snprintf(state_name, sizeof(state_name), "%s vs %s", left_var, right_var);
+		set_true_false_states(compare_id, state_name, NULL, true_state, false_state);
+		FOR_EACH_PTR(left_vsl, vs) {
+			save_link_var_sym(vs->var, vs->sym, state_name);
+		} END_FOR_EACH_PTR(vs);
+		FOR_EACH_PTR(right_vsl, vs) {
+			save_link_var_sym(vs->var, vs->sym, state_name);
+		} END_FOR_EACH_PTR(vs);
+		if (!vsl_to_sym(left_vsl))
+			save_link_var_sym(left_var, NULL, state_name);
+		if (!vsl_to_sym(right_vsl))
+			save_link_var_sym(right_var, NULL, state_name);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void update_tf_data(struct stree *pre_stree,
+		struct expression *left_expr,
+		const char *left_name, struct var_sym_list *left_vsl,
+		struct expression *right_expr,
+		const char *right_name, struct var_sym_list *right_vsl,
+		int true_comparison, int false_comparison)
+{
+	struct smatch_state *state;
+
+	state = get_state_stree(pre_stree, link_id, right_name, vsl_to_sym(right_vsl));
+	if (state)
+		update_tf_links(pre_stree, left_expr, left_name, left_vsl, true_comparison, false_comparison, right_name, right_vsl, state->data);
+
+	state = get_state_stree(pre_stree, link_id, left_name, vsl_to_sym(left_vsl));
+	if (state)
+		update_tf_links(pre_stree, right_expr, right_name, right_vsl, flip_comparison(true_comparison), flip_comparison(false_comparison), left_name, left_vsl, state->data);
+}
+
+static void iter_modify(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (sm->state != &start ||
+	    !mod_expr ||
+	    (mod_expr->type != EXPR_PREOP && mod_expr->type != EXPR_POSTOP) ||
+	    mod_expr->op != SPECIAL_INCREMENT)
+		set_state(inc_dec_id, sm->name, sm->sym, &undefined);
+	else
+		set_state(inc_dec_id, sm->name, sm->sym, &incremented);
+}
+
+static void handle_for_loops(struct expression *expr, char *state_name, struct smatch_state *false_state)
+{
+	sval_t sval;
+	char *iter_name, *cap_name;
+	struct symbol *iter_sym, *cap_sym;
+	struct compare_data *data;
+
+	if (expr->op != '<' && expr->op != SPECIAL_UNSIGNED_LT)
+		return;
+
+	if (!__cur_stmt || !__prev_stmt)
+		return;
+	if (__cur_stmt->type != STMT_ITERATOR)
+		return;
+	if (__cur_stmt->iterator_pre_condition != expr)
+		return;
+
+	/* literals are handled in smatch_extra.c */
+	if (get_value(expr->right, &sval))
+		return;
+
+	/* First time checking the condition */
+	if (__prev_stmt == __cur_stmt->iterator_pre_statement) {
+		if (!get_implied_value(expr->left, &sval) ||
+		    sval.value != 0)
+			return;
+
+		iter_name = expr_to_var_sym(expr->left, &iter_sym);
+		cap_name = expr_to_var_sym(expr->right, &cap_sym);
+		if (!iter_name || !cap_name || !iter_sym || !cap_sym) {
+			free_string(iter_name);
+			free_string(cap_name);
+			return;
+		}
+
+		set_state(inc_dec_id, iter_name, iter_sym, &start);
+		store_link(inc_dec_link_id, cap_name, cap_sym, iter_name, iter_sym);
+
+		free_string(iter_name);
+		free_string(cap_name);
+		return;
+	}
+
+	/* Second time checking the condtion */
+	if (__prev_stmt != __cur_stmt->iterator_post_statement)
+		return;
+
+	if (get_state_chunk(inc_dec_id, expr->left) != &incremented)
+		return;
+
+	data = false_state->data;
+	false_state = alloc_compare_state(
+			data->left, data->left_var, data->left_vsl,
+			SPECIAL_EQUAL,
+			data->right, data->right_var, data->right_vsl);
+
+	set_true_false_states(compare_id, state_name, NULL, NULL, false_state);
+}
+
+static int is_plus_one(struct expression *expr)
+{
+	sval_t sval;
+
+	if (expr->type != EXPR_BINOP || expr->op != '+')
+		return 0;
+	if (!get_implied_value(expr->right, &sval) || sval.value != 1)
+		return 0;
+	return 1;
+}
+
+static int is_minus_one(struct expression *expr)
+{
+	sval_t sval;
+
+	if (expr->type != EXPR_BINOP || expr->op != '-')
+		return 0;
+	if (!get_implied_value(expr->right, &sval) || sval.value != 1)
+		return 0;
+	return 1;
+}
+
+static void move_plus_to_minus_helper(struct expression **left_p, struct expression **right_p)
+{
+	struct expression *left = *left_p;
+	struct expression *right = *right_p;
+
+	/*
+	 * These two are basically equivalent: "foo + 1 != bar" and
+	 * "foo != bar - 1".  There are issues with signedness and integer
+	 * overflows.  There are also issues with type as well.  But let's
+	 * pretend we can ignore all that stuff for now.
+	 *
+	 */
+
+	if (!is_plus_one(left))
+		return;
+
+	*left_p = left->left;
+	*right_p = binop_expression(right, '-', left->right);
+}
+
+static void move_plus_to_minus(struct expression **left_p, struct expression **right_p)
+{
+	if (is_plus_one(*left_p) && is_plus_one(*right_p))
+		return;
+
+	move_plus_to_minus_helper(left_p, right_p);
+	move_plus_to_minus_helper(right_p, left_p);
+}
+
+static void handle_comparison(struct expression *left_expr, int op, struct expression *right_expr, char **_state_name, struct smatch_state **_false_state)
+{
+	char *left = NULL;
+	char *right = NULL;
+	struct symbol *left_sym, *right_sym;
+	struct var_sym_list *left_vsl = NULL;
+	struct var_sym_list *right_vsl = NULL;
+	int false_op;
+	int orig_comparison;
+	struct smatch_state *true_state, *false_state;
+	static char state_name[256];
+	struct stree *pre_stree;
+	sval_t sval;
+
+	if (!left_expr || !right_expr)
+		return;
+
+	left_expr = strip_parens(left_expr);
+	right_expr = strip_parens(right_expr);
+
+	while (left_expr->type == EXPR_ASSIGNMENT)
+		left_expr = strip_parens(left_expr->left);
+	while (right_expr->type == EXPR_ASSIGNMENT)
+		right_expr = strip_parens(right_expr->left);
+
+	false_op = negate_comparison(op);
+
+	move_plus_to_minus(&left_expr, &right_expr);
+
+	if (op == SPECIAL_UNSIGNED_LT &&
+	    get_implied_value(left_expr, &sval) &&
+	    sval.value == 0)
+		false_op = SPECIAL_EQUAL;
+
+	if (op == SPECIAL_UNSIGNED_GT &&
+	    get_implied_value(right_expr, &sval) &&
+	    sval.value == 0)
+		false_op = SPECIAL_EQUAL;
+
+	left = chunk_to_var_sym(left_expr, &left_sym);
+	if (!left)
+		goto free;
+	if (left_sym)
+		add_var_sym(&left_vsl, left, left_sym);
+	else
+		left_vsl = expr_to_vsl(left_expr);
+	right = chunk_to_var_sym(right_expr, &right_sym);
+	if (!right)
+		goto free;
+	if (right_sym)
+		add_var_sym(&right_vsl, right, right_sym);
+	else
+		right_vsl = expr_to_vsl(right_expr);
+
+	if (strcmp(left, right) > 0) {
+		char *tmp_name = left;
+		struct var_sym_list *tmp_vsl = left_vsl;
+		struct expression *tmp_expr = left_expr;
+
+		left = right;
+		left_vsl = right_vsl;
+		left_expr = right_expr;
+		right = tmp_name;
+		right_vsl = tmp_vsl;
+		right_expr = tmp_expr;
+		op = flip_comparison(op);
+		false_op = flip_comparison(false_op);
+	}
+
+	orig_comparison = get_comparison(left_expr, right_expr);
+	op = filter_comparison(orig_comparison, op);
+	false_op = filter_comparison(orig_comparison, false_op);
+
+	snprintf(state_name, sizeof(state_name), "%s vs %s", left, right);
+	true_state = alloc_compare_state(
+			left_expr, left, left_vsl,
+			op,
+			right_expr, right, right_vsl);
+	false_state = alloc_compare_state(
+			left_expr, left, left_vsl,
+			false_op,
+			right_expr, right, right_vsl);
+
+	pre_stree = clone_stree(__get_cur_stree());
+	update_tf_data(pre_stree, left_expr, left, left_vsl, right_expr, right, right_vsl, op, false_op);
+	free_stree(&pre_stree);
+
+	set_true_false_states(compare_id, state_name, NULL, true_state, false_state);
+	__compare_param_limit_hook(left_expr, right_expr, state_name, true_state, false_state);
+	save_link(left_expr, state_name);
+	save_link(right_expr, state_name);
+
+	if (_false_state)
+		*_false_state = false_state;
+	if (_state_name)
+		*_state_name = state_name;
+free:
+	free_string(left);
+	free_string(right);
+}
+
+void __comparison_match_condition(struct expression *expr)
+{
+	struct expression *left, *right, *new_left, *new_right, *tmp;
+	struct smatch_state *false_state = NULL;
+	char *state_name = NULL;
+	int redo, count;
+
+	if (expr->type != EXPR_COMPARE)
+		return;
+
+	handle_comparison(expr->left, expr->op, expr->right, &state_name, &false_state);
+	if (false_state && state_name)
+		handle_for_loops(expr, state_name, false_state);
+
+	left = strip_parens(expr->left);
+	right = strip_parens(expr->right);
+
+	if (left->type == EXPR_BINOP && left->op == '+') {
+		new_left = left->left;
+		new_right = binop_expression(right, '-', left->right);
+		handle_comparison(new_left, expr->op, new_right, NULL, NULL);
+
+		new_left = left->right;
+		new_right = binop_expression(right, '-', left->left);
+		handle_comparison(new_left, expr->op, new_right, NULL, NULL);
+	}
+
+
+	redo = 0;
+	left = strip_parens(expr->left);
+	right = strip_parens(expr->right);
+	if (get_last_expr_from_expression_stmt(expr->left)) {
+		left = get_last_expr_from_expression_stmt(expr->left);
+		redo = 1;
+	}
+	if (get_last_expr_from_expression_stmt(expr->right)) {
+		right = get_last_expr_from_expression_stmt(expr->right);
+		redo = 1;
+	}
+
+	if (!redo)
+		return;
+
+	count = 0;
+	while ((tmp = get_assigned_expr(left))) {
+		if (count++ > 3)
+			break;
+		left = strip_expr(tmp);
+	}
+	count = 0;
+	while ((tmp = get_assigned_expr(right))) {
+		if (count++ > 3)
+			break;
+		right = strip_expr(tmp);
+	}
+
+	handle_comparison(left, expr->op, right, NULL, NULL);
+}
+
+static void add_comparison_var_sym(
+		struct expression *left_expr,
+		const char *left_name, struct var_sym_list *left_vsl,
+		int comparison,
+		struct expression *right_expr,
+		const char *right_name, struct var_sym_list *right_vsl)
+{
+	struct smatch_state *state;
+	struct var_sym *vs;
+	char state_name[256];
+
+	if (strcmp(left_name, right_name) > 0) {
+		struct expression *tmp_expr = left_expr;
+		const char *tmp_name = left_name;
+		struct var_sym_list *tmp_vsl = left_vsl;
+
+		left_expr = right_expr;
+		left_name = right_name;
+		left_vsl = right_vsl;
+		right_expr = tmp_expr;
+		right_name = tmp_name;
+		right_vsl = tmp_vsl;
+		comparison = flip_comparison(comparison);
+	}
+	snprintf(state_name, sizeof(state_name), "%s vs %s", left_name, right_name);
+	state = alloc_compare_state(
+			left_expr, left_name, left_vsl,
+			comparison,
+			right_expr, right_name, right_vsl);
+
+	set_state(compare_id, state_name, NULL, state);
+
+	FOR_EACH_PTR(left_vsl, vs) {
+		save_link_var_sym(vs->var, vs->sym, state_name);
+	} END_FOR_EACH_PTR(vs);
+	FOR_EACH_PTR(right_vsl, vs) {
+		save_link_var_sym(vs->var, vs->sym, state_name);
+	} END_FOR_EACH_PTR(vs);
+}
+
+static void add_comparison(struct expression *left, int comparison, struct expression *right)
+{
+	char *left_name = NULL;
+	char *right_name = NULL;
+	struct symbol *left_sym, *right_sym;
+	struct var_sym_list *left_vsl, *right_vsl;
+	struct smatch_state *state;
+	char state_name[256];
+
+	left_name = chunk_to_var_sym(left, &left_sym);
+	if (!left_name)
+		goto free;
+	left_vsl = expr_to_vsl(left);
+	right_name = chunk_to_var_sym(right, &right_sym);
+	if (!right_name)
+		goto free;
+	right_vsl = expr_to_vsl(right);
+
+	if (strcmp(left_name, right_name) > 0) {
+		struct expression *tmp_expr = left;
+		struct symbol *tmp_sym = left_sym;
+		char *tmp_name = left_name;
+		struct var_sym_list *tmp_vsl = left_vsl;
+
+		left = right;
+		left_name = right_name;
+		left_sym = right_sym;
+		left_vsl = right_vsl;
+		right = tmp_expr;
+		right_name = tmp_name;
+		right_sym = tmp_sym;
+		right_vsl = tmp_vsl;
+		comparison = flip_comparison(comparison);
+	}
+	snprintf(state_name, sizeof(state_name), "%s vs %s", left_name, right_name);
+	state = alloc_compare_state(
+			left, left_name, left_vsl,
+			comparison,
+			right, right_name, right_vsl);
+
+	set_state(compare_id, state_name, NULL, state);
+	save_link(left, state_name);
+	save_link(right, state_name);
+
+free:
+	free_string(left_name);
+	free_string(right_name);
+}
+
+static void match_assign_add(struct expression *expr)
+{
+	struct expression *right;
+	struct expression *r_left, *r_right;
+	sval_t left_tmp, right_tmp;
+
+	right = strip_expr(expr->right);
+	r_left = strip_expr(right->left);
+	r_right = strip_expr(right->right);
+
+	get_absolute_min(r_left, &left_tmp);
+	get_absolute_min(r_right, &right_tmp);
+
+	if (left_tmp.value > 0)
+		add_comparison(expr->left, '>', r_right);
+	else if (left_tmp.value == 0)
+		add_comparison(expr->left, SPECIAL_GTE, r_right);
+
+	if (right_tmp.value > 0)
+		add_comparison(expr->left, '>', r_left);
+	else if (right_tmp.value == 0)
+		add_comparison(expr->left, SPECIAL_GTE, r_left);
+}
+
+static void match_assign_sub(struct expression *expr)
+{
+	struct expression *right;
+	struct expression *r_left, *r_right;
+	int comparison;
+	sval_t min;
+
+	right = strip_expr(expr->right);
+	r_left = strip_expr(right->left);
+	r_right = strip_expr(right->right);
+
+	if (get_absolute_min(r_right, &min) && sval_is_negative(min))
+		return;
+
+	comparison = get_comparison(r_left, r_right);
+
+	switch (comparison) {
+	case '>':
+	case SPECIAL_GTE:
+		if (implied_not_equal(r_right, 0))
+			add_comparison(expr->left, '>', r_left);
+		else
+			add_comparison(expr->left, SPECIAL_GTE, r_left);
+		return;
+	}
+}
+
+static void match_assign_divide(struct expression *expr)
+{
+	struct expression *right;
+	struct expression *r_left, *r_right;
+	sval_t min;
+
+	right = strip_expr(expr->right);
+	r_left = strip_expr(right->left);
+	r_right = strip_expr(right->right);
+	if (!get_implied_min(r_right, &min) || min.value <= 1)
+		return;
+
+	add_comparison(expr->left, '<', r_left);
+}
+
+static void match_binop_assign(struct expression *expr)
+{
+	struct expression *right;
+
+	right = strip_expr(expr->right);
+	if (right->op == '+')
+		match_assign_add(expr);
+	if (right->op == '-')
+		match_assign_sub(expr);
+	if (right->op == '/')
+		match_assign_divide(expr);
+}
+
+static void copy_comparisons(struct expression *left, struct expression *right)
+{
+	struct string_list *links;
+	struct smatch_state *state;
+	struct compare_data *data;
+	struct symbol *left_sym, *right_sym;
+	char *left_var = NULL;
+	char *right_var = NULL;
+	struct var_sym_list *left_vsl;
+	struct expression *expr;
+	const char *var;
+	struct var_sym_list *vsl;
+	int comparison;
+	char *tmp;
+
+	left_var = chunk_to_var_sym(left, &left_sym);
+	if (!left_var)
+		goto done;
+	left_vsl = expr_to_vsl(left);
+	right_var = chunk_to_var_sym(right, &right_sym);
+	if (!right_var)
+		goto done;
+
+	state = get_state(link_id, right_var, right_sym);
+	if (!state)
+		return;
+	links = state->data;
+
+	FOR_EACH_PTR(links, tmp) {
+		state = get_state(compare_id, tmp, NULL);
+		if (!state || !state->data)
+			continue;
+		data = state->data;
+		comparison = data->comparison;
+		expr = data->right;
+		var = data->right_var;
+		vsl = data->right_vsl;
+		if (strcmp(var, right_var) == 0) {
+			expr = data->left;
+			var = data->left_var;
+			vsl = data->left_vsl;
+			comparison = flip_comparison(comparison);
+		}
+		/* n = copy_from_user(dest, src, n); leads to n <= n which is nonsense */
+		if (strcmp(left_var, var) == 0)
+			continue;
+		add_comparison_var_sym(left, left_var, left_vsl, comparison, expr, var, vsl);
+	} END_FOR_EACH_PTR(tmp);
+
+done:
+	free_string(right_var);
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *right;
+
+	if (expr->op != '=')
+		return;
+	if (__in_fake_assign || outside_of_function())
+		return;
+
+	if (is_struct(expr->left))
+		return;
+
+	if (is_self_assign(expr))
+		return;
+
+	copy_comparisons(expr->left, expr->right);
+	add_comparison(expr->left, SPECIAL_EQUAL, expr->right);
+
+	right = strip_expr(expr->right);
+	if (right->type == EXPR_BINOP)
+		match_binop_assign(expr);
+}
+
+int get_comparison_strings(const char *one, const char *two)
+{
+	char buf[256];
+	struct smatch_state *state;
+	int invert = 0;
+	int ret = 0;
+
+	if (!one || !two)
+		return 0;
+
+	if (strcmp(one, two) == 0)
+		return SPECIAL_EQUAL;
+
+	if (strcmp(one, two) > 0) {
+		const char *tmp = one;
+
+		one = two;
+		two = tmp;
+		invert = 1;
+	}
+
+	snprintf(buf, sizeof(buf), "%s vs %s", one, two);
+	state = get_state(compare_id, buf, NULL);
+	if (state)
+		ret = state_to_comparison(state);
+
+	if (invert)
+		ret = flip_comparison(ret);
+
+	return ret;
+}
+
+int get_comparison(struct expression *a, struct expression *b)
+{
+	char *one = NULL;
+	char *two = NULL;
+	int ret = 0;
+
+	if (!a || !b)
+		return 0;
+
+	a = strip_parens(a);
+	b = strip_parens(b);
+
+	move_plus_to_minus(&a, &b);
+
+	one = chunk_to_var(a);
+	if (!one)
+		goto free;
+	two = chunk_to_var(b);
+	if (!two)
+		goto free;
+
+	ret = get_comparison_strings(one, two);
+	if (ret)
+		goto free;
+
+	if (is_plus_one(a) || is_minus_one(a)) {
+		free_string(one);
+		one = chunk_to_var(a->left);
+		ret = get_comparison_strings(one, two);
+	} else if (is_plus_one(b) || is_minus_one(b)) {
+		free_string(two);
+		two = chunk_to_var(b->left);
+		ret = get_comparison_strings(one, two);
+	}
+
+	if (!ret)
+		goto free;
+
+	if ((is_plus_one(a) || is_minus_one(b)) && ret == '<')
+		ret = SPECIAL_LTE;
+	else if ((is_minus_one(a) || is_plus_one(b)) && ret == '>')
+		ret = SPECIAL_GTE;
+	else
+		ret = 0;
+
+free:
+	free_string(one);
+	free_string(two);
+
+	if (!ret)
+		return comparison_from_extra(a, b);
+	return ret;
+}
+
+int possible_comparison(struct expression *a, int comparison, struct expression *b)
+{
+	char *one = NULL;
+	char *two = NULL;
+	int ret = 0;
+	char buf[256];
+	struct sm_state *sm;
+	int saved;
+
+	one = chunk_to_var(a);
+	if (!one)
+		goto free;
+	two = chunk_to_var(b);
+	if (!two)
+		goto free;
+
+
+	if (strcmp(one, two) == 0 && comparison == SPECIAL_EQUAL) {
+		ret = 1;
+		goto free;
+	}
+
+	if (strcmp(one, two) > 0) {
+		char *tmp = one;
+
+		one = two;
+		two = tmp;
+		comparison = flip_comparison(comparison);
+	}
+
+	snprintf(buf, sizeof(buf), "%s vs %s", one, two);
+	sm = get_sm_state(compare_id, buf, NULL);
+	if (!sm)
+		goto free;
+
+	FOR_EACH_PTR(sm->possible, sm) {
+		if (!sm->state->data)
+			continue;
+		saved = ((struct compare_data *)sm->state->data)->comparison;
+		if (saved == comparison)
+			ret = 1;
+		if (comparison == SPECIAL_EQUAL &&
+		    (saved == SPECIAL_LTE ||
+		     saved == SPECIAL_GTE ||
+		     saved == SPECIAL_UNSIGNED_LTE ||
+		     saved == SPECIAL_UNSIGNED_GTE))
+			ret = 1;
+		if (ret == 1)
+			goto free;
+	} END_FOR_EACH_PTR(sm);
+
+	return ret;
+free:
+	free_string(one);
+	free_string(two);
+	return ret;
+}
+
+struct state_list *get_all_comparisons(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct string_list *links;
+	struct state_list *ret = NULL;
+	struct sm_state *sm;
+	char *tmp;
+
+	state = get_state_chunk(link_id, expr);
+	if (!state)
+		return NULL;
+	links = state->data;
+
+	FOR_EACH_PTR(links, tmp) {
+		sm = get_sm_state(compare_id, tmp, NULL);
+		if (!sm)
+			continue;
+		// FIXME have to compare name with vsl
+		add_ptr_list(&ret, sm);
+	} END_FOR_EACH_PTR(tmp);
+
+	return ret;
+}
+
+struct state_list *get_all_possible_equal_comparisons(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct string_list *links;
+	struct state_list *ret = NULL;
+	struct sm_state *sm;
+	char *tmp;
+
+	state = get_state_chunk(link_id, expr);
+	if (!state)
+		return NULL;
+	links = state->data;
+
+	FOR_EACH_PTR(links, tmp) {
+		sm = get_sm_state(compare_id, tmp, NULL);
+		if (!sm)
+			continue;
+		if (!strchr(sm->state->name, '='))
+			continue;
+		if (strcmp(sm->state->name, "!=") == 0)
+			continue;
+		add_ptr_list(&ret, sm);
+	} END_FOR_EACH_PTR(tmp);
+
+	return ret;
+}
+
+struct state_list *get_all_possible_not_equal_comparisons(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct string_list *links;
+	struct state_list *ret = NULL;
+	struct sm_state *sm;
+	struct sm_state *possible;
+	char *link;
+
+	return NULL;
+
+	state = get_state_chunk(link_id, expr);
+	if (!state)
+		return NULL;
+	links = state->data;
+
+	FOR_EACH_PTR(links, link) {
+		sm = get_sm_state(compare_id, link, NULL);
+		if (!sm)
+			continue;
+		FOR_EACH_PTR(sm->possible, possible) {
+			if (strcmp(possible->state->name, "!=") != 0)
+				continue;
+			add_ptr_list(&ret, sm);
+			break;
+		} END_FOR_EACH_PTR(link);
+	} END_FOR_EACH_PTR(link);
+
+	return ret;
+}
+
+static void update_links_from_call(struct expression *left,
+				   int left_compare,
+				   struct expression *right)
+{
+	struct string_list *links;
+	struct smatch_state *state;
+	struct compare_data *data;
+	struct symbol *left_sym, *right_sym;
+	char *left_var = NULL;
+	char *right_var = NULL;
+	struct var_sym_list *left_vsl;
+	struct expression *expr;
+	const char *var;
+	struct var_sym_list *vsl;
+	int comparison;
+	char *tmp;
+
+	left_var = chunk_to_var_sym(left, &left_sym);
+	if (!left_var)
+		goto done;
+	left_vsl = expr_to_vsl(left);
+	right_var = chunk_to_var_sym(right, &right_sym);
+	if (!right_var)
+		goto done;
+
+	state = get_state(link_id, right_var, right_sym);
+	if (!state)
+		return;
+	links = state->data;
+
+	FOR_EACH_PTR(links, tmp) {
+		state = get_state(compare_id, tmp, NULL);
+		if (!state || !state->data)
+			continue;
+		data = state->data;
+		comparison = data->comparison;
+		expr = data->right;
+		var = data->right_var;
+		vsl = data->right_vsl;
+		if (strcmp(var, right_var) == 0) {
+			expr = data->left;
+			var = data->left_var;
+			vsl = data->left_vsl;
+			comparison = flip_comparison(comparison);
+		}
+		comparison = combine_comparisons(left_compare, comparison);
+		if (!comparison)
+			continue;
+		add_comparison_var_sym(left, left_var, left_vsl, comparison, expr, var, vsl);
+	} END_FOR_EACH_PTR(tmp);
+
+done:
+	free_string(right_var);
+}
+
+void __add_return_comparison(struct expression *call, const char *range)
+{
+	struct expression *arg;
+	int comparison;
+	char buf[4];
+
+	if (!str_to_comparison_arg(range, call, &comparison, &arg))
+		return;
+	snprintf(buf, sizeof(buf), "%s", show_special(comparison));
+	update_links_from_call(call, comparison, arg);
+	add_comparison(call, comparison, arg);
+}
+
+void __add_comparison_info(struct expression *expr, struct expression *call, const char *range)
+{
+	copy_comparisons(expr, call);
+}
+
+static char *get_mask_comparison(struct expression *expr, int ignore)
+{
+	struct expression *tmp, *right;
+	int count, param;
+	char buf[256];
+
+	/* The return value for "return foo & param;" is <= param */
+
+	count = 0;
+	while ((tmp = get_assigned_expr(expr))) {
+		expr = strip_expr(tmp);
+		if (count++ > 4)
+			break;
+	}
+
+	if (expr->type != EXPR_BINOP || expr->op != '&')
+		return NULL;
+
+	right = strip_expr(expr->right);
+	param = get_param_num(right);
+	if (param < 0 || param == ignore)
+		return NULL;
+
+	snprintf(buf, sizeof(buf), "[<=$%d]", param);
+	return alloc_sname(buf);
+}
+
+static char *range_comparison_to_param_helper(struct expression *expr, char starts_with, int ignore)
+{
+	struct symbol *param;
+	char *var = NULL;
+	char buf[256];
+	char *ret_str = NULL;
+	int compare;
+	int i;
+
+	if (!expr)
+		return NULL;
+
+	var = chunk_to_var(expr);
+	if (!var)
+		goto try_mask;
+
+	i = -1;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, param) {
+		i++;
+		if (i == ignore)
+			continue;
+		if (!param->ident)
+			continue;
+		snprintf(buf, sizeof(buf), "%s orig", param->ident->name);
+		compare = get_comparison_strings(var, buf);
+		if (!compare)
+			continue;
+		if (show_special(compare)[0] != starts_with)
+			continue;
+		snprintf(buf, sizeof(buf), "[%s$%d]", show_special(compare), i);
+		ret_str = alloc_sname(buf);
+		break;
+	} END_FOR_EACH_PTR(param);
+
+	free_string(var);
+	if (!ret_str)
+		goto try_mask;
+
+	return ret_str;
+
+try_mask:
+	if (starts_with == '<')
+		ret_str = get_mask_comparison(expr, ignore);
+	return ret_str;
+}
+
+char *name_sym_to_param_comparison(const char *name, struct symbol *sym)
+{
+	struct symbol *param;
+	char buf[256];
+	int compare;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, param) {
+		i++;
+		if (!param->ident)
+			continue;
+		snprintf(buf, sizeof(buf), "%s orig", param->ident->name);
+		compare = get_comparison_strings(name, buf);
+		if (!compare)
+			continue;
+		snprintf(buf, sizeof(buf), "[%s$%d]", show_special(compare), i);
+		return alloc_sname(buf);
+	} END_FOR_EACH_PTR(param);
+
+	return NULL;
+}
+
+char *expr_equal_to_param(struct expression *expr, int ignore)
+{
+	return range_comparison_to_param_helper(expr, '=', ignore);
+}
+
+char *expr_lte_to_param(struct expression *expr, int ignore)
+{
+	return range_comparison_to_param_helper(expr, '<', ignore);
+}
+
+char *expr_param_comparison(struct expression *expr, int ignore)
+{
+	struct symbol *param;
+	char *var = NULL;
+	char buf[256];
+	char *ret_str = NULL;
+	int compare;
+	int i;
+
+	var = chunk_to_var(expr);
+	if (!var)
+		goto free;
+
+	i = -1;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, param) {
+		i++;
+		if (i == ignore)
+			continue;
+		if (!param->ident)
+			continue;
+		snprintf(buf, sizeof(buf), "%s orig", param->ident->name);
+		compare = get_comparison_strings(var, buf);
+		if (!compare)
+			continue;
+		snprintf(buf, sizeof(buf), "[%s$%d]", show_special(compare), i);
+		ret_str = alloc_sname(buf);
+		break;
+	} END_FOR_EACH_PTR(param);
+
+free:
+	free_string(var);
+	return ret_str;
+}
+
+char *get_printed_param_name(struct expression *call, const char *param_name, struct symbol *param_sym)
+{
+	struct expression *arg;
+	char *name;
+	struct symbol *sym;
+	static char buf[256];
+	int len;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(call->args, arg) {
+		i++;
+
+		name = expr_to_var_sym(arg, &sym);
+		if (!name || !sym)
+			continue;
+		if (sym != param_sym)
+			continue;
+
+		len = strlen(name);
+		if (strncmp(name, param_name, len) != 0)
+			continue;
+		if (param_name[len] == '\0') {
+			snprintf(buf, sizeof(buf), "$%d", i);
+			return buf;
+		}
+		if (param_name[len] != '-')
+			continue;
+		snprintf(buf, sizeof(buf), "$%d%s", i, param_name + len);
+		return buf;
+	} END_FOR_EACH_PTR(arg);
+
+	return NULL;
+}
+
+static void match_call_info(struct expression *expr)
+{
+	struct expression *arg;
+	struct smatch_state *state;
+	struct sm_state *sm;
+	struct compare_data *data;
+	int comparison;
+	struct string_list *links;
+	char *arg_name;
+	const char *right_name;
+	char *link;
+	char info_buf[256];
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+
+		state = get_state_chunk(link_id, arg);
+		if (!state)
+			continue;
+
+		links = state->data;
+		FOR_EACH_PTR(links, link) {
+			struct var_sym_list *right_vsl;
+			struct var_sym *right_vs;
+
+
+			if (strstr(link, " orig"))
+				continue;
+			sm = get_sm_state(compare_id, link, NULL);
+			if (!sm)
+				continue;
+			data = sm->state->data;
+			if (!data || !data->comparison)
+				continue;
+			arg_name = expr_to_var(arg);
+			if (!arg_name)
+				continue;
+
+			right_vsl = NULL;
+			if (strcmp(data->left_var, arg_name) == 0) {
+				comparison = data->comparison;
+				right_name = data->right_var;
+				right_vsl = data->right_vsl;
+			} else if (strcmp(data->right_var, arg_name) == 0) {
+				comparison = flip_comparison(data->comparison);
+				right_name = data->left_var;
+				right_vsl = data->left_vsl;
+			}
+			if (!right_vsl || ptr_list_size((struct ptr_list *)right_vsl) != 1)
+				goto free;
+
+			right_vs = first_ptr_list((struct ptr_list *)right_vsl);
+			if (strcmp(right_vs->var, right_name) != 0)
+				goto free;
+			right_name = get_printed_param_name(expr, right_vs->var, right_vs->sym);
+			if (!right_name)
+				goto free;
+			snprintf(info_buf, sizeof(info_buf), "%s %s", show_special(comparison), right_name);
+			sql_insert_caller_info(expr, PARAM_COMPARE, i, "$", info_buf);
+
+free:
+			free_string(arg_name);
+		} END_FOR_EACH_PTR(link);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *link_sm)
+{
+	struct sm_state *compare_sm;
+	struct string_list *links;
+	char *link;
+	struct compare_data *data;
+	struct var_sym *left, *right;
+	static char info_buf[256];
+	const char *right_name;
+
+	if (strstr(printed_name, " orig"))
+		return;
+
+	links = link_sm->state->data;
+	FOR_EACH_PTR(links, link) {
+		compare_sm = get_sm_state(compare_id, link, NULL);
+		if (!compare_sm)
+			continue;
+		data = compare_sm->state->data;
+		if (!data || !data->comparison)
+			continue;
+
+		if (ptr_list_size((struct ptr_list *)data->left_vsl) != 1 ||
+		    ptr_list_size((struct ptr_list *)data->right_vsl) != 1)
+			continue;
+		left = first_ptr_list((struct ptr_list *)data->left_vsl);
+		right = first_ptr_list((struct ptr_list *)data->right_vsl);
+		if (left->sym == right->sym &&
+		    strcmp(left->var, right->var) == 0)
+			continue;
+		/*
+		 * Both parameters link to this comparison so only
+		 * record the first one.
+		 */
+		if (left->sym != link_sm->sym ||
+		    strcmp(left->var, link_sm->name) != 0)
+			continue;
+
+		right_name = get_printed_param_name(call, right->var, right->sym);
+		if (!right_name)
+			continue;
+		snprintf(info_buf, sizeof(info_buf), "%s %s", show_special(data->comparison), right_name);
+		sql_insert_caller_info(call, PARAM_COMPARE, param, printed_name, info_buf);
+	} END_FOR_EACH_PTR(link);
+}
+
+static void print_return_value_comparison(int return_id, char *return_ranges, struct expression *expr)
+{
+	char *name;
+	const char *tmp_name;
+	struct symbol *sym;
+	int param;
+	char info_buf[256];
+
+	/*
+	 * TODO: This only prints == comparisons. That's probably the most
+	 * useful comparison because == max has lots of implications.  But it
+	 * would be good to capture the rest as well.
+	 *
+	 * This information is already in the DB but it's in the parameter math
+	 * bits and it's awkward to use it.  This is is the simpler, possibly
+	 * cleaner way, but not necessarily the best, I don't know.
+	 */
+
+	if (!expr)
+		return;
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+
+	param = get_param_num_from_sym(sym);
+	if (param < 0)
+		goto free;
+	if (param_was_set_var_sym(name, sym))
+		goto free;
+
+	tmp_name = get_param_name_var_sym(name, sym);
+	if (!tmp_name)
+		goto free;
+
+	snprintf(info_buf, sizeof(info_buf), "== $%d%s", param, tmp_name + 1);
+	sql_insert_return_states(return_id, return_ranges,
+				PARAM_COMPARE, -1, "$", info_buf);
+free:
+	free_string(name);
+}
+
+static void print_return_comparison(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *tmp;
+	struct string_list *links;
+	char *link;
+	struct sm_state *sm;
+	struct compare_data *data;
+	struct var_sym *left, *right;
+	int left_param, right_param;
+	char left_buf[256];
+	char right_buf[256];
+	char info_buf[258];
+	const char *tmp_name;
+
+	print_return_value_comparison(return_id, return_ranges, expr);
+
+	FOR_EACH_MY_SM(link_id, __get_cur_stree(), tmp) {
+		if (get_param_num_from_sym(tmp->sym) < 0)
+			continue;
+		links = tmp->state->data;
+		FOR_EACH_PTR(links, link) {
+			sm = get_sm_state(compare_id, link, NULL);
+			if (!sm)
+				continue;
+			data = sm->state->data;
+			if (!data || !data->comparison)
+				continue;
+			if (ptr_list_size((struct ptr_list *)data->left_vsl) != 1 ||
+			    ptr_list_size((struct ptr_list *)data->right_vsl) != 1)
+				continue;
+			left = first_ptr_list((struct ptr_list *)data->left_vsl);
+			right = first_ptr_list((struct ptr_list *)data->right_vsl);
+			if (left->sym == right->sym &&
+			    strcmp(left->var, right->var) == 0)
+				continue;
+			/*
+			 * Both parameters link to this comparison so only
+			 * record the first one.
+			 */
+			if (left->sym != tmp->sym ||
+			    strcmp(left->var, tmp->name) != 0)
+				continue;
+
+			if (strstr(right->var, " orig"))
+				continue;
+
+			left_param = get_param_num_from_sym(left->sym);
+			right_param = get_param_num_from_sym(right->sym);
+			if (left_param < 0 || right_param < 0)
+				continue;
+
+			tmp_name = get_param_name_var_sym(left->var, left->sym);
+			if (!tmp_name)
+				continue;
+			snprintf(left_buf, sizeof(left_buf), "%s", tmp_name);
+
+			tmp_name = get_param_name_var_sym(right->var, right->sym);
+			if (!tmp_name || tmp_name[0] != '$')
+				continue;
+			snprintf(right_buf, sizeof(right_buf), "$%d%s", right_param, tmp_name + 1);
+
+			/*
+			 * FIXME: this should reject $ type variables (as
+			 * opposed to $->foo type).  Those should come from
+			 * smatch_param_compare_limit.c.
+			 */
+
+			snprintf(info_buf, sizeof(info_buf), "%s %s", show_special(data->comparison), right_buf);
+			sql_insert_return_states(return_id, return_ranges,
+					PARAM_COMPARE, left_param, left_buf, info_buf);
+		} END_FOR_EACH_PTR(link);
+
+	} END_FOR_EACH_SM(tmp);
+}
+
+static int parse_comparison(char **value, int *op)
+{
+
+	*op = **value;
+
+	switch (*op) {
+	case '<':
+		(*value)++;
+		if (**value == '=') {
+			(*value)++;
+			*op = SPECIAL_LTE;
+		}
+		break;
+	case '=':
+		(*value)++;
+		(*value)++;
+		*op = SPECIAL_EQUAL;
+		break;
+	case '!':
+		(*value)++;
+		(*value)++;
+		*op = SPECIAL_NOTEQUAL;
+		break;
+	case '>':
+		(*value)++;
+		if (**value == '=') {
+			(*value)++;
+			*op = SPECIAL_GTE;
+		}
+		break;
+	default:
+		return 0;
+	}
+
+	if (**value != ' ') {
+		sm_perror("parsing comparison.  %s", *value);
+		return 0;
+	}
+
+	(*value)++;
+	return 1;
+}
+
+static int split_op_param_key(char *value, int *op, int *param, char **key)
+{
+	static char buf[256];
+	char *p;
+
+	if (!parse_comparison(&value, op))
+		return 0;
+
+	snprintf(buf, sizeof(buf), value);
+
+	p = buf;
+	if (*p++ != '$')
+		return 0;
+
+	*param = atoi(p);
+	if (*param < 0 || *param > 99)
+		return 0;
+	p++;
+	if (*param > 9)
+		p++;
+	p--;
+	*p = '$';
+	*key = p;
+
+	return 1;
+}
+
+static void db_return_comparison(struct expression *expr, int left_param, char *key, char *value)
+{
+	struct expression *left_arg, *right_arg;
+	char *left_name = NULL;
+	struct symbol *left_sym;
+	char *right_name = NULL;
+	struct symbol *right_sym;
+	int op;
+	int right_param;
+	char *right_key;
+	struct var_sym_list *left_vsl = NULL, *right_vsl = NULL;
+
+	if (left_param == -1) {
+		if (expr->type != EXPR_ASSIGNMENT)
+			return;
+		left_arg = strip_expr(expr->left);
+
+		while (expr->type == EXPR_ASSIGNMENT)
+			expr = strip_expr(expr->right);
+		if (expr->type != EXPR_CALL)
+			return;
+	} else {
+		while (expr->type == EXPR_ASSIGNMENT)
+			expr = strip_expr(expr->right);
+		if (expr->type != EXPR_CALL)
+			return;
+
+		left_arg = get_argument_from_call_expr(expr->args, left_param);
+		if (!left_arg)
+			return;
+	}
+
+	if (!split_op_param_key(value, &op, &right_param, &right_key))
+		return;
+
+	right_arg = get_argument_from_call_expr(expr->args, right_param);
+	if (!right_arg)
+		return;
+
+	left_name = get_variable_from_key(left_arg, key, &left_sym);
+	if (!left_name || !left_sym)
+		goto free;
+
+	right_name = get_variable_from_key(right_arg, right_key, &right_sym);
+	if (!right_name || !right_sym)
+		goto free;
+
+	add_var_sym(&left_vsl, left_name, left_sym);
+	add_var_sym(&right_vsl, right_name, right_sym);
+
+	add_comparison_var_sym(NULL, left_name, left_vsl, op, NULL, right_name, right_vsl);
+
+free:
+	free_string(left_name);
+	free_string(right_name);
+}
+
+int param_compare_limit_is_impossible(struct expression *expr, int left_param, char *left_key, char *value)
+{
+	struct smatch_state *state;
+	char *left_name = NULL;
+	char *right_name = NULL;
+	struct symbol *left_sym, *right_sym;
+	struct expression *left_arg, *right_arg;
+	int op, state_op;
+	int right_param;
+	char *right_key;
+	int ret = 0;
+	char buf[256];
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return 0;
+
+	if (!split_op_param_key(value, &op, &right_param, &right_key))
+		return 0;
+
+	left_arg = get_argument_from_call_expr(expr->args, left_param);
+	if (!left_arg)
+		return 0;
+
+	right_arg = get_argument_from_call_expr(expr->args, right_param);
+	if (!right_arg)
+		return 0;
+
+	left_name = get_variable_from_key(left_arg, left_key, &left_sym);
+	right_name = get_variable_from_key(right_arg, right_key, &right_sym);
+	if (!left_name || !right_name)
+		goto free;
+
+	snprintf(buf, sizeof(buf), "%s vs %s", left_name, right_name);
+	state = get_state(compare_id, buf, NULL);
+	if (!state)
+		goto free;
+	state_op = state_to_comparison(state);
+	if (!state_op)
+		goto free;
+
+	if (!filter_comparison(remove_unsigned_from_comparison(state_op), op))
+		ret = 1;
+free:
+	free_string(left_name);
+	free_string(right_name);
+	return ret;
+}
+
+int impossibly_high_comparison(struct expression *expr)
+{
+	struct smatch_state *link_state;
+	struct sm_state *sm;
+	struct string_list *links;
+	char *link;
+	struct compare_data *data;
+
+	link_state = get_state_expr(link_id, expr);
+	if (!link_state) {
+		if (expr->type == EXPR_BINOP &&
+		    (impossibly_high_comparison(expr->left) ||
+		     impossibly_high_comparison(expr->right)))
+			return 1;
+		return 0;
+	}
+
+	links = link_state->data;
+	FOR_EACH_PTR(links, link) {
+		sm = get_sm_state(compare_id, link, NULL);
+		if (!sm)
+			continue;
+		data = sm->state->data;
+		if (!data)
+			continue;
+		if (!possibly_true(data->left, data->comparison, data->right))
+			return 1;
+	} END_FOR_EACH_PTR(link);
+
+	return 0;
+}
+
+static void free_data(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	clear_compare_data_alloc();
+}
+
+void register_comparison(int id)
+{
+	compare_id = id;
+	add_hook(&save_start_states, AFTER_DEF_HOOK);
+	add_unmatched_state_hook(compare_id, unmatched_comparison);
+	add_pre_merge_hook(compare_id, &pre_merge_hook);
+	add_merge_hook(compare_id, &merge_compare_states);
+	add_hook(&free_data, AFTER_FUNC_HOOK);
+	add_hook(&match_call_info, FUNCTION_CALL_HOOK);
+	add_split_return_callback(&print_return_comparison);
+
+	select_return_states_hook(PARAM_COMPARE, &db_return_comparison);
+	add_hook(&match_preop, OP_HOOK);
+}
+
+void register_comparison_late(int id)
+{
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+}
+
+void register_comparison_links(int id)
+{
+	link_id = id;
+	add_merge_hook(link_id, &merge_links);
+	add_modification_hook(link_id, &match_modify);
+	add_modification_hook_late(link_id, match_inc_dec);
+
+	add_member_info_callback(link_id, struct_member_callback);
+}
+
+void register_comparison_inc_dec(int id)
+{
+	inc_dec_id = id;
+	add_modification_hook_late(inc_dec_id, &iter_modify);
+}
+
+void register_comparison_inc_dec_links(int id)
+{
+	inc_dec_link_id = id;
+	set_up_link_functions(inc_dec_id, inc_dec_link_id);
+}
+
+static void filter_by_sm(struct sm_state *sm, int op,
+		       struct state_list **true_stack,
+		       struct state_list **false_stack)
+{
+	struct compare_data *data;
+	int istrue = 0;
+	int isfalse = 0;
+
+	if (!sm)
+		return;
+	data = sm->state->data;
+	if (!data) {
+		if (sm->merged) {
+			filter_by_sm(sm->left, op, true_stack, false_stack);
+			filter_by_sm(sm->right, op, true_stack, false_stack);
+		}
+		return;
+	}
+
+	if (data->comparison &&
+	    data->comparison == filter_comparison(data->comparison, op))
+		istrue = 1;
+
+	if (data->comparison &&
+	    data->comparison == filter_comparison(data->comparison, negate_comparison(op)))
+		isfalse = 1;
+
+	if (istrue)
+		add_ptr_list(true_stack, sm);
+	if (isfalse)
+		add_ptr_list(false_stack, sm);
+
+	if (sm->merged) {
+		filter_by_sm(sm->left, op, true_stack, false_stack);
+		filter_by_sm(sm->right, op, true_stack, false_stack);
+	}
+}
+
+struct sm_state *comparison_implication_hook(struct expression *expr,
+				struct state_list **true_stack,
+				struct state_list **false_stack)
+{
+	struct sm_state *sm;
+	char *left, *right;
+	int op;
+	static char buf[256];
+
+	if (expr->type != EXPR_COMPARE)
+		return NULL;
+
+	op = expr->op;
+
+	left = expr_to_var(expr->left);
+	right = expr_to_var(expr->right);
+	if (!left || !right) {
+		free_string(left);
+		free_string(right);
+		return NULL;
+	}
+
+	if (strcmp(left, right) > 0) {
+		char *tmp = left;
+
+		left = right;
+		right = tmp;
+		op = flip_comparison(op);
+	}
+
+	snprintf(buf, sizeof(buf), "%s vs %s", left, right);
+	sm = get_sm_state(compare_id, buf, NULL);
+	if (!sm)
+		return NULL;
+	if (!sm->merged)
+		return NULL;
+
+	filter_by_sm(sm, op, true_stack, false_stack);
+	if (!*true_stack && !*false_stack)
+		return NULL;
+
+	if (option_debug)
+		sm_msg("implications from comparison: (%s)", show_sm(sm));
+
+	return sm;
+}
diff --git a/usr/src/tools/smatch/src/smatch_conditions.c b/usr/src/tools/smatch/src/smatch_conditions.c
new file mode 100644
index 0000000000..79f89bdd56
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_conditions.c
@@ -0,0 +1,752 @@
+/*
+ * Copyright (C) 2006,2008 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The simplest type of condition is
+ * if (a) { ...
+ *
+ * The next simplest kind of conditions is
+ * if (a && b) { c;
+ * In that case 'a' is true when we get to 'b' and both are true
+ * when we get to c.
+ *
+ * Or's are a little more complicated.
+ * if (a || b) { c;
+ * We know 'a' is not true when we get to 'b' but it may be true
+ * when we get to c.
+ *
+ * If we mix and's and or's that's even more complicated.
+ * if (a && b && c || a && d) { d ;
+ * 'a' is true when we evaluate 'b', and 'd'.
+ * 'b' is true when we evaluate 'c' but otherwise we don't.
+ *
+ * The other thing that complicates matters is if we negate
+ * some if conditions.
+ * if (!a) { ...
+ * Smatch has passes the un-negated version to the client and flip
+ * the true and false values internally.  This makes it easier
+ * to write checks.
+ *
+ * And negations can be part of a compound.
+ * if (a && !(b || c)) { d;
+ * In that situation we multiply the negative through to simplify
+ * stuff so that we can remove the parens like this:
+ * if (a && !b && !c) { d;
+ *
+ * One other thing is that:
+ * if ((a) != 0){ ...
+ * that's basically the same as testing for just 'a' and we simplify
+ * comparisons with zero before passing it to the script.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+#include "smatch_expression_stacks.h"
+
+extern int __expr_stmt_count;
+
+struct expression_list *big_condition_stack;
+
+static void split_conditions(struct expression *expr);
+
+static int is_logical_and(struct expression *expr)
+{
+	if (expr->op == SPECIAL_LOGICAL_AND)
+		return 1;
+	return 0;
+}
+
+static int handle_zero_comparisons(struct expression *expr)
+{
+	struct expression *tmp = NULL;
+	struct expression *zero;
+
+	// if left is zero or right is zero
+	if (is_zero(expr->left)) {
+		zero = strip_expr(expr->left);
+		if (zero->type != EXPR_VALUE)
+			__split_expr(expr->left);
+		tmp = expr->right;
+	} else if (is_zero(expr->right)) {
+		zero = strip_expr(expr->left);
+		if (zero->type != EXPR_VALUE)
+			__split_expr(expr->right);
+		tmp = expr->left;
+	} else {
+		return 0;
+	}
+
+	// "if (foo != 0)" is the same as "if (foo)"
+	if (expr->op == SPECIAL_NOTEQUAL) {
+		split_conditions(tmp);
+		return 1;
+	}
+
+	// "if (foo == 0)" is the same as "if (!foo)"
+	if (expr->op == SPECIAL_EQUAL) {
+		split_conditions(tmp);
+		__negate_cond_stacks();
+		return 1;
+	}
+
+	return 0;
+}
+
+/*
+ * This function is for handling calls to likely/unlikely
+ */
+
+static int ignore_builtin_expect(struct expression *expr)
+{
+	if (sym_name_is("__builtin_expect", expr->fn)) {
+		split_conditions(first_ptr_list((struct ptr_list *) expr->args));
+		return 1;
+	}
+	return 0;
+}
+
+/*
+ * handle_compound_stmt() is for: foo = ({blah; blah; blah; 1})
+ */
+
+static void handle_compound_stmt(struct statement *stmt)
+{
+	struct expression *expr = NULL;
+	struct statement *last;
+	struct statement *s;
+
+	last = last_ptr_list((struct ptr_list *)stmt->stmts);
+	if (last->type == STMT_LABEL) {
+		if (last->label_statement &&
+		    last->label_statement->type == STMT_EXPRESSION)
+			expr = last->label_statement->expression;
+		else
+			last = NULL;
+	} else if (last->type != STMT_EXPRESSION) {
+		last = NULL;
+	} else {
+		expr = last->expression;
+	}
+
+	FOR_EACH_PTR(stmt->stmts, s) {
+		if (s != last)
+			__split_stmt(s);
+	} END_FOR_EACH_PTR(s);
+	if (last && last->type == STMT_LABEL)
+		__split_label_stmt(last);
+	split_conditions(expr);
+}
+
+static int handle_preop(struct expression *expr)
+{
+	struct statement *stmt;
+
+	if (expr->op == '!') {
+		split_conditions(expr->unop);
+		__negate_cond_stacks();
+		return 1;
+	}
+	stmt = get_expression_statement(expr);
+	if (stmt) {
+		handle_compound_stmt(stmt);
+		return 1;
+	}
+	return 0;
+}
+
+static void handle_logical(struct expression *expr)
+{
+	/*
+	 * If we come to an "and" expr then:
+	 * We split the left side.
+	 * We keep all the current states.
+	 * We split the right side.
+	 * We keep all the states from both true sides.
+	 *
+	 * If it's an "or" expr then:
+	 * We save the current slist.
+	 * We split the left side.
+	 * We use the false states for the right side.
+	 * We split the right side.
+	 * We save all the states that are the same on both sides.
+	 */
+
+	split_conditions(expr->left);
+
+	if (is_logical_and(expr))
+		__use_cond_true_states();
+	else
+		__use_cond_false_states();
+
+	__push_cond_stacks();
+
+	__save_pre_cond_states();
+	split_conditions(expr->right);
+	__discard_pre_cond_states();
+
+	if (is_logical_and(expr))
+		__and_cond_states();
+	else
+		__or_cond_states();
+
+	__use_cond_true_states();
+}
+
+static struct stree *combine_strees(struct stree *orig, struct stree *fake, struct stree *new)
+{
+	struct stree *ret = NULL;
+
+	overwrite_stree(orig, &ret);
+	overwrite_stree(fake, &ret);
+	overwrite_stree(new, &ret);
+	free_stree(&new);
+
+	return ret;
+}
+
+/*
+ * handle_select()
+ * if ((aaa()?bbb():ccc())) { ...
+ *
+ * This is almost the same as:
+ * if ((aaa() && bbb()) || (!aaa() && ccc())) { ...
+ *
+ * It's a bit complicated because we shouldn't pass aaa()
+ * to the clients more than once.
+ */
+
+static void handle_select(struct expression *expr)
+{
+	struct stree *a_T = NULL;
+	struct stree *a_F = NULL;
+	struct stree *a_T_b_T = NULL;
+	struct stree *a_T_b_F = NULL;
+	struct stree *a_T_b_fake = NULL;
+	struct stree *a_F_c_T = NULL;
+	struct stree *a_F_c_F = NULL;
+	struct stree *a_F_c_fake = NULL;
+	struct stree *tmp;
+	struct sm_state *sm;
+
+	/*
+	 * Imagine we have this:  if (a ? b : c) { ...
+	 *
+	 * The condition is true if "a" is true and "b" is true or
+	 * "a" is false and "c" is true.  It's false if "a" is true
+	 * and "b" is false or "a" is false and "c" is false.
+	 *
+	 * The variable name "a_T_b_T" stands for "a true b true" etc.
+	 *
+	 * But if we know "b" is true then we can simpilify things.
+	 * The condition is true if "a" is true or if "a" is false and
+	 * "c" is true.  The only way the condition can be false is if
+	 * "a" is false and "c" is false.
+	 *
+	 * The remaining thing is the "a_T_b_fake".  When we simplify
+	 * the equations we have to take into consideration that other
+	 * states may have changed that don't play into the true false
+	 * equation.  Take the following example:
+	 * if ({
+	 *         (flags) = __raw_local_irq_save();
+	 *         _spin_trylock(lock) ? 1 :
+	 *                 ({ raw_local_irq_restore(flags);  0; });
+	 *    })
+	 * Smatch has to record that the irq flags were restored on the
+	 * false path.
+	 *
+	 */
+
+	__save_pre_cond_states();
+
+	split_conditions(expr->conditional);
+
+	a_T = __copy_cond_true_states();
+	a_F = __copy_cond_false_states();
+
+	__use_cond_true_states();
+
+	__push_cond_stacks();
+	__push_fake_cur_stree();
+	split_conditions(expr->cond_true);
+	__process_post_op_stack();
+	a_T_b_fake = __pop_fake_cur_stree();
+	a_T_b_T = combine_strees(a_T, a_T_b_fake, __pop_cond_true_stack());
+	a_T_b_F = combine_strees(a_T, a_T_b_fake, __pop_cond_false_stack());
+
+	__use_cond_false_states();
+
+	__push_cond_stacks();
+	__push_fake_cur_stree();
+	split_conditions(expr->cond_false);
+	a_F_c_fake = __pop_fake_cur_stree();
+	a_F_c_T = combine_strees(a_F, a_F_c_fake, __pop_cond_true_stack());
+	a_F_c_F = combine_strees(a_F, a_F_c_fake, __pop_cond_false_stack());
+
+	/* We have to restore the pre condition states so that
+	   implied_condition_true() will use the right cur_stree */
+	__use_pre_cond_states();
+
+	if (implied_condition_true(expr->cond_true)) {
+		free_stree(&a_T_b_T);
+		free_stree(&a_T_b_F);
+		a_T_b_T = clone_stree(a_T);
+		overwrite_stree(a_T_b_fake, &a_T_b_T);
+	}
+	if (implied_condition_false(expr->cond_true)) {
+		free_stree(&a_T_b_T);
+		free_stree(&a_T_b_F);
+		a_T_b_F = clone_stree(a_T);
+		overwrite_stree(a_T_b_fake, &a_T_b_F);
+	}
+	if (implied_condition_true(expr->cond_false)) {
+		free_stree(&a_F_c_T);
+		free_stree(&a_F_c_F);
+		a_F_c_T = clone_stree(a_F);
+		overwrite_stree(a_F_c_fake, &a_F_c_T);
+	}
+	if (implied_condition_false(expr->cond_false)) {
+		free_stree(&a_F_c_T);
+		free_stree(&a_F_c_F);
+		a_F_c_F = clone_stree(a_F);
+		overwrite_stree(a_F_c_fake, &a_F_c_F);
+	}
+
+	merge_stree(&a_T_b_T, a_F_c_T);
+	merge_stree(&a_T_b_F, a_F_c_F);
+
+	tmp = __pop_cond_true_stack();
+	free_stree(&tmp);
+	tmp = __pop_cond_false_stack();
+	free_stree(&tmp);
+
+	__push_cond_stacks();
+	FOR_EACH_SM(a_T_b_T, sm) {
+		__set_true_false_sm(sm, NULL);
+	} END_FOR_EACH_SM(sm);
+	FOR_EACH_SM(a_T_b_F, sm) {
+		__set_true_false_sm(NULL, sm);
+	} END_FOR_EACH_SM(sm);
+	__free_set_states();
+
+	free_stree(&a_T_b_fake);
+	free_stree(&a_F_c_fake);
+	free_stree(&a_F_c_T);
+	free_stree(&a_F_c_F);
+	free_stree(&a_T_b_T);
+	free_stree(&a_T_b_F);
+	free_stree(&a_T);
+	free_stree(&a_F);
+}
+
+static void handle_comma(struct expression *expr)
+{
+	__split_expr(expr->left);
+	split_conditions(expr->right);
+}
+
+static int make_op_unsigned(int op)
+{
+	switch (op) {
+	case '<':
+		return SPECIAL_UNSIGNED_LT;
+	case SPECIAL_LTE:
+		return SPECIAL_UNSIGNED_LTE;
+	case '>':
+		return SPECIAL_UNSIGNED_GT;
+	case SPECIAL_GTE:
+		return SPECIAL_UNSIGNED_GTE;
+	}
+	return op;
+}
+
+static void hackup_unsigned_compares(struct expression *expr)
+{
+	if (expr->type != EXPR_COMPARE)
+		return;
+
+	if (type_unsigned(get_type(expr)))
+		expr->op = make_op_unsigned(expr->op);
+}
+
+static void do_condition(struct expression *expr)
+{
+	__fold_in_set_states();
+	__push_fake_cur_stree();
+	__pass_to_client(expr, CONDITION_HOOK);
+	__fold_in_set_states();
+}
+
+static void split_conditions(struct expression *expr)
+{
+	if (option_debug) {
+		char *cond = expr_to_str(expr);
+
+		sm_msg("%d in split_conditions (%s)", get_lineno(), cond);
+		free_string(cond);
+	}
+
+	expr = strip_expr_set_parent(expr);
+	if (!expr) {
+		__fold_in_set_states();
+		return;
+	}
+
+	/*
+	 * On fast paths (and also I guess some people think it's cool) people
+	 * sometimes use | instead of ||.  It works the same basically except
+	 * that || implies a memory barrier between conditions.  The easiest way
+	 * to handle it is by pretending that | also has a barrier and re-using
+	 * all the normal condition code.  This potentially hides some bugs, but
+	 * people who write code like this should just be careful or they
+	 * deserve bugs.
+	 *
+	 * We could potentially treat boolean bitwise & this way but that seems
+	 * too complicated to deal with.
+	 */
+	if (expr->type == EXPR_BINOP && expr->op == '|') {
+		handle_logical(expr);
+		return;
+	}
+
+	switch (expr->type) {
+	case EXPR_LOGICAL:
+		expr_set_parent_expr(expr->left, expr);
+		expr_set_parent_expr(expr->right, expr);
+		__pass_to_client(expr, LOGIC_HOOK);
+		handle_logical(expr);
+		return;
+	case EXPR_COMPARE:
+		expr_set_parent_expr(expr->left, expr);
+		expr_set_parent_expr(expr->right, expr);
+		hackup_unsigned_compares(expr);
+		if (handle_zero_comparisons(expr))
+			return;
+		break;
+	case EXPR_CALL:
+		if (ignore_builtin_expect(expr))
+			return;
+		break;
+	case EXPR_PREOP:
+		expr_set_parent_expr(expr->unop, expr);
+		if (handle_preop(expr))
+			return;
+		break;
+	case EXPR_CONDITIONAL:
+	case EXPR_SELECT:
+		expr_set_parent_expr(expr->conditional, expr);
+		expr_set_parent_expr(expr->cond_true, expr);
+		expr_set_parent_expr(expr->cond_false, expr);
+		handle_select(expr);
+		return;
+	case EXPR_COMMA:
+		expr_set_parent_expr(expr->left, expr);
+		expr_set_parent_expr(expr->right, expr);
+		handle_comma(expr);
+		return;
+	}
+
+	/* fixme: this should be in smatch_flow.c
+	   but because of the funny stuff we do with conditions
+	   it's awkward to put it there.  We would need to
+	   call CONDITION_HOOK in smatch_flow as well.
+	*/
+	push_expression(&big_expression_stack, expr);
+	push_expression(&big_condition_stack, expr);
+
+	if (expr->type == EXPR_COMPARE) {
+		if (expr->left->type != EXPR_POSTOP)
+			__split_expr(expr->left);
+		if (expr->right->type != EXPR_POSTOP)
+			__split_expr(expr->right);
+	} else if (expr->type != EXPR_POSTOP) {
+		__split_expr(expr);
+	}
+	do_condition(expr);
+	if (expr->type == EXPR_COMPARE) {
+		if (expr->left->type == EXPR_POSTOP)
+			__split_expr(expr->left);
+		if (expr->right->type == EXPR_POSTOP)
+			__split_expr(expr->right);
+	} else if (expr->type == EXPR_POSTOP) {
+		__split_expr(expr);
+	}
+	__push_fake_cur_stree();
+	__process_post_op_stack();
+	__fold_in_set_states();
+	pop_expression(&big_condition_stack);
+	pop_expression(&big_expression_stack);
+}
+
+static int inside_condition;
+void __split_whole_condition(struct expression *expr)
+{
+	sm_debug("%d in __split_whole_condition\n", get_lineno());
+	inside_condition++;
+	__save_pre_cond_states();
+	__push_cond_stacks();
+	/* it's a hack, but it's sometimes handy to have this stuff
+	   on the big_expression_stack.  */
+	push_expression(&big_expression_stack, expr);
+	split_conditions(expr);
+	__use_cond_states();
+	__pass_to_client(expr, WHOLE_CONDITION_HOOK);
+	pop_expression(&big_expression_stack);
+	inside_condition--;
+	sm_debug("%d done __split_whole_condition\n", get_lineno());
+}
+
+void __handle_logic(struct expression *expr)
+{
+	sm_debug("%d in __handle_logic\n", get_lineno());
+	inside_condition++;
+	__save_pre_cond_states();
+	__push_cond_stacks();
+	/* it's a hack, but it's sometimes handy to have this stuff
+	   on the big_expression_stack.  */
+	push_expression(&big_expression_stack, expr);
+	if (expr)
+		split_conditions(expr);
+	__use_cond_states();
+	__pass_to_client(expr, WHOLE_CONDITION_HOOK);
+	pop_expression(&big_expression_stack);
+	__merge_false_states();
+	inside_condition--;
+	sm_debug("%d done __handle_logic\n", get_lineno());
+}
+
+int is_condition(struct expression *expr)
+{
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return 0;
+
+	switch (expr->type) {
+	case EXPR_LOGICAL:
+	case EXPR_COMPARE:
+		return 1;
+	case EXPR_PREOP:
+		if (expr->op == '!')
+			return 1;
+	}
+	return 0;
+}
+
+int __handle_condition_assigns(struct expression *expr)
+{
+	struct expression *right;
+	struct stree *true_stree, *false_stree, *fake_stree;
+	struct sm_state *sm;
+
+	if (expr->op != '=')
+		return 0;
+	right = strip_expr(expr->right);
+	if (!is_condition(expr->right))
+		return 0;
+
+	sm_debug("%d in __handle_condition_assigns\n", get_lineno());
+	inside_condition++;
+	__save_pre_cond_states();
+	__push_cond_stacks();
+	/* it's a hack, but it's sometimes handy to have this stuff
+	   on the big_expression_stack.  */
+	push_expression(&big_expression_stack, right);
+	split_conditions(right);
+	true_stree = __get_true_states();
+	false_stree = __get_false_states();
+	__use_cond_states();
+	__push_fake_cur_stree();
+	set_extra_expr_mod(expr->left, alloc_estate_sval(sval_type_val(get_type(expr->left), 1)));
+	__pass_to_client(right, WHOLE_CONDITION_HOOK);
+
+	fake_stree = __pop_fake_cur_stree();
+	FOR_EACH_SM(fake_stree, sm) {
+		overwrite_sm_state_stree(&true_stree, sm);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&fake_stree);
+
+	pop_expression(&big_expression_stack);
+	inside_condition--;
+
+	__push_true_states();
+
+	__use_false_states();
+	__push_fake_cur_stree();
+	set_extra_expr_mod(expr->left, alloc_estate_sval(sval_type_val(get_type(expr->left), 0)));
+
+	fake_stree = __pop_fake_cur_stree();
+	FOR_EACH_SM(fake_stree, sm) {
+		overwrite_sm_state_stree(&false_stree, sm);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&fake_stree);
+
+	__merge_true_states();
+	merge_fake_stree(&true_stree, false_stree);
+	free_stree(&false_stree);
+	FOR_EACH_SM(true_stree, sm) {
+		__set_sm(sm);
+	} END_FOR_EACH_SM(sm);
+
+	__pass_to_client(expr, ASSIGNMENT_HOOK);
+	sm_debug("%d done __handle_condition_assigns\n", get_lineno());
+	return 1;
+}
+
+static int is_select_assign(struct expression *expr)
+{
+	struct expression *right;
+
+	if (expr->op != '=')
+		return 0;
+	right = strip_expr(expr->right);
+	if (right->type == EXPR_CONDITIONAL)
+		return 1;
+	if (right->type == EXPR_SELECT)
+		return 1;
+	return 0;
+}
+
+int __handle_select_assigns(struct expression *expr)
+{
+	struct expression *right;
+	struct stree *final_states = NULL;
+	struct sm_state *sm;
+	int is_true;
+	int is_false;
+
+	if (!is_select_assign(expr))
+		return 0;
+	sm_debug("%d in __handle_ternary_assigns\n", get_lineno());
+	right = strip_expr(expr->right);
+	__pass_to_client(right, SELECT_HOOK);
+
+	is_true = implied_condition_true(right->conditional);
+	is_false = implied_condition_false(right->conditional);
+
+	/* hah hah.  the ultra fake out */
+	__save_pre_cond_states();
+	__split_whole_condition(right->conditional);
+
+	if (!is_false) {
+		struct expression *fake_expr;
+
+		if (right->cond_true)
+			fake_expr = assign_expression(expr->left, expr->op, right->cond_true);
+		else
+			fake_expr = assign_expression(expr->left, expr->op, right->conditional);
+		__split_expr(fake_expr);
+		final_states = clone_stree(__get_cur_stree());
+	}
+
+	__use_false_states();
+	if (!is_true) {
+		struct expression *fake_expr;
+
+		fake_expr = assign_expression(expr->left, expr->op, right->cond_false);
+		__split_expr(fake_expr);
+		merge_stree(&final_states, __get_cur_stree());
+	}
+
+	__use_pre_cond_states();
+
+	FOR_EACH_SM(final_states, sm) {
+		__set_sm(sm);
+	} END_FOR_EACH_SM(sm);
+
+	free_stree(&final_states);
+
+	sm_debug("%d done __handle_ternary_assigns\n", get_lineno());
+
+	return 1;
+}
+
+static struct statement *split_then_return_last(struct statement *stmt)
+{
+	struct statement *tmp;
+	struct statement *last_stmt;
+
+	last_stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
+	if (!last_stmt)
+		return NULL;
+
+	__push_scope_hooks();
+	FOR_EACH_PTR(stmt->stmts, tmp) {
+		if (tmp == last_stmt) {
+			if (tmp->type == STMT_LABEL) {
+				__split_label_stmt(tmp);
+				return tmp->label_statement;
+			}
+			return last_stmt;
+		}
+		__split_stmt(tmp);
+	} END_FOR_EACH_PTR(tmp);
+	return NULL;
+}
+
+int __handle_expr_statement_assigns(struct expression *expr)
+{
+	struct expression *right;
+	struct statement *stmt;
+
+	right = expr->right;
+	if (right->type == EXPR_PREOP && right->op == '(')
+		right = right->unop;
+	if (right->type != EXPR_STATEMENT)
+		return 0;
+
+	__expr_stmt_count++;
+	stmt = right->statement;
+	if (stmt->type == STMT_COMPOUND) {
+		struct statement *last_stmt;
+		struct expression *fake_assign;
+		struct expression fake_expr_stmt = { .smatch_flags = Fake, };
+
+		last_stmt = split_then_return_last(stmt);
+		if (!last_stmt) {
+			__expr_stmt_count--;
+			return 0;
+		}
+
+		fake_expr_stmt.pos = last_stmt->pos;
+		fake_expr_stmt.type = EXPR_STATEMENT;
+		fake_expr_stmt.op = 0;
+		fake_expr_stmt.statement = last_stmt;
+
+		fake_assign = assign_expression(expr->left, expr->op, &fake_expr_stmt);
+		__split_expr(fake_assign);
+
+		__pass_to_client(stmt, STMT_HOOK_AFTER);
+		__call_scope_hooks();
+	} else if (stmt->type == STMT_EXPRESSION) {
+		struct expression *fake_assign;
+
+		fake_assign = assign_expression(expr->left, expr->op, stmt->expression);
+		__split_expr(fake_assign);
+
+	} else {
+		__split_stmt(stmt);
+	}
+	__expr_stmt_count--;
+	return 1;
+}
+
+int in_condition(void)
+{
+	return inside_condition;
+}
diff --git a/usr/src/tools/smatch/src/smatch_constraints.c b/usr/src/tools/smatch/src/smatch_constraints.c
new file mode 100644
index 0000000000..b026e90383
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_constraints.c
@@ -0,0 +1,541 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Basically I see constraints as a way of saying "x <= some_limit".  The
+ * problem is that smatch_capped is not granullar enough.
+ *
+ * This is mostly for finding out of bounds errors.  So there are different
+ * types of constraints.  Quite often we have "foo->xxx[i] = 42;" and we want
+ * to verify that "i" is less than foo->size.
+ *
+ * My idea was that we could automatically figure out these constraints.  And we
+ * could load them in the DB so that they are the same every time.  As in a
+ * constraint could be "< (struct whatever)->size" and give that in ID that
+ * would be constant until you completely wiped the DB.  So when you do a normal
+ * DB rebuild then the first thing it will do is preserve all the constraints.
+ * I guess the reason to do it this way is to save space...  I sometimes suspect
+ * that worrying about saving space is premature optimization.
+ *
+ * The other thing that I want to do a little bit different here is how I merge
+ * constraints.  If a constraint is true on both sides, then that's normal.  If
+ * we merge constraint 23 and 67 then we get constraint 23|67.  If we merge 23
+ * with &undefined then we get &undefined.  We can also have two constraints
+ * that are both true so we could have (45&23)|12 which means either both 45 and
+ * 23 are true or 12 is true.
+ *
+ */
+
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+ALLOCATOR(constraint, "constraints");
+
+static void add_constraint(struct constraint_list **list, int op, int constraint)
+{
+	struct constraint *tmp, *new;
+
+	FOR_EACH_PTR(*list, tmp) {
+		if (tmp->id < constraint)
+			continue;
+		if (tmp->id == constraint) {
+			if (tmp->op == '<')
+				return;
+			if (op == SPECIAL_LTE)
+				return;
+
+			new = __alloc_constraint(0);
+			new->op = op;
+			new->id = constraint;
+			REPLACE_CURRENT_PTR(tmp, new);
+			return;
+		}
+
+		new = __alloc_constraint(0);
+		new->op = op;
+		new->id = constraint;
+		INSERT_CURRENT(new, tmp);
+		return;
+	} END_FOR_EACH_PTR(tmp);
+
+	new = __alloc_constraint(0);
+	new->op = op;
+	new->id = constraint;
+	add_ptr_list(list, new);
+}
+
+static struct constraint_list *merge_constraint_lists(struct constraint_list *one, struct constraint_list *two)
+{
+	struct constraint_list *ret = NULL;
+	struct constraint *tmp;
+
+	// FIXME: not || but &&
+	FOR_EACH_PTR(one, tmp) {
+		add_constraint(&ret, tmp->op, tmp->id);
+	} END_FOR_EACH_PTR(tmp);
+
+	FOR_EACH_PTR(two, tmp) {
+		add_constraint(&ret, tmp->op, tmp->id);
+	} END_FOR_EACH_PTR(tmp);
+
+	return ret;
+}
+
+static struct constraint_list *clone_constraint_list(struct constraint_list *list)
+{
+	struct constraint_list *ret = NULL;
+	struct constraint *tmp;
+
+	FOR_EACH_PTR(list, tmp) {
+		add_constraint(&ret, tmp->op, tmp->id);
+	} END_FOR_EACH_PTR(tmp);
+
+	return ret;
+}
+
+static struct smatch_state *alloc_constraint_state(struct constraint_list *list)
+{
+	struct smatch_state *state;
+	struct constraint *con;
+	static char buf[256];
+	int cnt = 0;
+
+	FOR_EACH_PTR(list, con) {
+		if (cnt != 0)
+			cnt += snprintf(buf + cnt, sizeof(buf) - cnt, ", ");
+		cnt += snprintf(buf + cnt, sizeof(buf) - cnt, "%s%d",
+				show_special(con->op), con->id);
+	} END_FOR_EACH_PTR(con);
+
+	state = __alloc_smatch_state(0);
+	state->name = alloc_string(buf);
+	state->data = list;
+	return state;
+}
+
+static struct smatch_state *merge_func(struct smatch_state *s1, struct smatch_state *s2)
+{
+	struct constraint_list *list;
+
+	// FIXME:  use the dead code below instead
+	if (strcmp(s1->name, s2->name) == 0)
+		return s1;
+	return &merged;
+
+	list = merge_constraint_lists(s1->data, s2->data);
+	return alloc_constraint_state(list);
+}
+
+static int negate_gt(int op)
+{
+	switch (op) {
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+	case SPECIAL_GTE:
+	case SPECIAL_UNSIGNED_GTE:
+		return negate_comparison(op);
+	}
+	return op;
+}
+
+static char *get_func_constraint(struct expression *expr)
+{
+	char buf[256];
+	char *name;
+
+	if (is_fake_call(expr))
+		return NULL;
+	name = expr_to_str(expr->fn);
+	if (!name)
+		return NULL;
+	snprintf(buf, sizeof(buf), "%s()", name);
+	free_string(name);
+	return alloc_string(buf);
+}
+
+static char *get_toplevel_name(struct expression *expr)
+{
+	struct symbol *sym;
+	char buf[256];
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_SYMBOL || !expr->symbol || !expr->symbol->ident)
+		return NULL;
+
+	sym = expr->symbol;
+	if (!(sym->ctype.modifiers & MOD_TOPLEVEL))
+		return NULL;
+
+	if (sym->ctype.modifiers & MOD_STATIC)
+		snprintf(buf, sizeof(buf), "%s %s", get_base_file(), sym->ident->name);
+	else
+		snprintf(buf, sizeof(buf), "extern %s", sym->ident->name);
+
+	return alloc_string(buf);
+}
+
+char *get_constraint_str(struct expression *expr)
+{
+	char *name;
+
+	if (!expr)
+		return NULL;
+	if (expr->type == EXPR_CALL)
+		return get_func_constraint(expr);
+	if (expr->type == EXPR_BINOP)
+		return expr_to_str(expr);
+	name = get_toplevel_name(expr);
+	if (name)
+		return name;
+	return get_member_name(expr);
+}
+
+static int save_int_callback(void *_p, int argc, char **argv, char **azColName)
+{
+	int *p = _p;
+
+	*p = atoi(argv[0]);
+	return 0;
+}
+
+static int constraint_str_to_id(const char *str)
+{
+	int id = -1;
+
+	run_sql(save_int_callback, &id,
+		"select id from constraints where str = '%q'", str);
+
+	return id;
+}
+
+static int save_constraint_str(void *_str, int argc, char **argv, char **azColName)
+{
+	char **str = _str;
+
+	*str = alloc_string(argv[0]);
+	return 0;
+}
+
+static char *constraint_id_to_str(int id)
+{
+	char *str = NULL;
+
+	run_sql(save_constraint_str, &str,
+		"select str from constraints where id = '%d'", id);
+
+	return str;
+}
+
+static int save_op_callback(void *_p, int argc, char **argv, char **azColName)
+{
+	int *p = _p;
+
+	if (argv[0][0] == '<' && argv[0][1] == '=')
+		*p = SPECIAL_LTE;
+	else
+		*p = '<';
+	return 0;
+}
+
+static int save_str_callback(void *_p, int argc, char **argv, char **azColName)
+{
+	char **p = _p;
+
+	if (!*p) {
+		*p = alloc_string(argv[0]);
+	} else {
+		char buf[256];
+
+		snprintf(buf, sizeof(buf), "%s, %s", *p, argv[0]);
+		*p = alloc_string(buf);
+	}
+	return 0;
+}
+
+char *get_required_constraint(const char *data_str)
+{
+	char *required = NULL;
+
+	run_sql(save_str_callback, &required,
+		"select bound from constraints_required where data = '%q'", data_str);
+
+	return required;
+}
+
+static int get_required_op(char *data_str, char *con_str)
+{
+	int op = 0;
+
+	run_sql(save_op_callback, &op,
+		"select op from constraints_required where data = '%q' and bound = '%q'", data_str, con_str);
+
+	return op;
+}
+
+char *unmet_constraint(struct expression *data, struct expression *offset)
+{
+	struct smatch_state *state;
+	struct constraint_list *list;
+	struct constraint *con;
+	char *data_str;
+	char *required;
+	int req_op;
+
+	data_str = get_constraint_str(data);
+	if (!data_str)
+		return NULL;
+
+	required = get_required_constraint(data_str);
+	if (!required)
+		goto free_data;
+
+	state = get_state_expr(my_id, offset);
+	if (!state)
+		goto free_data;
+	list = state->data;
+
+	/* check the list of bounds on our index against the list that work */
+	FOR_EACH_PTR(list, con) {
+		char *con_str;
+
+		con_str = constraint_id_to_str(con->id);
+		if (!con_str) {
+			sm_msg("constraint %d not found", con->id);
+			continue;
+		}
+
+		req_op = get_required_op(data_str, con_str);
+		free_string(con_str);
+		if (!req_op)
+			continue;
+		if (con->op == '<' || con->op == req_op) {
+			free_string(required);
+			required = NULL;
+			goto free_data;
+		}
+	} END_FOR_EACH_PTR(con);
+
+free_data:
+	free_string(data_str);
+	return required;
+}
+
+struct string_list *saved_constraints;
+static void save_new_constraint(const char *con)
+{
+	if (list_has_string(saved_constraints, con))
+		return;
+	insert_string(&saved_constraints, con);
+	sql_save_constraint(con);
+}
+
+static void handle_comparison(struct expression *left, int op, struct expression *right)
+{
+	struct constraint_list *constraints;
+	struct smatch_state *state;
+	char *constraint;
+	int constraint_id;
+	int orig_op = op;
+	sval_t sval;
+
+	/* known values are handled in smatch extra */
+	if (get_value(left, &sval) || get_value(right, &sval))
+		return;
+
+	if (local_debug)
+		sm_msg("COMPARE: %s %s %s", expr_to_str(left), show_special(op), expr_to_str(right));
+
+	constraint = get_constraint_str(right);
+	if (!constraint)
+		return;
+	if (local_debug)
+		sm_msg("EXPR: %s CONSTRAINT %s", expr_to_str(right), constraint);
+	constraint_id = constraint_str_to_id(constraint);
+	if (local_debug)
+		sm_msg("CONSTRAINT ID %d", constraint_id);
+	if (constraint_id < 0)
+		save_new_constraint(constraint);
+	free_string(constraint);
+	if (constraint_id < 0)
+		return;
+
+	constraints = get_constraints(left);
+	constraints = clone_constraint_list(constraints);
+	op = negate_gt(orig_op);
+	add_constraint(&constraints, remove_unsigned_from_comparison(op), constraint_id);
+	state = alloc_constraint_state(constraints);
+
+	if (op == orig_op) {
+		if (local_debug)
+			sm_msg("SETTING %s true %s", expr_to_str(left), state->name);
+		set_true_false_states_expr(my_id, left,	state, NULL);
+	} else {
+		if (local_debug)
+			sm_msg("SETTING %s false %s", expr_to_str(left), state->name);
+
+		set_true_false_states_expr(my_id, left, NULL, state);
+	}
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (expr->type != EXPR_COMPARE)
+		return;
+
+	if (expr->op == SPECIAL_EQUAL ||
+	    expr->op == SPECIAL_NOTEQUAL)
+		return;
+
+	handle_comparison(expr->left, expr->op, expr->right);
+	handle_comparison(expr->right, flip_comparison(expr->op), expr->left);
+}
+
+struct constraint_list *get_constraints(struct expression *expr)
+{
+	struct smatch_state *state;
+
+	state = get_state_expr(my_id, expr);
+	if (!state)
+		return NULL;
+	return state->data;
+}
+
+static void match_caller_info(struct expression *expr)
+{
+	struct expression *tmp;
+	struct smatch_state *state;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, tmp) {
+		i++;
+		state = get_state_expr(my_id, tmp);
+		if (!state || state == &merged || state == &undefined)
+			continue;
+		sql_insert_caller_info(expr, CONSTRAINT, i, "$", state->name);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
+{
+	if (sm->state == &merged || sm->state == &undefined)
+		return;
+	sql_insert_caller_info(call, CONSTRAINT, param, printed_name, sm->state->name);
+}
+
+static struct smatch_state *constraint_str_to_state(char *value)
+{
+	struct constraint_list *list = NULL;
+	char *p = value;
+	int op;
+	long long id;
+
+	while (true) {
+		op = '<';
+		if (*p != '<')
+			return &undefined;
+		p++;
+		if (*p == '=') {
+			op = SPECIAL_LTE;
+			p++;
+		}
+		id = strtoll(p, &p, 10);
+		add_constraint(&list, op, id);
+		if (*p != ',')
+			break;
+		p++;
+		if (*p != ' ')
+			return &undefined;
+	}
+
+	return alloc_constraint_state(list);
+}
+
+static void set_param_constrained(const char *name, struct symbol *sym, char *key, char *value)
+{
+	char fullname[256];
+
+	if (strcmp(key, "*$") == 0)
+		snprintf(fullname, sizeof(fullname), "*%s", name);
+	else if (strncmp(key, "$", 1) == 0)
+		snprintf(fullname, 256, "%s%s", name, key + 1);
+	else
+		return;
+
+	set_state(my_id, name, sym, constraint_str_to_state(value));
+}
+
+static void print_return_implies_constrained(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct smatch_state *orig;
+	struct sm_state *sm;
+	const char *param_name;
+	int param;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (sm->state == &merged || sm->state == &undefined)
+			continue;
+
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+
+		orig = get_state_stree(get_start_states(), my_id, sm->name, sm->sym);
+		if (orig && strcmp(sm->state->name, orig->name) == 0)
+			continue;
+
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+
+		sql_insert_return_states(return_id, return_ranges, CONSTRAINT,
+					 param, param_name, sm->state->name);
+	} END_FOR_EACH_SM(sm);
+}
+
+static void db_returns_constrained(struct expression *expr, int param, char *key, char *value)
+{
+	char *name;
+	struct symbol *sym;
+
+	name = return_state_to_var_sym(expr, param, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	set_state(my_id, name, sym, constraint_str_to_state(value));
+free:
+	free_string(name);
+}
+
+void register_constraints(int id)
+{
+	my_id = id;
+
+	add_merge_hook(my_id, &merge_func);
+	add_hook(&match_condition, CONDITION_HOOK);
+
+	add_hook(&match_caller_info, FUNCTION_CALL_HOOK);
+	add_member_info_callback(my_id, struct_member_callback);
+	select_caller_info_hook(&set_param_constrained, CONSTRAINT);
+
+	add_split_return_callback(print_return_implies_constrained);
+	select_return_states_hook(CONSTRAINT, &db_returns_constrained);
+}
diff --git a/usr/src/tools/smatch/src/smatch_constraints_required.c b/usr/src/tools/smatch/src/smatch_constraints_required.c
new file mode 100644
index 0000000000..3708938586
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_constraints_required.c
@@ -0,0 +1,490 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+struct allocator {
+	const char *func;
+	int param;
+	int param2;
+};
+
+static struct allocator generic_allocator_table[] = {
+	{"malloc", 0},
+	{"memdup", 1},
+	{"realloc", 1},
+};
+
+static struct allocator kernel_allocator_table[] = {
+	{"kmalloc", 0},
+	{"kzalloc", 0},
+	{"vmalloc", 0},
+	{"__vmalloc", 0},
+	{"vzalloc", 0},
+	{"sock_kmalloc", 1},
+	{"kmemdup", 1},
+	{"kmemdup_user", 1},
+	{"dma_alloc_attrs", 1},
+	{"pci_alloc_consistent", 1},
+	{"pci_alloc_coherent", 1},
+	{"devm_kmalloc", 1},
+	{"devm_kzalloc", 1},
+	{"krealloc", 1},
+};
+
+static struct allocator calloc_table[] = {
+	{"calloc", 0, 1},
+	{"kcalloc", 0, 1},
+	{"kmalloc_array", 0, 1},
+	{"devm_kcalloc", 1, 2},
+};
+
+static int bytes_per_element(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+
+	if (type->type != SYM_PTR && type->type != SYM_ARRAY)
+		return 0;
+
+	type = get_base_type(type);
+	return type_bytes(type);
+}
+
+static void save_constraint_required(struct expression *pointer, int op, struct expression *constraint)
+{
+	char *data, *limit;
+
+	data = get_constraint_str(pointer);
+	if (!data)
+		return;
+
+	limit = get_constraint_str(constraint);
+	if (!limit) {
+		// FIXME deal with <= also
+		if (op == '<')
+			set_state_expr(my_id, constraint, alloc_state_expr(pointer));
+		goto free_data;
+	}
+
+	sql_save_constraint_required(data, op, limit);
+
+	free_string(limit);
+free_data:
+	free_string(data);
+}
+
+static int handle_zero_size_arrays(struct expression *pointer, struct expression *size)
+{
+	struct expression *left, *right;
+	struct symbol *type, *array, *array_type;
+	sval_t struct_size;
+	char *limit;
+	char data[128];
+
+	if (size->type != EXPR_BINOP || size->op != '+')
+		return 0;
+
+	type = get_type(pointer);
+	if (!type || type->type != SYM_PTR)
+		return 0;
+	type = get_real_base_type(type);
+	if (!type || !type->ident || type->type != SYM_STRUCT)
+		return 0;
+	if (!last_member_is_resizable(type))
+		return 0;
+	array = last_ptr_list((struct ptr_list *)type->symbol_list);
+	if (!array || !array->ident)
+		return 0;
+	array_type = get_real_base_type(array);
+	if (!array_type || array_type->type != SYM_ARRAY)
+		return 0;
+	array_type = get_real_base_type(array_type);
+
+	left = strip_expr(size->left);
+	right = strip_expr(size->right);
+
+	if (!get_implied_value(left, &struct_size))
+		return 0;
+	if (struct_size.value != type_bytes(type))
+		return 0;
+
+	if (right->type == EXPR_BINOP && right->op == '*') {
+		struct expression *mult_left, *mult_right;
+		sval_t sval;
+
+		mult_left = strip_expr(right->left);
+		mult_right = strip_expr(right->right);
+
+		if (get_implied_value(mult_left, &sval) &&
+		    sval.value == type_bytes(array_type))
+			size = mult_right;
+		else if (get_implied_value(mult_right, &sval) &&
+		    sval.value == type_bytes(array_type))
+			size = mult_left;
+		else
+			return 0;
+	}
+
+	snprintf(data, sizeof(data), "(struct %s)->%s", type->ident->name, array->ident->name);
+	limit = get_constraint_str(size);
+	if (!limit) {
+		set_state_expr(my_id, size, alloc_state_expr(
+			       member_expression(deref_expression(pointer), '*', array->ident)));
+		return 1;
+	}
+
+	sql_save_constraint_required(data, '<', limit);
+
+	free_string(limit);
+	return 1;
+}
+
+static void match_alloc_helper(struct expression *pointer, struct expression *size, int recurse)
+{
+	struct expression *size_orig, *tmp;
+	sval_t sval;
+	int cnt = 0;
+
+	pointer = strip_expr(pointer);
+	size = strip_expr(size);
+	if (!size || !pointer)
+		return;
+
+	size_orig = size;
+	if (recurse) {
+		while ((tmp = get_assigned_expr(size))) {
+			size = strip_expr(tmp);
+			if (cnt++ > 5)
+				break;
+		}
+		if (size != size_orig) {
+			match_alloc_helper(pointer, size, 0);
+			size = size_orig;
+		}
+	}
+
+	if (handle_zero_size_arrays(pointer, size))
+		return;
+
+	if (size->type == EXPR_BINOP && size->op == '*') {
+		struct expression *mult_left, *mult_right;
+
+		mult_left = strip_expr(size->left);
+		mult_right = strip_expr(size->right);
+
+		if (get_implied_value(mult_left, &sval) &&
+		    sval.value == bytes_per_element(pointer))
+			size = mult_right;
+		else if (get_implied_value(mult_right, &sval) &&
+		    sval.value == bytes_per_element(pointer))
+			size = mult_left;
+		else
+			return;
+	}
+
+	if (size->type == EXPR_BINOP && size->op == '+' &&
+	    get_implied_value(size->right, &sval) &&
+	    sval.value == 1)
+		save_constraint_required(pointer, SPECIAL_LTE, size->left);
+	else
+		save_constraint_required(pointer, '<', size);
+}
+
+static void match_alloc(const char *fn, struct expression *expr, void *_size_arg)
+{
+	int size_arg = PTR_INT(_size_arg);
+	struct expression *call, *arg;
+
+	call = strip_expr(expr->right);
+	arg = get_argument_from_call_expr(call->args, size_arg);
+
+	match_alloc_helper(expr->left, arg, 1);
+}
+
+static void match_calloc(const char *fn, struct expression *expr, void *_start_arg)
+{
+	struct expression *pointer, *call, *size;
+	struct expression *count = NULL;
+	int start_arg = PTR_INT(_start_arg);
+	sval_t sval;
+
+	pointer = strip_expr(expr->left);
+	call = strip_expr(expr->right);
+
+	size = get_argument_from_call_expr(call->args, start_arg);
+	if (get_implied_value(size, &sval) &&
+	    sval.value == bytes_per_element(pointer))
+		count = get_argument_from_call_expr(call->args, start_arg + 1);
+	else {
+		size = get_argument_from_call_expr(call->args, start_arg + 1);
+		if (get_implied_value(size, &sval) &&
+		    sval.value == bytes_per_element(pointer))
+			count = get_argument_from_call_expr(call->args, start_arg);
+	}
+
+	if (!count)
+		return;
+
+	save_constraint_required(pointer, '<', count);
+}
+
+static void add_allocation_function(const char *func, void *call_back, int param)
+{
+	add_function_assign_hook(func, call_back, INT_PTR(param));
+}
+
+static void match_assign_size(struct expression *expr)
+{
+	struct smatch_state *state;
+	char *data, *limit;
+
+	state = get_state_expr(my_id, expr->right);
+	if (!state || !state->data)
+		return;
+
+	data = get_constraint_str(state->data);
+	if (!data)
+		return;
+
+	limit = get_constraint_str(expr->left);
+	if (!limit)
+		goto free_data;
+
+	sql_save_constraint_required(data, '<', limit);
+
+	free_string(limit);
+free_data:
+	free_string(data);
+}
+
+static void match_assign_has_buf_comparison(struct expression *expr)
+{
+	struct expression *size;
+
+	if (expr->op != '=')
+		return;
+	if (expr->right->type == EXPR_CALL)
+		return;
+	size = get_size_variable(expr->right);
+	if (!size)
+		return;
+	match_alloc_helper(expr->left, size, 1);
+}
+
+static void match_assign_data(struct expression *expr)
+{
+	struct expression *right, *arg, *tmp;
+	int i;
+	int size_arg;
+	int size_arg2 = -1;
+
+	if (expr->op != '=')
+		return;
+
+	/* Direct calls are handled else where (for now at least) */
+	tmp = get_assigned_expr(expr->right);
+	if (!tmp)
+		return;
+
+	right = strip_expr(tmp);
+	if (right->type != EXPR_CALL)
+		return;
+
+	if (right->fn->type != EXPR_SYMBOL ||
+	    !right->fn->symbol ||
+	    !right->fn->symbol->ident)
+		return;
+
+	for (i = 0; i < ARRAY_SIZE(generic_allocator_table); i++) {
+		if (strcmp(right->fn->symbol->ident->name,
+			   generic_allocator_table[i].func) == 0) {
+			size_arg = generic_allocator_table[i].param;
+			goto found;
+		}
+	}
+
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	for (i = 0; i < ARRAY_SIZE(kernel_allocator_table); i++) {
+		if (strcmp(right->fn->symbol->ident->name,
+			   kernel_allocator_table[i].func) == 0) {
+			size_arg = kernel_allocator_table[i].param;
+			goto found;
+		}
+	}
+
+	for (i = 0; i < ARRAY_SIZE(calloc_table); i++) {
+		if (strcmp(right->fn->symbol->ident->name,
+			   calloc_table[i].func) == 0) {
+			size_arg = calloc_table[i].param;
+			size_arg2 = calloc_table[i].param2;
+			goto found;
+		}
+	}
+
+	return;
+
+found:
+	arg = get_argument_from_call_expr(right->args, size_arg);
+	match_alloc_helper(expr->left, arg, 1);
+	if (size_arg2 == -1)
+		return;
+	arg = get_argument_from_call_expr(right->args, size_arg2);
+	match_alloc_helper(expr->left, arg, 1);
+}
+
+static void match_assign_ARRAY_SIZE(struct expression *expr)
+{
+	struct expression *array;
+	char *data, *limit;
+	const char *macro;
+
+	macro = get_macro_name(expr->right->pos);
+	if (!macro || strcmp(macro, "ARRAY_SIZE") != 0)
+		return;
+	array = strip_expr(expr->right);
+	if (array->type != EXPR_BINOP || array->op != '+')
+		return;
+	array = strip_expr(array->left);
+	if (array->type != EXPR_BINOP || array->op != '/')
+		return;
+	array = strip_expr(array->left);
+	if (array->type != EXPR_SIZEOF)
+		return;
+	array = strip_expr(array->cast_expression);
+	if (array->type != EXPR_PREOP || array->op != '*')
+		return;
+	array = strip_expr(array->unop);
+
+	data = get_constraint_str(array);
+	limit = get_constraint_str(expr->left);
+	if (!data || !limit)
+		goto free;
+
+	sql_save_constraint_required(data, '<', limit);
+
+free:
+	free_string(data);
+	free_string(limit);
+}
+
+static void match_assign_buf_comparison(struct expression *expr)
+{
+	struct expression *pointer;
+
+	if (expr->op != '=')
+		return;
+	pointer = get_array_variable(expr->right);
+	if (!pointer)
+		return;
+
+	match_alloc_helper(pointer, expr->right, 1);
+}
+
+static int constraint_found(void *_found, int argc, char **argv, char **azColName)
+{
+	int *found = _found;
+
+	*found = 1;
+	return 0;
+}
+
+static int has_constraint(struct expression *expr, const char *constraint)
+{
+	int found = 0;
+
+	if (get_state_expr(my_id, expr))
+		return 1;
+
+	run_sql(constraint_found, &found,
+		"select data from constraints_required where bound = '%q' limit 1",
+		escape_newlines(constraint));
+
+	return found;
+}
+
+static void match_assign_constraint(struct expression *expr)
+{
+	struct symbol *type;
+	char *left, *right;
+
+	if (expr->op != '=')
+		return;
+
+	type = get_type(expr->left);
+	if (!type || type->type != SYM_BASETYPE)
+		return;
+
+	left = get_constraint_str(expr->left);
+	if (!left)
+		return;
+	right = get_constraint_str(expr->right);
+	if (!right)
+		goto free;
+	if (!has_constraint(expr->right, right))
+		return;
+	sql_copy_constraint_required(left, right);
+free:
+	free_string(right);
+	free_string(left);
+}
+
+void register_constraints_required(int id)
+{
+	my_id = id;
+
+	add_hook(&match_assign_size, ASSIGNMENT_HOOK);
+	add_hook(&match_assign_data, ASSIGNMENT_HOOK);
+	add_hook(&match_assign_has_buf_comparison, ASSIGNMENT_HOOK);
+
+	add_hook(&match_assign_ARRAY_SIZE, ASSIGNMENT_HOOK);
+	add_hook(&match_assign_ARRAY_SIZE, GLOBAL_ASSIGNMENT_HOOK);
+	add_hook(&match_assign_buf_comparison, ASSIGNMENT_HOOK);
+	add_hook(&match_assign_constraint, ASSIGNMENT_HOOK);
+
+	add_allocation_function("malloc", &match_alloc, 0);
+	add_allocation_function("memdup", &match_alloc, 1);
+	add_allocation_function("realloc", &match_alloc, 1);
+	add_allocation_function("realloc", &match_calloc, 0);
+	if (option_project == PROJ_KERNEL) {
+		add_allocation_function("kmalloc", &match_alloc, 0);
+		add_allocation_function("kzalloc", &match_alloc, 0);
+		add_allocation_function("vmalloc", &match_alloc, 0);
+		add_allocation_function("__vmalloc", &match_alloc, 0);
+		add_allocation_function("vzalloc", &match_alloc, 0);
+		add_allocation_function("sock_kmalloc", &match_alloc, 1);
+		add_allocation_function("kmemdup", &match_alloc, 1);
+		add_allocation_function("kmemdup_user", &match_alloc, 1);
+		add_allocation_function("dma_alloc_attrs", &match_alloc, 1);
+		add_allocation_function("pci_alloc_consistent", &match_alloc, 1);
+		add_allocation_function("pci_alloc_coherent", &match_alloc, 1);
+		add_allocation_function("devm_kmalloc", &match_alloc, 1);
+		add_allocation_function("devm_kzalloc", &match_alloc, 1);
+		add_allocation_function("kcalloc", &match_calloc, 0);
+		add_allocation_function("kmalloc_array", &match_calloc, 0);
+		add_allocation_function("devm_kcalloc", &match_calloc, 1);
+		add_allocation_function("krealloc", &match_alloc, 1);
+	}
+}
diff --git a/usr/src/tools/smatch/src/smatch_container_of.c b/usr/src/tools/smatch/src/smatch_container_of.c
new file mode 100644
index 0000000000..7399726917
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_container_of.c
@@ -0,0 +1,654 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+static int param_id;
+
+static struct stree *used_stree;
+static struct stree_stack *saved_stack;
+
+STATE(used);
+
+int get_param_from_container_of(struct expression *expr)
+{
+	struct expression *param_expr;
+	struct symbol *type;
+	sval_t sval;
+	int param;
+
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_PTR)
+		return -1;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_BINOP || expr->op != '-')
+		return -1;
+
+	if (!get_value(expr->right, &sval))
+		return -1;
+	if (sval.value < 0 || sval.value > 4096)
+		return -1;
+
+	param_expr = get_assigned_expr(expr->left);
+	if (!param_expr)
+		return -1;
+	param = get_param_num(param_expr);
+	if (param < 0)
+		return -1;
+
+	return param;
+}
+
+int get_offset_from_container_of(struct expression *expr)
+{
+	struct expression *param_expr;
+	struct symbol *type;
+	sval_t sval;
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_PTR)
+		return -1;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_BINOP || expr->op != '-')
+		return -1;
+
+	if (!get_value(expr->right, &sval))
+		return -1;
+	if (sval.value < 0 || sval.value > 4096)
+		return -1;
+
+	param_expr = get_assigned_expr(expr->left);
+	if (!param_expr)
+		return -1;
+
+	return sval.value;
+}
+
+static int get_container_arg(struct symbol *sym)
+{
+	struct expression *__mptr;
+	int param;
+
+	if (!sym || !sym->ident)
+		return -1;
+
+	__mptr = get_assigned_expr_name_sym(sym->ident->name, sym);
+	param = get_param_from_container_of(__mptr);
+
+	return param;
+}
+
+static int get_container_offset(struct symbol *sym)
+{
+	struct expression *__mptr;
+	int offset;
+
+	if (!sym || !sym->ident)
+		return -1;
+
+	__mptr = get_assigned_expr_name_sym(sym->ident->name, sym);
+	offset = get_offset_from_container_of(__mptr);
+
+	return offset;
+}
+
+static char *get_container_name(struct sm_state *sm, int offset)
+{
+	static char buf[256];
+	const char *name;
+
+	name = get_param_name(sm);
+	if (!name)
+		return NULL;
+
+	if (name[0] == '$')
+		snprintf(buf, sizeof(buf), "$(-%d)%s", offset, name + 1);
+	else if (name[0] == '*' || name[1] == '$')
+		snprintf(buf, sizeof(buf), "*$(-%d)%s", offset, name + 2);
+	else
+		return NULL;
+
+	return buf;
+}
+
+static void get_state_hook(int owner, const char *name, struct symbol *sym)
+{
+	int arg;
+
+	if (!option_info)
+		return;
+	if (__in_fake_assign)
+		return;
+
+	arg = get_container_arg(sym);
+	if (arg >= 0)
+		set_state_stree(&used_stree, my_id, name, sym, &used);
+}
+
+static void set_param_used(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	struct symbol *sym;
+	char *name;
+	int arg_nr;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	arg_nr = get_container_arg(sym);
+	if (arg_nr >= 0)
+		set_state(my_id, name, sym, &used);
+free:
+	free_string(name);
+}
+
+static void process_states(void)
+{
+	struct sm_state *tmp;
+	int arg, offset;
+	const char *name;
+
+	FOR_EACH_SM(used_stree, tmp) {
+		arg = get_container_arg(tmp->sym);
+		offset = get_container_offset(tmp->sym);
+		if (arg < 0 || offset < 0)
+			continue;
+		name = get_container_name(tmp, offset);
+		if (!name)
+			continue;
+		sql_insert_return_implies(CONTAINER, arg, name, "");
+	} END_FOR_EACH_SM(tmp);
+
+	free_stree(&used_stree);
+}
+
+static void match_function_def(struct symbol *sym)
+{
+	free_stree(&used_stree);
+}
+
+static void match_save_states(struct expression *expr)
+{
+	push_stree(&saved_stack, used_stree);
+	used_stree = NULL;
+}
+
+static void match_restore_states(struct expression *expr)
+{
+	free_stree(&used_stree);
+	used_stree = pop_stree(&saved_stack);
+}
+
+static void print_returns_container_of(int return_id, char *return_ranges, struct expression *expr)
+{
+	int offset;
+	int param;
+	char key[64];
+	char value[64];
+
+	param = get_param_from_container_of(expr);
+	if (param < 0)
+		return;
+	offset = get_offset_from_container_of(expr);
+	if (offset < 0)
+		return;
+
+	snprintf(key, sizeof(key), "%d", param);
+	snprintf(value, sizeof(value), "-%d", offset);
+
+	/* no need to add it to return_implies because it's not really param_used */
+	sql_insert_return_states(return_id, return_ranges, CONTAINER, -1,
+			key, value);
+}
+
+static void returns_container_of(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *call, *arg;
+	int offset;
+	char buf[64];
+
+	if (expr->type != EXPR_ASSIGNMENT || expr->op != '=')
+		return;
+	call = strip_expr(expr->right);
+	if (call->type != EXPR_CALL)
+		return;
+	if (param != -1)
+		return;
+	param = atoi(key);
+	offset = atoi(value);
+
+	arg = get_argument_from_call_expr(call->args, param);
+	if (!arg)
+		return;
+	if (arg->type != EXPR_SYMBOL)
+		return;
+	param = get_param_num(arg);
+	if (param < 0)
+		return;
+	snprintf(buf, sizeof(buf), "$(%d)", offset);
+	sql_insert_return_implies(CONTAINER, param, buf, "");
+}
+
+static int get_shared_cnt(const char *one, const char *two)
+{
+	int i;
+	int on_end = false;
+
+	i = 0;
+	while (true) {
+		if (!one[i] || !two[i]) {
+			on_end = true;
+			break;
+		}
+		if (one[i] != two[i])
+			break;
+		i++;
+	}
+	if (i == 0)
+		return 0;
+	i--;
+	while (i > 0 && (one[i] == '>' || one[i] == '-' || one[i] == '.')) {
+		on_end = true;
+		i--;
+	}
+	if (!on_end)
+		return 0;
+
+	return i + 1;
+}
+
+static int build_offset_str(struct expression *expr, const char *name,
+			    int shared, char *buf, int size, int op)
+{
+	int chop = 0;
+	int offset;
+	int i;
+
+	i = shared;
+	while (name[i]) {
+		if (name[i] == '.' || name[i] == '-')
+			chop++;
+		i++;
+	}
+
+	// FIXME:  Handle more chops
+	if (chop > 1)
+		return 0;
+
+	if (chop == 0) {
+		offset = 0;
+	} else {
+		offset = get_member_offset_from_deref(expr);
+		if (offset < 0)
+			return 0;
+	}
+
+	snprintf(buf, size, "%c%d", (op == '+') ? '+' : '-', offset);
+	return 1;
+}
+
+static void match_call(struct expression *call)
+{
+	struct expression *fn, *arg;
+	char *fn_name, *arg_name;
+	int param, shared;
+	char minus_str[64];
+	char plus_str[64];
+	char offset_str[64];
+	bool star;
+
+	/*
+	 * We're trying to link the function with the parameter.  There are a
+	 * couple ways this can be passed:
+	 * foo->func(foo, ...);
+	 * foo->func(foo->x, ...);
+	 * foo->bar.func(&foo->bar, ...);
+	 * foo->bar->baz->func(foo, ...);
+	 *
+	 * So the method is basically to subtract the offsets until we get to
+	 * the common bit, then add the member offsets to get the parameter.
+	 *
+	 * If we're taking an address then the offset math is not stared,
+	 * otherwise it is.  Starred means dereferenced.
+	 */
+	fn = strip_expr(call->fn);
+	fn_name = expr_to_var(fn);
+	if (!fn_name)
+		return;
+
+	param = -1;
+	FOR_EACH_PTR(call->args, arg) {
+		param++;
+
+		arg = strip_expr(arg);
+		star = true;
+		if (arg->type == EXPR_PREOP && arg->op == '&') {
+			arg = strip_expr(arg->unop);
+			star = false;
+		}
+
+		arg_name = expr_to_var(arg);
+		if (!arg_name)
+			continue;
+		shared = get_shared_cnt(fn_name, arg_name);
+		if (!shared)
+			goto free_arg_name;
+		if (!build_offset_str(fn, fn_name, shared, minus_str, sizeof(minus_str), '-'))
+			goto free_arg_name;
+		if (!build_offset_str(arg, arg_name, shared, plus_str, sizeof(plus_str), '+'))
+			goto free_arg_name;
+		if (star)
+			snprintf(offset_str, sizeof(offset_str), "*(%s%s)", minus_str, plus_str);
+		else
+			snprintf(offset_str, sizeof(offset_str), "%s%s", minus_str, plus_str);
+		sql_insert_caller_info(call, CONTAINER, param, offset_str, "$(-1)");
+free_arg_name:
+		free_string(arg_name);
+	} END_FOR_EACH_PTR(arg);
+
+	free_string(fn_name);
+}
+
+static void db_passed_container(const char *name, struct symbol *sym, char *key, char *value)
+{
+	sval_t offset = {
+		.type = &int_ctype,
+	};
+	const char *arg_offset;
+	int star = 0;
+	int val;
+
+	if (key[0] == '*') {
+		star = 1;
+		key += 2;
+	}
+
+	val = atoi(key);
+	if (val < -4095 || val > 0)
+		return;
+	offset.value = -val;
+	arg_offset = strchr(key, '+');
+	if (!arg_offset)
+		return;
+	val = atoi(arg_offset + 1);
+	if (val > 4095 || val < 0)
+		return;
+	offset.value |= val << 16;
+	if (star)
+		offset.value |= 1ULL << 31;
+
+	set_state(param_id, name, sym, alloc_estate_sval(offset));
+}
+
+struct db_info {
+	struct symbol *arg;
+	int prev_offset;
+	struct range_list *rl;
+	int star;
+	struct stree *stree;
+};
+
+static struct symbol *get_member_from_offset(struct symbol *sym, int offset)
+{
+	struct symbol *type, *tmp;
+	int cur;
+
+	type = get_real_base_type(sym);
+	if (!type || type->type != SYM_PTR)
+		return NULL;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_STRUCT)
+		return NULL;
+
+	cur = 0;
+	FOR_EACH_PTR(type->symbol_list, tmp) {
+		cur = ALIGN(cur, tmp->ctype.alignment);
+		if (offset == cur)
+			return tmp;
+		cur += type_bytes(tmp);
+	} END_FOR_EACH_PTR(tmp);
+	return NULL;
+}
+
+static struct symbol *get_member_type_from_offset(struct symbol *sym, int offset)
+{
+	struct symbol *base_type;
+	struct symbol *member;
+
+	base_type = get_real_base_type(sym);
+	if (base_type && base_type->type == SYM_PTR)
+		base_type = get_real_base_type(base_type);
+	if (offset == 0 && base_type && base_type->type == SYM_BASETYPE)
+		return base_type;
+
+	member = get_member_from_offset(sym, offset);
+	if (!member)
+		return NULL;
+	return get_real_base_type(member);
+}
+
+static const char *get_name_from_offset(struct symbol *arg, int offset)
+{
+	struct symbol *member, *type;
+	const char *name;
+	static char fullname[256];
+
+	name = arg->ident->name;
+
+	type = get_real_base_type(arg);
+	if (!type || type->type != SYM_PTR)
+		return name;
+
+	type = get_real_base_type(type);
+	if (!type)
+		return NULL;
+	if (type->type != SYM_STRUCT) {
+		snprintf(fullname, sizeof(fullname), "*%s", name);
+		return fullname;
+	}
+
+	member = get_member_from_offset(arg, offset);
+	if (!member)
+		return NULL;
+
+	snprintf(fullname, sizeof(fullname), "%s->%s", name, member->ident->name);
+	return fullname;
+}
+
+static void set_param_value(struct stree **stree, struct symbol *arg, int offset, struct range_list *rl)
+{
+	const char *name;
+
+	name = get_name_from_offset(arg, offset);
+	if (!name)
+		return;
+	set_state_stree(stree, SMATCH_EXTRA, name, arg, alloc_estate_rl(rl));
+}
+
+static int save_vals(void *_db_info, int argc, char **argv, char **azColName)
+{
+	struct db_info *db_info = _db_info;
+	struct symbol *type;
+	struct range_list *rl;
+	int offset = 0;
+	const char *value;
+
+	if (argc == 2) {
+		offset = atoi(argv[0]);
+		value = argv[1];
+	} else {
+		value = argv[0];
+	}
+
+	if (db_info->prev_offset != -1 &&
+	    db_info->prev_offset != offset) {
+		set_param_value(&db_info->stree, db_info->arg, db_info->prev_offset, db_info->rl);
+		db_info->rl = NULL;
+	}
+
+	db_info->prev_offset = offset;
+
+	type = get_real_base_type(db_info->arg);
+	if (db_info->star)
+		goto found_type;
+	if (type->type != SYM_PTR)
+		return 0;
+	type = get_real_base_type(type);
+	if (type->type == SYM_BASETYPE)
+		goto found_type;
+	type = get_member_type_from_offset(db_info->arg, offset);
+found_type:
+	str_to_rl(type, (char *)value, &rl);
+	if (db_info->rl)
+		db_info->rl = rl_union(db_info->rl, rl);
+	else
+		db_info->rl = rl;
+
+	return 0;
+}
+
+static struct stree *load_tag_info_sym(mtag_t tag, struct symbol *arg, int arg_offset, int star)
+{
+	struct db_info db_info = {
+		.arg = arg,
+		.prev_offset = -1,
+		.star = star,
+	};
+	struct symbol *type;
+
+	if (!tag || !arg->ident)
+		return NULL;
+
+	type = get_real_base_type(arg);
+	if (!type)
+		return NULL;
+	if (!star) {
+		if (type->type != SYM_PTR)
+			return NULL;
+		type = get_real_base_type(type);
+		if (!type)
+			return NULL;
+	}
+
+	if (star || type->type == SYM_BASETYPE) {
+		run_sql(save_vals, &db_info,
+			"select value from mtag_data where tag = %lld and offset = %d and type = %d;",
+			tag, arg_offset, DATA_VALUE);
+	} else {  /* presumably the parameter is a struct pointer */
+		run_sql(save_vals, &db_info,
+			"select offset, value from mtag_data where tag = %lld and type = %d;",
+			tag, DATA_VALUE);
+	}
+
+	if (db_info.prev_offset != -1)
+		set_param_value(&db_info.stree, arg, db_info.prev_offset, db_info.rl);
+
+	// FIXME: handle an offset correctly
+	if (!star && !arg_offset) {
+		sval_t sval;
+
+		sval.type = get_real_base_type(arg);
+		sval.uvalue = tag;
+		set_state_stree(&db_info.stree, SMATCH_EXTRA, arg->ident->name, arg, alloc_estate_sval(sval));
+	}
+	return db_info.stree;
+}
+
+static void handle_passed_container(struct symbol *sym)
+{
+	struct symbol *arg;
+	struct smatch_state *state;
+	struct sm_state *sm;
+	struct stree *stree;
+	mtag_t fn_tag, container_tag, arg_tag;
+	sval_t offset;
+	int container_offset, arg_offset;
+	int star;
+
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
+		state = get_state(param_id, arg->ident->name, arg);
+		if (state)
+			goto found;
+	} END_FOR_EACH_PTR(arg);
+
+	return;
+found:
+	if (!estate_get_single_value(state, &offset))
+		return;
+	container_offset = -(offset.value & 0xffff);
+	arg_offset = (offset.value & 0xfff0000) >> 16;
+	star = !!(offset.value & (1ULL << 31));
+
+	if (!get_toplevel_mtag(cur_func_sym, &fn_tag))
+		return;
+	if (!mtag_map_select_container(fn_tag, container_offset, &container_tag))
+		return;
+	if (!arg_offset || star) {
+		arg_tag = container_tag;
+	} else {
+		if (!mtag_map_select_tag(container_tag, -arg_offset, &arg_tag))
+			return;
+	}
+
+	stree = load_tag_info_sym(arg_tag, arg, arg_offset, star);
+	FOR_EACH_SM(stree, sm) {
+		set_state(sm->owner, sm->name, sm->sym, sm->state);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&stree);
+}
+
+void register_container_of(int id)
+{
+	my_id = id;
+
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+
+	add_get_state_hook(&get_state_hook);
+
+	add_hook(&match_save_states, INLINE_FN_START);
+	add_hook(&match_restore_states, INLINE_FN_END);
+
+	select_return_implies_hook(CONTAINER, &set_param_used);
+	all_return_states_hook(&process_states);
+
+	add_split_return_callback(&print_returns_container_of);
+	select_return_states_hook(CONTAINER, &returns_container_of);
+
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+}
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	return alloc_estate_whole(estate_type(sm->state));
+}
+
+void register_container_of2(int id)
+{
+	param_id = id;
+
+	select_caller_info_hook(db_passed_container, CONTAINER);
+	add_hook(&handle_passed_container, AFTER_DEF_HOOK);
+	add_unmatched_state_hook(param_id, &unmatched_state);
+	add_merge_hook(param_id, &merge_estates);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_data/db/build_early_index.sh b/usr/src/tools/smatch/src/smatch_data/db/build_early_index.sh
new file mode 100755
index 0000000000..bb1faaee0f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/build_early_index.sh
@@ -0,0 +1,48 @@
+#!/bin/bash
+
+db_file=$1
+
+
+cat << EOF | sqlite3 $db_file
+PRAGMA synchronous = OFF;
+PRAGMA cache_size = 800000;
+PRAGMA journal_mode = OFF;
+PRAGMA count_changes = OFF;
+PRAGMA temp_store = MEMORY;
+PRAGMA locking = EXCLUSIVE;
+
+CREATE INDEX caller_fn_idx on caller_info (function, call_id);
+CREATE INDEX caller_ff_idx on caller_info (file, function, call_id);
+CREATE INDEX common_fn_idx on common_caller_info (function, call_id);
+CREATE INDEX common_ff_idx on common_caller_info (file, function, call_id);
+CREATE INDEX call_implies_fn_idx on call_implies (function);
+CREATE INDEX call_implies_ff_idx on call_implies (file, function);
+CREATE INDEX return_implies_fn_idx on return_implies (function);
+CREATE INDEX return_implies_ff_idx on return_implies (file, function);
+CREATE INDEX data_file_info_idx on data_info (file, data);
+CREATE INDEX data_info_idx on data_info (data);
+CREATE INDEX fn_ptr_idx_file on function_ptr (file, function);
+CREATE INDEX fn_ptr_idx_nofile on function_ptr (function);
+CREATE INDEX fn_ptr_idx_ptr on function_ptr (ptr);
+CREATE INDEX file_function_type_idx on function_type (file, function);
+CREATE INDEX function_type_idx on function_type (function);
+CREATE INDEX function_type_size_idx ON function_type_size (type);
+CREATE INDEX function_type_value_idx ON function_type_value (type);
+CREATE INDEX local_value_idx on local_values (file, variable);
+CREATE INDEX return_states_fn_idx on return_states (function);
+CREATE INDEX return_states_ff_idx on return_states (file, function);
+CREATE INDEX parameter_name_file_idx on parameter_name (file, function);
+CREATE INDEX parameter_name_idx on parameter_name (function);
+CREATE INDEX str_idx on constraints (str);
+CREATE INDEX required_idx on constraints_required (data);
+CREATE INDEX mtag_about_idx on mtag_about (tag);
+CREATE INDEX mtag_data_idx on mtag_data (tag);
+CREATE INDEX mtag_map_idx1 on mtag_map (tag);
+CREATE INDEX mtag_map_idx2 on mtag_map (container);
+CREATE INDEX sink_index on sink_info (file, sink_name);
+
+EOF
+
+#CREATE INDEX type_size_idx on type_size (type);
+#CREATE INDEX type_val_idx on type_value (type);
+
diff --git a/usr/src/tools/smatch/src/smatch_data/db/build_late_index.sh b/usr/src/tools/smatch/src/smatch_data/db/build_late_index.sh
new file mode 100755
index 0000000000..32f637fd6c
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/build_late_index.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+db_file=$1
+
+
+cat << EOF | sqlite3 $db_file
+PRAGMA synchronous = OFF;
+PRAGMA cache_size = 800000;
+PRAGMA journal_mode = OFF;
+PRAGMA count_changes = OFF;
+PRAGMA temp_store = MEMORY;
+PRAGMA locking = EXCLUSIVE;
+
+CREATE INDEX type_size_idx on type_size (type);
+CREATE INDEX type_val_idx on type_value (type);
+
+EOF
+
+
diff --git a/usr/src/tools/smatch/src/smatch_data/db/call_implies.schema b/usr/src/tools/smatch/src/smatch_data/db/call_implies.schema
new file mode 100644
index 0000000000..6133061bf0
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/call_implies.schema
@@ -0,0 +1,12 @@
+CREATE TABLE call_implies (
+	file varchar(128),
+	function varchar(64),
+	call_id integer,
+	static boolean,
+	type integer,
+	parameter integer,
+	key varchar(256),
+	value varchar(256),
+
+	CONSTRAINT implies_row UNIQUE (file, function, call_id, static, type, parameter, key, value)
+);
diff --git a/usr/src/tools/smatch/src/smatch_data/db/caller_info.schema b/usr/src/tools/smatch/src/smatch_data/db/caller_info.schema
new file mode 100644
index 0000000000..31a029e8e6
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/caller_info.schema
@@ -0,0 +1 @@
+CREATE TABLE caller_info (file varchar(128), caller varchar(64), function varchar(64), call_id integer, static boolean, type integer, parameter integer, key varchar(256), value varchar(256));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/clear_user_data.sh b/usr/src/tools/smatch/src/smatch_data/db/clear_user_data.sh
new file mode 100755
index 0000000000..c0826ae67d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/clear_user_data.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+echo "delete from caller_info where type = 8017; delete from return_states where type = 8017;" | sqlite3 smatch_db.sqlite
+
+
diff --git a/usr/src/tools/smatch/src/smatch_data/db/common_caller_info.schema b/usr/src/tools/smatch/src/smatch_data/db/common_caller_info.schema
new file mode 100644
index 0000000000..9d344d021b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/common_caller_info.schema
@@ -0,0 +1 @@
+CREATE TABLE common_caller_info (file varchar(128), caller varchar(64), function varchar(64), call_id integer, static boolean, type integer, parameter integer, key varchar(256), value varchar(256));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/constraints.schema b/usr/src/tools/smatch/src/smatch_data/db/constraints.schema
new file mode 100644
index 0000000000..413aa95a41
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/constraints.schema
@@ -0,0 +1,6 @@
+CREATE TABLE constraints (
+	id integer primary key,
+	str varchar(256),
+
+	CONSTRAINT constraint_name UNIQUE (str)
+);
diff --git a/usr/src/tools/smatch/src/smatch_data/db/constraints_required.schema b/usr/src/tools/smatch/src/smatch_data/db/constraints_required.schema
new file mode 100644
index 0000000000..bf8bd07a20
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/constraints_required.schema
@@ -0,0 +1,7 @@
+CREATE TABLE constraints_required (
+	data varchar(256),
+	op integer,
+	bound varchar(256),
+
+	CONSTRAINT unique_row UNIQUE (data, op, bound)
+);
diff --git a/usr/src/tools/smatch/src/smatch_data/db/copy_required_constraints.pl b/usr/src/tools/smatch/src/smatch_data/db/copy_required_constraints.pl
new file mode 100755
index 0000000000..f32ee61a38
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/copy_required_constraints.pl
@@ -0,0 +1,46 @@
+#!/usr/bin/perl -w
+
+use strict;
+use warnings;
+use bigint;
+use DBI;
+use Data::Dumper;
+use File::Basename;
+use Try::Tiny;
+
+my $project = shift;
+$project =~ s/.*=(.*)/$1/;
+my $warns = shift;
+my $db_file = shift;
+
+my $db;
+
+sub connect_to_db($)
+{
+    my $name = shift;
+
+    $db = DBI->connect("dbi:SQLite:$name", "", "", {AutoCommit => 0});
+
+    $db->do("PRAGMA cache_size = 800000");
+    $db->do("PRAGMA journal_mode = OFF");
+    $db->do("PRAGMA count_changes = OFF");
+    $db->do("PRAGMA temp_store = MEMORY");
+    $db->do("PRAGMA locking = EXCLUSIVE");
+}
+
+sub copy_constraints($$)
+{
+    my $full_path = shift;
+    my $project = shift;
+    my $dir = dirname($full_path);
+
+    $db->do('insert or ignore into constraints (str) select bound from constraints_required');
+
+    $db->commit();
+}
+
+connect_to_db($db_file);
+copy_constraints($0, $project);
+
+$db->commit();
+$db->disconnect();
diff --git a/usr/src/tools/smatch/src/smatch_data/db/create_db.sh b/usr/src/tools/smatch/src/smatch_data/db/create_db.sh
new file mode 100755
index 0000000000..42c1524d15
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/create_db.sh
@@ -0,0 +1,58 @@
+#!/bin/bash
+
+if echo $1 | grep -q '^-p' ; then
+    PROJ=$(echo $1 | cut -d = -f 2)
+    shift
+fi
+
+info_file=$1
+
+if [[ "$info_file" = "" ]] ; then
+    echo "Usage:  $0 -p=<project> <file with smatch messages>"
+    exit 1
+fi
+
+bin_dir=$(dirname $0)
+db_file=smatch_db.sqlite.new
+
+rm -f $db_file
+
+for i in ${bin_dir}/*.schema ; do
+    cat $i | sqlite3 $db_file
+done
+
+${bin_dir}/init_constraints.pl "$PROJ" $info_file $db_file
+${bin_dir}/init_constraints_required.pl "$PROJ" $info_file $db_file
+${bin_dir}/fill_db_sql.pl "$PROJ" $info_file $db_file
+if [ -e ${info_file}.sql ] ; then
+    ${bin_dir}/fill_db_sql.pl "$PROJ" ${info_file}.sql $db_file
+fi
+${bin_dir}/fill_db_caller_info.pl "$PROJ" $info_file $db_file
+if [ -e ${info_file}.caller_info ] ; then
+    ${bin_dir}/fill_db_caller_info.pl "$PROJ" ${info_file}.caller_info $db_file
+fi
+${bin_dir}/build_early_index.sh $db_file
+
+${bin_dir}/fill_db_type_value.pl "$PROJ" $info_file $db_file
+${bin_dir}/fill_db_type_size.pl "$PROJ" $info_file $db_file
+${bin_dir}/copy_required_constraints.pl "$PROJ" $info_file $db_file
+${bin_dir}/build_late_index.sh $db_file
+
+${bin_dir}/fixup_all.sh $db_file
+if [ "$PROJ" != "" ] ; then
+    ${bin_dir}/fixup_${PROJ}.sh $db_file
+fi
+
+${bin_dir}/remove_mixed_up_pointer_params.pl $db_file
+${bin_dir}/mark_function_ptrs_searchable.pl $db_file
+
+# delete duplicate entrees and speed things up
+echo "delete from function_ptr where rowid not in (select min(rowid) from function_ptr group by file, function, ptr, searchable);" | sqlite3 $db_file
+
+test -e  ${bin_dir}/${PROJ}.return_fixes && \
+cat ${bin_dir}/${PROJ}.return_fixes | \
+while read func old new ; do
+    echo "update return_states set return = '$new' where function = '$func' and return = '$old';" | sqlite3 $db_file
+done
+
+mv $db_file smatch_db.sqlite
diff --git a/usr/src/tools/smatch/src/smatch_data/db/data_info.schema b/usr/src/tools/smatch/src/smatch_data/db/data_info.schema
new file mode 100644
index 0000000000..651a07c45d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/data_info.schema
@@ -0,0 +1 @@
+CREATE TABLE data_info (file varchar(80), data varchar(80), type integer, value varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/db.schema b/usr/src/tools/smatch/src/smatch_data/db/db.schema
new file mode 100644
index 0000000000..23118d152c
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/db.schema
@@ -0,0 +1 @@
+PRAGMA max_page_count = 2147483646;
diff --git a/usr/src/tools/smatch/src/smatch_data/db/fill_db_caller_info.pl b/usr/src/tools/smatch/src/smatch_data/db/fill_db_caller_info.pl
new file mode 100755
index 0000000000..a363d4ffde
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/fill_db_caller_info.pl
@@ -0,0 +1,96 @@
+#!/usr/bin/perl -w
+
+use strict;
+use DBI;
+use Scalar::Util qw(looks_like_number);
+
+sub usage()
+{
+    print "usage:  $0 <project> <smatch_warns.txt> <db_file>\n";
+    exit(1);
+}
+
+my %too_common_funcs;
+sub get_too_common_functions($$$)
+{
+    my $path = shift;
+    my $project = shift;
+    my $warns = shift;
+
+    open(FUNCS, "grep 'SQL_caller_info: ' $warns | grep '%call_marker%' | cut -d \"'\" -f 6 | sort | uniq -c | ");
+
+    while (<FUNCS>) {
+        if ($_ =~ /(\d+) (.*)/) {
+            if (int($1) > 200) {
+                $too_common_funcs{$2} = 1;
+            }
+        }
+    }
+
+    close(FUNCS);
+
+    open(FILE, ">", "$path/../$project.common_functions");
+    foreach my $func (keys %too_common_funcs) {
+        if ($func =~ / /) {
+            next;
+        }
+        print FILE "$func\n";
+    }
+    close(FILE);
+}
+
+my $exec_name = $0;
+my $path = $exec_name;
+$path =~ s/(.*)\/.*/$1/;
+my $project = shift;
+my $warns = shift;
+my $db_file = shift;
+
+if (!defined($db_file)) {
+    usage();
+}
+
+get_too_common_functions($path, $project, $warns);
+
+my $db = DBI->connect("dbi:SQLite:$db_file", "", "", {AutoCommit => 0});
+$db->do("PRAGMA cache_size = 800000");
+$db->do("PRAGMA journal_mode = OFF");
+$db->do("PRAGMA count_changes = OFF");
+$db->do("PRAGMA temp_store = MEMORY");
+$db->do("PRAGMA locking = EXCLUSIVE");
+
+foreach my $func (keys %too_common_funcs) {
+    $db->do("insert into common_caller_info values ('unknown', 'too common', '$func', 0, 0, 0, -1, '', '');");
+}
+
+my $call_id = 0;
+my ($fn, $dummy, $sql);
+
+open(WARNS, "<$warns");
+while (<WARNS>) {
+    # test.c:11 frob() SQL_caller_info: insert into caller_info values ('test.c', 'frob', '__smatch_buf_size', %CALL_ID%, 1, 0, -1, '', ');
+
+    if (!($_ =~ /^.*? \w+\(\) SQL_caller_info: /)) {
+        next;
+    }
+    ($dummy, $dummy, $dummy, $dummy, $dummy, $fn, $dummy) = split(/'/);
+
+    if ($fn =~ /__builtin_/) {
+        next;
+    }
+    if ($fn =~ /^(printk|memset|memcpy|kfree|printf|dev_err|writel)$/) {
+        next;
+    }
+
+    ($dummy, $dummy, $sql) = split(/:/, $_, 3);
+
+    if ($sql =~ /%call_marker%/) {
+        $sql =~ s/%call_marker%//; # don't need this taking space in the db.
+        $call_id++;
+    }
+    $sql =~ s/%CALL_ID%/$call_id/;
+
+    $db->do($sql);
+}
+$db->commit();
+$db->disconnect();
diff --git a/usr/src/tools/smatch/src/smatch_data/db/fill_db_sql.pl b/usr/src/tools/smatch/src/smatch_data/db/fill_db_sql.pl
new file mode 100755
index 0000000000..68a4c31613
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/fill_db_sql.pl
@@ -0,0 +1,49 @@
+#!/usr/bin/perl -w
+
+use strict;
+use DBI;
+
+my $project = shift;
+my $warns = shift;
+my $db_file = shift;
+
+if (!defined($warns)) {
+    print "usage:  $0 <-p=project> <smatch_warns.txt> <db_file>\n";
+    exit(1);
+}
+
+my $db = DBI->connect("dbi:SQLite:$db_file", "", "", {AutoCommit => 0});
+$db->do("PRAGMA cache_size = 800000");
+$db->do("PRAGMA journal_mode = OFF");
+$db->do("PRAGMA count_changes = OFF");
+$db->do("PRAGMA temp_store = MEMORY");
+$db->do("PRAGMA locking = EXCLUSIVE");
+
+my ($dummy, $sql);
+
+open(WARNS, "<$warns");
+while (<WARNS>) {
+
+    if (!($_ =~ /^.*? [^ ]*\(\) SQL: /)) {
+        next;
+    }
+    ($dummy, $dummy, $sql) = split(/:/, $_, 3);
+
+    $db->do($sql);
+}
+close(WARNS);
+
+open(WARNS, "<$warns");
+while (<WARNS>) {
+
+    if (!($_ =~ /^.*? [^ ]*\(\) SQL_late: /)) {
+        next;
+    }
+    ($dummy, $dummy, $sql) = split(/:/, $_, 3);
+
+    $db->do($sql);
+}
+close(WARNS);
+
+$db->commit();
+$db->disconnect();
diff --git a/usr/src/tools/smatch/src/smatch_data/db/fill_db_type_size.pl b/usr/src/tools/smatch/src/smatch_data/db/fill_db_type_size.pl
new file mode 100755
index 0000000000..812e05390e
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/fill_db_type_size.pl
@@ -0,0 +1,185 @@
+#!/usr/bin/perl -w
+
+use strict;
+use warnings;
+use bigint;
+use DBI;
+use Data::Dumper;
+
+my $project = shift;
+my $warns = shift;
+my $db_file = shift;
+my $db = DBI->connect("dbi:SQLite:$db_file", "", "", {AutoCommit => 0});
+
+my $raw_line;
+
+sub text_to_int($)
+{
+    my $text = shift;
+
+    if ($text =~ /s64min/) {
+        return -(2**63);
+    } elsif ($text =~/s32min/) {
+        return -(2**31);
+    } elsif ($text =~ /s16min/) {
+        return -(2**15);
+    } elsif ($text =~ /s64max/) {
+        return 2**63 - 1;
+    } elsif ($text =~ /s32max/) {
+        return 2**31 - 1;
+    } elsif ($text =~ /s16max/) {
+        return 2**15 - 1;
+    } elsif ($text =~ /u64max/) {
+        return 2**62 - 1;
+    } elsif ($text =~ /u32max/) {
+        return 2**32 - 1;
+    } elsif ($text =~ /u16max/) {
+        return 2**16 - 1;
+    }
+    if ($text =~ /\((.*?)\)/) {
+        $text = $1;
+    }
+    if (!($text =~ /^[-0123456789]/)) {
+        return "NaN";
+    }
+
+    return int($text);
+}
+
+sub add_range($$$)
+{
+    my $union = shift;
+    my $min = shift;
+    my $max = shift;
+    my %range;
+    my @return_union;
+    my $added = 0;
+    my $check_next = 0;
+
+    $range{min} = $min;
+    $range{max} = $max;
+
+    foreach my $tmp (@$union) {
+        if ($added) {
+            push @return_union, $tmp;
+            next;
+        }
+
+        if ($range{max} < $tmp->{min}) {
+            push @return_union, \%range;
+            push @return_union, $tmp;
+            $added = 1;
+        } elsif ($range{min} <= $tmp->{min}) {
+            if ($range{max} <= $tmp->{max}) {
+                $range{max} = $tmp->{max};
+                push @return_union, \%range;
+                $added = 1;
+            }
+        } elsif ($range{min} <= $tmp->{max}) {
+            if ($range{max} <= $tmp->{max}) {
+                push @return_union, $tmp;
+                $added = 1;
+            } else {
+                $range{min} = $tmp->{min};
+            }
+        } else {
+            push @return_union, $tmp;
+        }
+    }
+
+    if (!$added) {
+        push @return_union, \%range;
+    }
+
+    return \@return_union;
+}
+
+sub print_num($)
+{
+    my $num = shift;
+
+    if ($num < 0) {
+        return "(" . $num . ")";
+    } else {
+        return $num;
+    }
+}
+
+sub print_range($)
+{
+    my $range = shift;
+
+    if ($range->{min} == $range->{max}) {
+        return print_num($range->{min});
+    } else {
+        return print_num($range->{min}) . "-" .  print_num($range->{max});
+    }
+}
+
+sub print_info($$)
+{
+    my $type = shift;
+    my $union = shift;
+    my $printed_range = "";
+    my $i = 0;
+
+    foreach my $range (@$union) {
+        if ($i) {
+            $printed_range = $printed_range . ",";
+        }
+        $i++;
+        $printed_range = $printed_range . print_range($range);
+    }
+    my $sql = "insert into type_size values ('$type', '$printed_range');";
+    $db->do($sql);
+}
+
+
+$db->do("PRAGMA cache_size = 800000");
+$db->do("PRAGMA journal_mode = OFF");
+$db->do("PRAGMA count_changes = OFF");
+$db->do("PRAGMA temp_store = MEMORY");
+$db->do("PRAGMA locking = EXCLUSIVE");
+
+my ($sth, @row, $cur_type, $type, @ranges, $range_txt, %range, $min, $max, $union_array, $skip);
+
+$sth = $db->prepare('select * from function_type_size order by type');
+$sth->execute();
+
+$skip = 0;
+$cur_type = "";
+while (@row = $sth->fetchrow_array()) {
+    $raw_line = join ',', @row;
+
+    $type = $row[2];
+
+    if ($cur_type ne "$type") {
+        if ($cur_type ne "" && $skip == 0) {
+            print_info($cur_type, $union_array);
+        }
+        $cur_type = $type;
+        $union_array = ();
+        $skip = 0;
+    }
+
+    @ranges = split(/,/, $row[3]);
+    foreach $range_txt (@ranges) {
+        if ($range_txt =~ /(.*[^(])-(.*)/) {
+            $min = text_to_int($1);
+            $max = text_to_int($2);
+        } else {
+            $min = text_to_int($range_txt);
+            $max = $min;
+        }
+        if ($min =~ /NaN/ || $max =~ /NaN/) {
+            $skip = 1;
+        }
+        $union_array = add_range($union_array, $min, $max);
+    }
+}
+if ($skip == 0) {
+    print_info($cur_type, $union_array);
+}
+
+$db->commit();
+$db->disconnect();
diff --git a/usr/src/tools/smatch/src/smatch_data/db/fill_db_type_value.pl b/usr/src/tools/smatch/src/smatch_data/db/fill_db_type_value.pl
new file mode 100755
index 0000000000..24753de10a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/fill_db_type_value.pl
@@ -0,0 +1,195 @@
+#!/usr/bin/perl -w
+
+use strict;
+use warnings;
+use bigint;
+use DBI;
+use Data::Dumper;
+
+
+my $project = shift;
+my $warns = shift;
+my $db_file = shift;
+my $db = DBI->connect("dbi:SQLite:$db_file", "", "", {AutoCommit => 0});
+
+sub text_to_int($)
+{
+    my $text = shift;
+
+    if ($text =~ /s64min/) {
+        return -(2**63);
+    } elsif ($text =~/s32min/) {
+        return -(2**31);
+    } elsif ($text =~ /s16min/) {
+        return -(2**15);
+    } elsif ($text =~ /s64max/) {
+        return 2**63 - 1;
+    } elsif ($text =~ /s32max/) {
+        return 2**31 - 1;
+    } elsif ($text =~ /s16max/) {
+        return 2**15 - 1;
+    } elsif ($text =~ /u64max/) {
+        return 2**64 - 1;
+    } elsif ($text =~ /u32max/) {
+        return 2**32 - 1;
+    } elsif ($text =~ /u16max/) {
+        return 2**16 - 1;
+    }
+    if ($text =~ /\((.*?)\)/) {
+        $text = $1;
+    }
+    if (!($text =~ /^[-0123456789]/)) {
+        return "NaN";
+    }
+
+    return int($text);
+}
+
+sub add_range($$$)
+{
+    my $union = shift;
+    my $min = shift;
+    my $max = shift;
+    my %range;
+    my @return_union;
+    my $added = 0;
+    my $check_next = 0;
+
+    $range{min} = $min;
+    $range{max} = $max;
+
+    foreach my $tmp (@$union) {
+        if ($added) {
+            push @return_union, $tmp;
+            next;
+        }
+
+        if ($range{max} < $tmp->{min}) {
+            push @return_union, \%range;
+            push @return_union, $tmp;
+            $added = 1;
+        } elsif ($range{min} <= $tmp->{min}) {
+            if ($range{max} <= $tmp->{max}) {
+                $range{max} = $tmp->{max};
+                push @return_union, \%range;
+                $added = 1;
+            }
+        } elsif ($range{min} <= $tmp->{max}) {
+            if ($range{max} <= $tmp->{max}) {
+                push @return_union, $tmp;
+                $added = 1;
+            } else {
+                $range{min} = $tmp->{min};
+            }
+        } else {
+            push @return_union, $tmp;
+        }
+    }
+
+    if (!$added) {
+        push @return_union, \%range;
+    }
+
+    return \@return_union;
+}
+
+sub print_num($)
+{
+    my $num = shift;
+
+    if ($num < 0) {
+        return "(" . $num . ")";
+    } else {
+        return $num;
+    }
+}
+
+sub print_range($)
+{
+    my $range = shift;
+
+    if ($range->{min} == $range->{max}) {
+        return print_num($range->{min});
+    } else {
+        return print_num($range->{min}) . "-" .  print_num($range->{max});
+    }
+}
+
+sub print_info($$)
+{
+    my $type = shift;
+    my $union = shift;
+    my $printed_range = "";
+    my $i = 0;
+
+    if ($#$union > 100) {
+        print "$type " . scalar @$union . "\n";
+        return;
+    }
+
+    foreach my $range (@$union) {
+        if ($i) {
+            $printed_range = $printed_range . ",";
+        }
+        $i++;
+        $printed_range = $printed_range . print_range($range);
+    }
+    my $sql = "insert into type_value values ('$type', '$printed_range');";
+    $db->do($sql);
+}
+
+
+$db->do("PRAGMA cache_size = 800000");
+$db->do("PRAGMA journal_mode = OFF");
+$db->do("PRAGMA count_changes = OFF");
+$db->do("PRAGMA temp_store = MEMORY");
+$db->do("PRAGMA locking = EXCLUSIVE");
+
+my ($sth, @row, $cur_type, $type, @ranges, $range_txt, %range, $min, $max, $union_array, $skip);
+
+$sth = $db->prepare('select type, value from function_type_value order by type');
+$sth->execute();
+
+$skip = 0;
+$cur_type = "";
+while (@row = $sth->fetchrow_array()) {
+    $type = $row[0];
+
+    if ($cur_type ne "$type") {
+        if ($cur_type ne "" && $skip == 0) {
+            print_info($cur_type, $union_array);
+        }
+        $cur_type = $type;
+        $union_array = ();
+        $skip = 0;
+    }
+
+    if ($skip == 1) {
+        next;
+    }
+
+    @ranges = split(/,/, $row[1]);
+    foreach $range_txt (@ranges) {
+        if ($range_txt =~ /ignore/) {
+            next;
+        }
+        if ($range_txt =~ /(.*[^(])-(.*)/) {
+            $min = text_to_int($1);
+            $max = text_to_int($2);
+        } else {
+            $min = text_to_int($range_txt);
+            $max = $min;
+        }
+        if ($min =~ /NaN/ || $max =~ /NaN/) {
+            $skip = 1;
+            last;
+        }
+        $union_array = add_range($union_array, $min, $max);
+    }
+}
+if ($skip == 0) {
+    print_info($cur_type, $union_array);
+}
+
+$db->commit();
+$db->disconnect();
diff --git a/usr/src/tools/smatch/src/smatch_data/db/fixup_all.sh b/usr/src/tools/smatch/src/smatch_data/db/fixup_all.sh
new file mode 100755
index 0000000000..5a3032ed78
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/fixup_all.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+db_file=$1
+cat << EOF | sqlite3 $db_file
+
+delete from return_states where function = 'strlen';
+delete from return_states where function = 'strnlen';
+delete from return_states where function = 'sprintf';
+delete from return_states where function = 'snprintf';
+
+EOF
+
diff --git a/usr/src/tools/smatch/src/smatch_data/db/fixup_kernel.sh b/usr/src/tools/smatch/src/smatch_data/db/fixup_kernel.sh
new file mode 100755
index 0000000000..0a323cf374
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/fixup_kernel.sh
@@ -0,0 +1,229 @@
+#!/bin/bash
+
+db_file=$1
+cat << EOF | sqlite3 $db_file
+/* we only care about the main ->read/write() functions. */
+delete from caller_info where function = '(struct file_operations)->read' and file != 'fs/read_write.c';
+delete from caller_info where function = '(struct file_operations)->write' and file != 'fs/read_write.c';
+delete from caller_info where function = '(struct file_operations)->read' and caller != '__vfs_read';
+delete from caller_info where function = '(struct file_operations)->write' and caller != '__vfs_write';
+delete from function_ptr where function = '(struct file_operations)->read';
+delete from function_ptr where function = '(struct file_operations)->write';
+delete from caller_info where function = '__vfs_write' and caller != 'vfs_write';
+delete from caller_info where function = '__vfs_read' and caller != 'vfs_read';
+delete from caller_info where function = '(struct file_operations)->write' and caller = 'do_loop_readv_writev';
+delete from caller_info where function = 'do_splice_from' and caller = 'direct_splice_actor';
+
+/* delete these function pointers which cause false positives */
+delete from caller_info where function = '(struct file_operations)->open' and type != 0;
+delete from caller_info where function = '(struct notifier_block)->notifier_call' and type != 0;
+delete from caller_info where function = '(struct mISDNchannel)->send' and type != 0;
+delete from caller_info where function = '(struct irq_router)->get' and type != 0;
+delete from caller_info where function = '(struct irq_router)->set' and type != 0;
+delete from caller_info where function = '(struct net_device_ops)->ndo_change_mtu' and caller = 'i40e_dbg_netdev_ops_write';
+delete from caller_info where function = '(struct timer_list)->function' and type != 0;
+
+/* type 1003 is USER_DATA */
+delete from caller_info where caller = 'hid_input_report' and type = 1003;
+delete from caller_info where caller = 'nes_process_iwarp_aeqe' and type = 1003;
+delete from caller_info where caller = 'oz_process_ep0_urb' and type = 1003;
+delete from caller_info where function = 'dev_hard_start_xmit' and key = '\$' and type = 1003;
+delete from caller_info where function like '%->ndo_start_xmit' and key = '\$' and type = 1003;
+delete from caller_info where caller = 'packet_rcv_fanout' and function = '(struct packet_type)->func' and parameter = 1 and type = 1003;
+delete from caller_info where caller = 'hptiop_probe' and type = 1003;
+delete from caller_info where caller = 'p9_fd_poll' and function = '(struct file_operations)->poll' and type = 1003;
+delete from caller_info where caller = 'proc_reg_poll' and function = 'proc_reg_poll ptr poll' and type = 1003;
+delete from caller_info where function = 'blkdev_ioctl' and type = 1003 and parameter = 0 and key = '\$';
+/* 9017 is USER_DATA3_SET */
+delete from return_states where function='vscnprintf' and type = 9017;
+delete from return_states where function='scnprintf' and type = 9017;
+delete from return_states where function='vsnprintf' and type = 9017;
+delete from return_states where function='snprintf' and type = 9017;
+delete from return_states where function='sprintf' and type = 9017;
+delete from return_states where function='vscnprintf' and type = 8017;
+delete from return_states where function='scnprintf' and type = 8017;
+delete from return_states where function='vsnprintf' and type = 8017;
+delete from return_states where function='snprintf' and type = 8017;
+delete from return_states where function='sprintf' and type = 8017;
+/* There is something setting skb->sk->sk_mark and friends to user_data and */
+/* because of recursion it gets passed to everything and is impossible to debug */
+delete from caller_info where function = '__dev_queue_xmit' and type = 8017;
+delete from caller_info where function = '__netdev_start_xmit' and type = 8017;
+/* comparison doesn't deal with chunks, I guess.  */
+delete from return_states where function='get_tty_driver' and type = 8017;
+delete from caller_info where caller = 'snd_ctl_elem_write' and function = '(struct snd_kcontrol)->put' and type = 8017;
+delete from caller_info where caller = 'snd_ctl_elem_read' and function = '(struct snd_kcontrol)->get' and type = 8017;
+delete from caller_info where function = 'nf_tables_newexpr' and type = 8017 and key = '\$->family';
+delete from caller_info where caller = 'fb_set_var' and function = '(struct fb_ops)->fb_set_par' and type = 8017 and parameter = 0;
+delete from return_states where function = 'tty_lookup_driver' and parameter = 2 and type = 8017;
+
+insert into caller_info values ('userspace', '', 'compat_sys_ioctl', 0, 0, 1003, 0, '\$', '1');
+insert into caller_info values ('userspace', '', 'compat_sys_ioctl', 0, 0, 1003, 1, '\$', '1');
+insert into caller_info values ('userspace', '', 'compat_sys_ioctl', 0, 0, 1003, 2, '\$', '1');
+
+delete from caller_info where function = '(struct timer_list)->function' and parameter = 0;
+
+/*
+ * rw_verify_area is a very central function for the kernel.  The 1000000000
+ * isn't accurate but I've picked it so that we can add "pos + count" without
+ * wrapping on 32 bits.
+ */
+delete from return_states where function = 'rw_verify_area';
+insert into return_states values ('faked', 'rw_verify_area', 0, 1, '0-1000000000[<=\$3]', 0, 0,   -1,      '', '');
+insert into return_states values ('faked', 'rw_verify_area', 0, 1, '0-1000000000[<=\$3]', 0, 104,  2, '*\$', '0-1000000000');
+insert into return_states values ('faked', 'rw_verify_area', 0, 1, '0-1000000000[<=\$3]', 0, 103, 3,  '\$', '0-1000000000');
+insert into return_states values ('faked', 'rw_verify_area', 0, 2, '(-4095)-(-1)',     0, 0,   -1,      '', '');
+
+delete from return_states where function = 'is_kernel_rodata';
+insert into return_states values ('faked', 'is_kernel_rodata', 0, 1, '1', 0, 0,   -1,  '', '');
+insert into return_states values ('faked', 'is_kernel_rodata', 0, 1, '1', 0, 103,  0,  '\$', '100000000-177777777');
+insert into return_states values ('faked', 'is_kernel_rodata', 0, 2, '0', 0, 0,   -1,  '', '');
+
+/*
+ * I am a bad person for doing this to __kmalloc() which is a very deep function
+ * and can easily be removed instead of to kmalloc().  But kmalloc() is an
+ * inline function so it ends up being recorded thousands of times in the
+ * database.  Doing this is easier.
+ *
+ */
+delete from return_states where function = '__kmalloc';
+insert into return_states values ('faked', '__kmalloc', 0, 1, '16', 0,    0,  -1, '', '');
+insert into return_states values ('faked', '__kmalloc', 0, 1, '16', 0, 103,   0, '\$', '0');
+insert into return_states values ('faked', '__kmalloc', 0, 2, '0,500000000-577777777', 0,    0, -1, '', '');
+insert into return_states values ('faked', '__kmalloc', 0, 2, '0,500000000-577777777', 0, 103,  0, '\$', '1-4000000');
+insert into return_states values ('faked', '__kmalloc', 0, 2, '0,500000000-577777777', 0, 1037,  -1, '', 400);
+insert into return_states values ('faked', '__kmalloc', 0, 3, '0', 0,    0,  -1, '', '');
+insert into return_states values ('faked', '__kmalloc', 0, 3, '0', 0,    103,  0, '\$', '4000000-long_max');
+
+/*
+ * Other kmalloc hacking.
+ */
+update return_states set return = '0,500000000-577777777' where function = 'kmalloc_slab' and return = 's64min-s64max';
+update return_states set return = '0,500000000-577777777' where function = 'slab_alloc_node' and return = 's64min-s64max';
+update return_states set return = '0,500000000-577777777' where function = 'kmalloc_large' and return != '0';
+update return_states set return = '0,500000000-577777777' where function = 'kmalloc_order_trace' and return != '0';
+
+delete from return_states where function = 'vmalloc';
+insert into return_states values ('faked', 'vmalloc', 0, 1, '0,600000000-677777777', 0,    0, -1, '', '');
+insert into return_states values ('faked', 'vmalloc', 0, 1, '0,600000000-677777777', 0, 103,  0, '\$', '1-128000000');
+insert into return_states values ('faked', 'vmalloc', 0, 2, '0', 0,    0,  -1, '', '');
+
+delete from return_states where function = 'ksize';
+insert into return_states values ('faked', 'ksize', 0, 1, '0', 0,    0, -1, '', '');
+insert into return_states values ('faked', 'ksize', 0, 1, '0', 0, 103,  0, '\$', '16');
+insert into return_states values ('faked', 'ksize', 0, 2, '1-4000000', 0,    0,  -1, '', '');
+
+/* store a bunch of capped functions */
+update return_states set return = '0-u32max[<=\$2]' where function = 'copy_to_user';
+update return_states set return = '0-u32max[<=\$2]' where function = '_copy_to_user';
+update return_states set return = '0-u32max[<=\$2]' where function = '__copy_to_user';
+update return_states set return = '0-u32max[<=\$2]' where function = 'copy_from_user';
+update return_states set return = '0-u32max[<=\$2]' where function = '_copy_from_user';
+update return_states set return = '0-u32max[<=\$2]' where function = '__copy_from_user';
+
+update return_states set return = '0-8' where function = '__arch_hweight8';
+update return_states set return = '0-16' where function = '__arch_hweight16';
+update return_states set return = '0-32' where function = '__arch_hweight32';
+update return_states set return = '0-64' where function = '__arch_hweight64';
+
+/*
+ * Preserve the value across byte swapping.  By the time we use it for math it
+ * will be byte swapped back to CPU endian.
+ */
+update return_states set return = '0-u64max[==\$0]' where function = '__fswab64';
+update return_states set return = '0-u32max[==\$0]' where function = '__fswab32';
+update return_states set return = '0-u16max[==\$0]' where function = '__fswab16';
+update return_states set return = '0-u64max[==\$0]' where function = '__builtin_bswap64';
+update return_states set return = '0-u32max[==\$0]' where function = '__builtin_bswap32';
+update return_states set return = '0-u16max[==\$0]' where function = '__builtin_bswap16';
+
+delete from return_states where function = 'bitmap_allocate_region' and return = '1';
+/* Just delete a lot of returns that everyone ignores */
+delete from return_states where file = 'drivers/pci/access.c' and (return >= 129 and return <= 137);
+
+update return_states set return = '(-4095)-s32max[<=\$1]' where function = 'get_user_pages' and return = 's32min-s32max';
+update return_states set return = '(-4095)-s64max[<=\$1]' where function = 'get_user_pages' and return = 's64min-s64max';
+
+/* Smatch can't parse wait_for_completion() */
+update return_states set return = '(-108),(-22),0' where function = '__spi_sync' and return = '(-115),(-108),(-22)';
+
+delete from caller_info where caller = '__kernel_write';
+
+/* We sometimes use pre-allocated 4097 byte buffers for performance critical code but pretend it is always PAGE_SIZE */
+update caller_info set value = 4096 where caller='kernfs_file_direct_read' and function='(struct kernfs_ops)->read' and type = 1002 and parameter = 1;
+/* let's pretend firewire doesn't exist */
+delete from caller_info where caller='init_fw_attribute_group' and function='(struct device_attribute)->show';
+/* and let's fake the next dev_attr_show() call entirely */
+delete from caller_info where caller='sysfs_kf_seq_show' and function='(struct sysfs_ops)->show';
+insert into caller_info values ('fake', 'sysfs_kf_seq_show', '(struct sysfs_ops)->show', 0, 0, 1001, 0, '\$', '4096-2117777777777777777');
+insert into caller_info values ('fake', 'sysfs_kf_seq_show', '(struct sysfs_ops)->show', 0, 0, 1002, 2, '\$', '4096');
+insert into caller_info values ('fake', 'sysfs_kf_seq_show', '(struct sysfs_ops)->show', 0, 0, 1001, 2, '\$', '4096-2117777777777777777');
+insert into caller_info values ('fake', 'sysfs_kf_seq_show', '(struct sysfs_ops)->show', 0, 0, 0,   -1, ''  , '');
+/* config fs confuses smatch a little */
+update caller_info set value = 4096 where caller='fill_read_buffer' and function='(struct configfs_item_operations)->show_attribute' and type = 1002 and parameter = 2;
+
+/* smatch sees the memset() but not the subsequent changes */
+update return_states set value = "" where function = 'gfs2_ea_find' and return = '0' and type = 101 and parameter = 3;
+
+delete from type_value where type = '(struct fd)->file';
+delete from type_value where type = '(struct fd)->flags';
+
+/* This is sometimes an enum or a u64 */
+delete from type_value where type = '(struct mc_cmd_header)->status';
+
+/* this is handled in check_kernel.c */
+delete from return_states where function = "__write_once_size";
+
+update return_states set value = "s32min-s32max[\$1]" where function = 'atomic_set' and parameter = 0 and type = 1025;
+
+/* handled in the check itself */
+delete from return_states where function = 'atomic_inc_return' and (type = 8023 or type = 8024);
+delete from return_states where function = 'atomic_add_return' and (type = 8023 or type = 8024);
+delete from return_states where function = 'atomic_sub_return' and (type = 8023 or type = 8024);
+delete from return_states where function = 'atomic_sub_and_test' and (type = 8023 or type = 8024);
+delete from return_states where function = 'atomic_dec_and_test' and (type = 8023 or type = 8024);
+delete from return_states where function = 'atomic_dec' and (type = 8023 or type = 8024);
+delete from return_states where function = 'atomic_inc' and (type = 8023 or type = 8024);
+delete from return_states where function = 'atomic_sub' and (type = 8023 or type = 8024);
+delete from return_states where function = 'refcount_add_not_zero' and (type = 8023 or type = 8024);
+delete from return_states where function = 'refcount_inc_not_zero' and (type = 8023 or type = 8024);
+delete from return_states where function = 'refcount_sub_and_test' and (type = 8023 or type = 8024);
+
+update return_states set return = '0-32,2147483648-2147483690' where function = '_parse_integer' and return = '0';
+update return_states set value = '0-u64max' where function = '_parse_integer' and type = 1025 and parameter = 2 and key = '*$';
+
+/* delete some function pointers which are sometimes byte units */
+delete from caller_info where function = '(struct i2c_algorithm)->master_xfer' and type = 1027;
+
+/* this if from READ_ONCE().  We can't know anything about the data.  */
+delete from type_info where key = '(union anonymous)->__val';
+
+EOF
+
+# fixme: this is totally broken
+call_id=$(echo "select distinct call_id from caller_info where function = '__kernel_write';" | sqlite3 $db_file)
+for id in $call_id ; do
+    echo "insert into caller_info values ('fake', '', '__kernel_write', $id, 0, 1003, 1, '*\$', '');" | sqlite3 $db_file
+done
+
+for i in $(echo "select distinct return from return_states where function = 'clear_user';" | sqlite3 $db_file ) ; do
+    echo "update return_states set return = \"$i[<=\$1]\" where return = \"$i\" and function = 'clear_user';" | sqlite3 $db_file
+done
+
+echo "select distinct file, function from function_ptr where ptr='(struct rtl_hal_ops)->set_hw_reg';" \
+        | sqlite3 $db_file | sed -e 's/|/ /' | while read file function ; do
+
+    drv=$(echo $file | perl -ne 's/.*\/rtlwifi\/(.*?)\/sw.c/$1/; print')
+    if [ $drv = "" ] ; then
+        continue
+    fi
+
+    echo "update caller_info
+          set function = '$drv (struct rtl_hal_ops)->set_hw_reg'
+          where function = '(struct rtl_hal_ops)->set_hw_reg' and file like 'drivers/net/wireless/rtlwifi/$drv/%';" \
+         | sqlite3 $db_file
+
+    echo "insert into function_ptr values ('$file', '$function', '$drv (struct rtl_hal_ops)->set_hw_reg', 1);" \
+         | sqlite3 $db_file
+done
+
diff --git a/usr/src/tools/smatch/src/smatch_data/db/fixup_smatch_generic.sh b/usr/src/tools/smatch/src/smatch_data/db/fixup_smatch_generic.sh
new file mode 100755
index 0000000000..e69de29bb2
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/fixup_smatch_generic.sh
diff --git a/usr/src/tools/smatch/src/smatch_data/db/fn_data_link.schema b/usr/src/tools/smatch/src/smatch_data/db/fn_data_link.schema
new file mode 100644
index 0000000000..ba7170a964
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/fn_data_link.schema
@@ -0,0 +1 @@
+CREATE TABLE fn_data_link (file varchar(128), function varchar(64), static boolean, type integer, parameter integer, key varchar(256), value varchar(256));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/fn_ptr_data_link.schema b/usr/src/tools/smatch/src/smatch_data/db/fn_ptr_data_link.schema
new file mode 100644
index 0000000000..19ce705f9e
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/fn_ptr_data_link.schema
@@ -0,0 +1 @@
+CREATE TABLE fn_ptr_data_link (fn_ptr varchar(80), data varchar(80), CONSTRAINT unique_row UNIQUE (fn_ptr, data));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/function_ptr.schema b/usr/src/tools/smatch/src/smatch_data/db/function_ptr.schema
new file mode 100644
index 0000000000..20227b24e9
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/function_ptr.schema
@@ -0,0 +1 @@
+CREATE TABLE function_ptr (file varchar(128), function varchar(64), ptr varchar(256), searchable integer);
diff --git a/usr/src/tools/smatch/src/smatch_data/db/function_type.schema b/usr/src/tools/smatch/src/smatch_data/db/function_type.schema
new file mode 100644
index 0000000000..0c10c61eda
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/function_type.schema
@@ -0,0 +1 @@
+CREATE TABLE function_type (file varchar(80), function varchar(80), static boolean, parameter integer, value varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/function_type_info.schema b/usr/src/tools/smatch/src/smatch_data/db/function_type_info.schema
new file mode 100644
index 0000000000..fe065847fe
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/function_type_info.schema
@@ -0,0 +1 @@
+CREATE TABLE function_type_info (file varchar(128), function varchar(80), type integer, struct varchar(80), member varchar(80), value varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/function_type_size.schema b/usr/src/tools/smatch/src/smatch_data/db/function_type_size.schema
new file mode 100644
index 0000000000..b9574fbb5d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/function_type_size.schema
@@ -0,0 +1 @@
+CREATE TABLE function_type_size (file varchar(128), function varchar(80), type varchar(80), size varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/function_type_value.schema b/usr/src/tools/smatch/src/smatch_data/db/function_type_value.schema
new file mode 100644
index 0000000000..079fa545c4
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/function_type_value.schema
@@ -0,0 +1 @@
+CREATE TABLE function_type_value (file varchar(128), function varchar(80), type varchar(80), value varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/init_constraints.pl b/usr/src/tools/smatch/src/smatch_data/db/init_constraints.pl
new file mode 100755
index 0000000000..d1db7d03a8
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/init_constraints.pl
@@ -0,0 +1,79 @@
+#!/usr/bin/perl -w
+
+use strict;
+use warnings;
+use bigint;
+use DBI;
+use Data::Dumper;
+use File::Basename;
+use Try::Tiny;
+
+my $project = shift;
+$project =~ s/.*=(.*)/$1/;
+my $warns = shift;
+my $db_file = shift;
+
+sub preserve_existing_constraints()
+{
+    if (! -e "smatch_db.sqlite") {
+        return;
+    }
+
+    my $db = DBI->connect("dbi:SQLite:$db_file", "", "",);
+    $db->do('attach "smatch_db.sqlite" as old_db');
+    $db->do('insert into constraints select * from old_db.constraints');
+    $db->disconnect();
+}
+
+my $db;
+
+sub connect_to_db($)
+{
+    my $name = shift;
+
+    $db = DBI->connect("dbi:SQLite:$name", "", "", {AutoCommit => 0});
+
+    $db->do("PRAGMA cache_size = 800000");
+    $db->do("PRAGMA journal_mode = OFF");
+    $db->do("PRAGMA count_changes = OFF");
+    $db->do("PRAGMA temp_store = MEMORY");
+    $db->do("PRAGMA locking = EXCLUSIVE");
+}
+
+sub load_manual_constraints($$)
+{
+    my $full_path = shift;
+    my $project = shift;
+    my $dir = dirname($full_path);
+
+    open(FILE, "$dir/$project.constraints");
+    while (<FILE>) {
+        s/\n//;
+        $db->do("insert or ignore into constraints (str) values ('$_')");
+    }
+    close(FILE);
+
+    open(FILE, "$dir/$project.constraints_required");
+    while (<FILE>) {
+        my $limit;
+        my $dummy;
+
+        ($dummy, $dummy, $limit) = split(/,/);
+        $limit =~ s/^ +//;
+        $limit =~ s/\n//;
+        try {
+            $db->do("insert or ignore into constraints (str) values ('$limit')");
+        } catch {}
+    }
+    close(FILE);
+
+    $db->commit();
+}
+
+preserve_existing_constraints();
+
+connect_to_db($db_file);
+load_manual_constraints($0, $project);
+
+$db->commit();
+$db->disconnect();
diff --git a/usr/src/tools/smatch/src/smatch_data/db/init_constraints_required.pl b/usr/src/tools/smatch/src/smatch_data/db/init_constraints_required.pl
new file mode 100755
index 0000000000..e7a4057544
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/init_constraints_required.pl
@@ -0,0 +1,54 @@
+#!/usr/bin/perl -w
+
+use strict;
+use warnings;
+use bigint;
+use DBI;
+use Data::Dumper;
+use File::Basename;
+
+my $project = shift;
+$project =~ s/.*=(.*)/$1/;
+my $warns = shift;
+my $db_file = shift;
+
+my $db;
+
+sub connect_to_db($)
+{
+    my $name = shift;
+
+    $db = DBI->connect("dbi:SQLite:$name", "", "", {AutoCommit => 0});
+
+    $db->do("PRAGMA cache_size = 800000");
+    $db->do("PRAGMA journal_mode = OFF");
+    $db->do("PRAGMA count_changes = OFF");
+    $db->do("PRAGMA temp_store = MEMORY");
+    $db->do("PRAGMA locking = EXCLUSIVE");
+}
+
+sub load_manual_constraints($$)
+{
+    my $full_path = shift;
+    my $project = shift;
+    my $dir = dirname($full_path);
+    my ($data, $op, $limit);
+
+    open(FILE, "$dir/$project.constraints_required");
+    while (<FILE>) {
+        ($data, $op, $limit) = split(/,/);
+        $op =~ s/ //g;
+        $limit =~ s/^ +//;
+        $limit =~ s/\n//;
+        $db->do("insert into constraints_required values (?, ?, ?);", undef, $data, $op, $limit);
+    }
+    close(FILE);
+
+    $db->commit();
+}
+
+connect_to_db($db_file);
+load_manual_constraints($0, $project);
+
+$db->commit();
+$db->disconnect();
diff --git a/usr/src/tools/smatch/src/smatch_data/db/kernel.constraints b/usr/src/tools/smatch/src/smatch_data/db/kernel.constraints
new file mode 100644
index 0000000000..3136b9e8f9
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/kernel.constraints
@@ -0,0 +1 @@
+trusted
diff --git a/usr/src/tools/smatch/src/smatch_data/db/kernel.constraints_required b/usr/src/tools/smatch/src/smatch_data/db/kernel.constraints_required
new file mode 100644
index 0000000000..3b79bd00bc
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/kernel.constraints_required
@@ -0,0 +1,4 @@
+(struct seq_oss_devinfo)->synths, <, (struct seq_oss_devinfo)->max_synthdev
+(struct hid_report)->field, <, (struct hid_report)->maxfield
+(struct pidff_device)->pid_id, <, (struct ff_device)->max_effects
+(struct usb_mixer_elem_info)->cache_val, <, (struct snd_ctl_elem_id)->index
diff --git a/usr/src/tools/smatch/src/smatch_data/db/kernel.return_fixes b/usr/src/tools/smatch/src/smatch_data/db/kernel.return_fixes
new file mode 100644
index 0000000000..03d2e00d05
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/kernel.return_fixes
@@ -0,0 +1,34 @@
+i2c_master_recv s32min-s32max 1-s32max[<=$2]
+i2c_master_recv s32min-0,2-s32max 1-s32max[<=$2]
+hid_hw_output_report s32min-s32max 1-s32max[<=$2]
+_regmap_read s32min-(-1),1-s32max (-4095)-(-1)
+regmap_bulk_read s32min-(-1),1-s32max (-4095)-(-1)
+scnprintf s32min-s32max 0-s32max[<$1]
+scnprintf s32min-(-2),0-2147483646[<$1] 0-s32max[<$1]
+scnprintf s32min-(-2),0-2147483646 0-s32max[<$1]
+scnprintf s32min-s32max[<=$1] 0-s32max[<$1]
+scnprintf 0-s32max 0-s32max[<$1]
+vscnprintf s32min-(-2),0-s32max[<$1] 0-s32max[<$1]
+down_interruptible s32min-s32max (-62),(-4)
+__sock_create s32min-(-1),1-s32max (-4095)-(-1)
+sock_create_kern s32min-(-1),1-s32max (-4095)-(-1)
+nilfs_cpfile_get_checkpoint_block s32min-(-18),(-16)-s32max (-4095)-(-18),(-16)-(-1)
+nilfs_cpfile_get_checkpoint_block s32min-(-18),(-16)-(-3),(-1),1-s32max (-4095)-(-18),(-16)-(-3),(-1)
+nilfs_mdt_insert_new_block s32min-(-23),(-21)-(-1),1-s32max (-4095)-(-23),(-21)-(-1)
+simple_write_to_buffer s64min-s64max 0-s32max[<=$1]
+atomic_read s32min-s32max s32min-s32max[==$0->counter]
+notifier_to_errno (-2147483646)-(-1) (-4095)-(-1)
+mc_status_to_error s32min-s32max (-4095)-0
+dma_fence_wait_timeout s64min-s64max (-4095)-s64max
+dma_fence_wait_timeout s32min-s32max (-4095)-s32max
+fls s32min-s32max 0-32
+fls64 s64min-s64max 0-64
+__bitmap_weight s32min-s32max 0-s32max[<=$1]
+__bitmap_weight 0-s32max 0-s32max[<=$1]
+__ffs 0-u64max 0-63
+__ffs 0-u32max 0-31
+__spi_sync (-524),(-115),(-108),(-22) (-4095)-0
+tpm_tis_spi_read_bytes s32min-s32max (-4095)-0
+__irq_domain_activate_irq s32min-s32max (-4095)-0
+get_user_pages_fast s32min-s32max 1-s32max[<$1]
+__nci_request s32min-s32max (-4095)-0
diff --git a/usr/src/tools/smatch/src/smatch_data/db/local_values.schema b/usr/src/tools/smatch/src/smatch_data/db/local_values.schema
new file mode 100644
index 0000000000..6c78efc58c
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/local_values.schema
@@ -0,0 +1 @@
+CREATE TABLE local_values (file varchar(128), variable varchar(64), value varchar(256));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/mark_function_ptrs_searchable.pl b/usr/src/tools/smatch/src/smatch_data/db/mark_function_ptrs_searchable.pl
new file mode 100755
index 0000000000..a35148febc
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/mark_function_ptrs_searchable.pl
@@ -0,0 +1,50 @@
+#!/usr/bin/perl -w
+
+use strict;
+use warnings;
+use bigint;
+use DBI;
+use Data::Dumper;
+
+my $db_file = shift;
+my $db = DBI->connect("dbi:SQLite:$db_file", "", "", {AutoCommit => 0});
+
+$db->do("PRAGMA cache_size = 800000");
+$db->do("PRAGMA journal_mode = OFF");
+$db->do("PRAGMA count_changes = OFF");
+$db->do("PRAGMA temp_store = MEMORY");
+$db->do("PRAGMA locking = EXCLUSIVE");
+
+my ($update, $sth, $fn_ptr, $ptr_to_ptr, $count);
+
+$update = $db->prepare_cached('UPDATE function_ptr set searchable = 1 where ptr = ?');
+$sth = $db->prepare('select distinct(ptr) from function_ptr;');
+$sth->execute();
+
+while ($fn_ptr = $sth->fetchrow_array()) {
+
+    # following a pointer to pointer chain is too complicated for now
+    $ptr_to_ptr = $db->selectrow_array("select function from function_ptr where ptr = '$fn_ptr' and function like '% %';");
+    if ($ptr_to_ptr) {
+        next;
+    }
+    $ptr_to_ptr = $db->selectrow_array("select function from function_ptr where ptr = '$fn_ptr' and function like '%[]';");
+    if ($ptr_to_ptr) {
+        next;
+    }
+
+    $count = $db->selectrow_array("select count(*) from return_states join function_ptr where return_states.function == function_ptr.function and ptr = '$fn_ptr';");
+    # if there are too many states then bail
+    if ($count > 1000) {
+        next;
+    }
+    # if there are no states at all then don't bother recording
+    if ($count == 0) {
+        next;
+    }
+
+    $update->execute($fn_ptr);
+}
+
+$db->commit();
+$db->disconnect();
diff --git a/usr/src/tools/smatch/src/smatch_data/db/mtag_about.schema b/usr/src/tools/smatch/src/smatch_data/db/mtag_about.schema
new file mode 100644
index 0000000000..775764fedf
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/mtag_about.schema
@@ -0,0 +1 @@
+CREATE TABLE mtag_about (tag big int, file varchar(80), function varchar(80), line integer, left_name varchar(80), right_name varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/mtag_alias.schema b/usr/src/tools/smatch/src/smatch_data/db/mtag_alias.schema
new file mode 100644
index 0000000000..e01a79fd9f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/mtag_alias.schema
@@ -0,0 +1 @@
+CREATE TABLE mtag_alias (orig big int, new big int);
diff --git a/usr/src/tools/smatch/src/smatch_data/db/mtag_data.schema b/usr/src/tools/smatch/src/smatch_data/db/mtag_data.schema
new file mode 100644
index 0000000000..2bb5b26553
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/mtag_data.schema
@@ -0,0 +1 @@
+CREATE TABLE mtag_data (tag big int, offset integer, type integer, value varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/mtag_map.schema b/usr/src/tools/smatch/src/smatch_data/db/mtag_map.schema
new file mode 100644
index 0000000000..3eb892d3ac
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/mtag_map.schema
@@ -0,0 +1 @@
+CREATE TABLE mtag_map (tag big int, offset integer, container big int);
diff --git a/usr/src/tools/smatch/src/smatch_data/db/param_map.schema b/usr/src/tools/smatch/src/smatch_data/db/param_map.schema
new file mode 100644
index 0000000000..8885313453
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/param_map.schema
@@ -0,0 +1 @@
+CREATE TABLE param_map (file varchar(256), to_from bool, fn_ptr varchar(80), parameter integer, source varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/parameter_name.schema b/usr/src/tools/smatch/src/smatch_data/db/parameter_name.schema
new file mode 100644
index 0000000000..14da987ed1
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/parameter_name.schema
@@ -0,0 +1 @@
+CREATE TABLE parameter_name (file varchar(80), function varchar(80), static boolean, parameter integer, value varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/reload_partial.sh b/usr/src/tools/smatch/src/smatch_data/db/reload_partial.sh
new file mode 100755
index 0000000000..67b966c12b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/reload_partial.sh
@@ -0,0 +1,47 @@
+#!/bin/bash
+
+if echo $1 | grep -q '^-p' ; then
+    PROJ=$(echo $1 | cut -d = -f 2)
+    shift
+fi
+
+info_file=$1
+
+if [[ "$info_file" = "" ]] ; then
+    echo "Usage:  $0 -p=<project> <file with smatch messages>"
+    exit 1
+fi
+
+bin_dir=$(dirname $0)
+db_file=smatch_db.sqlite
+
+files=$(grep "insert into caller_info" $info_file | cut -d : -f 1 | sort -u)
+for c_file in $files; do
+    echo "FILE $c_file"
+    echo "delete from caller_info where file = '$c_file';" | sqlite3 $db_file
+    echo "delete from return_states where file = '$c_file';" | sqlite3 $db_file
+    echo "delete from call_implies where file = '$c_file';" | sqlite3 $db_file
+    echo "delete from return_implies where file = '$c_file';" | sqlite3 $db_file
+done
+
+tmp_file=$(mktemp)
+
+grep "insert into caller_info" $info_file > $tmp_file
+${bin_dir}/fill_db_caller_info.pl "$PROJ" $tmp_file $db_file
+
+grep "insert into return_states" $info_file > $tmp_file
+${bin_dir}/fill_db_sql.pl "$PROJ" $tmp_file $db_file
+
+grep "into call_implies" $info_file > $tmp_file
+${bin_dir}/fill_db_sql.pl "$PROJ" $tmp_file $db_file
+
+grep "into return_implies" $info_file > $tmp_file
+${bin_dir}/fill_db_sql.pl "$PROJ" $tmp_file $db_file
+
+rm $tmp_file
+
+${bin_dir}/fixup_all.sh $db_file
+if [ "$PROJ" != "" ] ; then
+    ${bin_dir}/fixup_${PROJ}.sh $db_file
+fi
+
diff --git a/usr/src/tools/smatch/src/smatch_data/db/remove_mixed_up_pointer_params.pl b/usr/src/tools/smatch/src/smatch_data/db/remove_mixed_up_pointer_params.pl
new file mode 100755
index 0000000000..1e7a89ab0e
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/remove_mixed_up_pointer_params.pl
@@ -0,0 +1,50 @@
+#!/usr/bin/perl -w
+
+use strict;
+use warnings;
+use bigint;
+use DBI;
+use Data::Dumper;
+
+my $db_file = shift;
+my $db = DBI->connect("dbi:SQLite:$db_file", "", "", {AutoCommit => 0});
+
+$db->do("PRAGMA cache_size = 800000");
+$db->do("PRAGMA journal_mode = OFF");
+$db->do("PRAGMA count_changes = OFF");
+$db->do("PRAGMA temp_store = MEMORY");
+$db->do("PRAGMA locking = EXCLUSIVE");
+
+my ($select, $select_type, $remove, $file, $caller, $function, $param, $src_param, $value, $type);
+
+$remove = $db->prepare_cached('DELETE FROM caller_info WHERE file = ? AND caller = ? AND function = ? AND parameter = ? AND type != 1014');
+$select = $db->prepare('SELECT file, caller, function, parameter, value FROM caller_info WHERE function LIKE "% param %" AND type = 1014 AND value LIKE "p %"');
+$select_type = $db->prepare_cached('SELECT value from function_type WHERE file = ? AND function = ? AND parameter = ? limit 1');
+$select->execute();
+
+while (($file, $caller, $function, $param, $value) = $select->fetchrow_array()) {
+
+    if ($value =~ /p (.*)/) {
+        $src_param = $1;
+    } else {
+        print "error:  unexpected source parameter $value\n";
+        next;
+    }
+
+    $select_type->execute($file, $caller, $src_param);
+    $type = $select_type->fetchrow_array();
+    if (!$type) {
+        next;
+    }
+    #FIXME: Why is this extra fetch() needed???
+    $select_type->fetch();
+
+    if (!($type =~ /^void\*$/) && !($type =~ /^ulong$/)) {
+        next;
+    }
+
+    $remove->execute($file, $caller, $function, $param);
+}
+
+$db->commit();
+$db->disconnect();
diff --git a/usr/src/tools/smatch/src/smatch_data/db/return_implies.schema b/usr/src/tools/smatch/src/smatch_data/db/return_implies.schema
new file mode 100644
index 0000000000..065d0f6d9d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/return_implies.schema
@@ -0,0 +1,12 @@
+CREATE TABLE return_implies (
+	file varchar(128),
+	function varchar(64),
+	call_id integer,
+	static boolean,
+	type integer,
+	parameter integer,
+	key varchar(256),
+	value varchar(256),
+
+	CONSTRAINT implies_row UNIQUE (file, function, call_id, static, type, parameter, key, value)
+);
diff --git a/usr/src/tools/smatch/src/smatch_data/db/return_states.schema b/usr/src/tools/smatch/src/smatch_data/db/return_states.schema
new file mode 100644
index 0000000000..a222eac9b7
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/return_states.schema
@@ -0,0 +1 @@
+CREATE TABLE return_states (file varchar(128), function varchar(64), call_id integer, return_id integer, return varchar(256), static boolean, type integer, parameter integer, key varchar(256), value varchar(256));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/sink_info.schema b/usr/src/tools/smatch/src/smatch_data/db/sink_info.schema
new file mode 100644
index 0000000000..dc2a285a36
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/sink_info.schema
@@ -0,0 +1 @@
+CREATE TABLE sink_info (file varchar(128), static boolean, sink_name varchar(64), type integer, key varchar(256), value varchar(256));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/smdb.py b/usr/src/tools/smatch/src/smatch_data/db/smdb.py
new file mode 100755
index 0000000000..1dcad2e94e
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/smdb.py
@@ -0,0 +1,668 @@
+#!/usr/bin/python
+
+# Copyright (C) 2013 Oracle.
+#
+# Licensed under the Open Software License version 1.1
+
+import sqlite3
+import sys
+import re
+
+try:
+    con = sqlite3.connect('smatch_db.sqlite')
+except sqlite3.Error, e:
+    print "Error %s:" % e.args[0]
+    sys.exit(1)
+
+def usage():
+    print "%s" %(sys.argv[0])
+    print "<function> - how a function is called"
+    print "return_states <function> - what a function returns"
+    print "call_tree <function> - show the call tree"
+    print "where <struct_type> <member> - where a struct member is set"
+    print "type_size <struct_type> <member> - how a struct member is allocated"
+    print "data_info <struct_type> <member> - information about a given data type"
+    print "function_ptr <function> - which function pointers point to this"
+    print "trace_param <function> <param> - trace where a parameter came from"
+    print "locals <file> - print the local values in a file."
+    sys.exit(1)
+
+function_ptrs = []
+searched_ptrs = []
+def get_function_pointers_helper(func):
+    cur = con.cursor()
+    cur.execute("select distinct ptr from function_ptr where function = '%s';" %(func))
+    for row in cur:
+        ptr = row[0]
+        if ptr in function_ptrs:
+            continue
+        function_ptrs.append(ptr)
+        if not ptr in searched_ptrs:
+            searched_ptrs.append(ptr)
+            get_function_pointers_helper(ptr)
+
+def get_function_pointers(func):
+    global function_ptrs
+    global searched_ptrs
+    function_ptrs = [func]
+    searched_ptrs = [func]
+    get_function_pointers_helper(func)
+    return function_ptrs
+
+db_types = {   0: "INTERNAL",
+             101: "PARAM_CLEARED",
+             103: "PARAM_LIMIT",
+             104: "PARAM_FILTER",
+            1001: "PARAM_VALUE",
+            1002: "BUF_SIZE",
+            1003: "USER_DATA",
+            1004: "CAPPED_DATA",
+            1005: "RETURN_VALUE",
+            1006: "DEREFERENCE",
+            1007: "RANGE_CAP",
+            1008: "LOCK_HELD",
+            1009: "LOCK_RELEASED",
+            1010: "ABSOLUTE_LIMITS",
+            1012: "PARAM_ADD",
+            1013: "PARAM_FREED",
+            1014: "DATA_SOURCE",
+            1015: "FUZZY_MAX",
+            1016: "STR_LEN",
+            1017: "ARRAY_LEN",
+            1018: "CAPABLE",
+            1019: "NS_CAPABLE",
+            1022: "TYPE_LINK",
+            1023: "UNTRACKED_PARAM",
+            1024: "CULL_PATH",
+            1025: "PARAM_SET",
+            1026: "PARAM_USED",
+            1027: "BYTE_UNITS",
+            1028: "COMPARE_LIMIT",
+            1029: "PARAM_COMPARE",
+            8017: "USER_DATA2",
+            8018: "NO_OVERFLOW",
+            8019: "NO_OVERFLOW_SIMPLE",
+            8020: "LOCKED",
+            8021: "UNLOCKED",
+            8023: "ATOMIC_INC",
+            8024: "ATOMIC_DEC",
+};
+
+def add_range(rl, min_val, max_val):
+    check_next = 0
+    done = 0
+    ret = []
+    idx = 0
+
+    if len(rl) == 0:
+        return [[min_val, max_val]]
+
+    for idx in range(len(rl)):
+        cur_min = rl[idx][0]
+        cur_max = rl[idx][1]
+
+        # we already merged the new range but we might need to change later
+        # ranges if they over lap with more than one
+        if check_next:
+            # join with added range
+            if max_val + 1 == cur_min:
+                ret[len(ret) - 1][1] = cur_max
+                done = 1
+                break
+            # don't overlap
+            if max_val < cur_min:
+                ret.append([cur_min, cur_max])
+                done = 1
+                break
+            # partially overlap
+            if max_val < cur_max:
+                ret[len(ret) - 1][1] = cur_max
+                done = 1
+                break
+            # completely overlap
+            continue
+
+        # join 2 ranges into one
+        if max_val + 1 == cur_min:
+            ret.append([min_val, cur_max])
+            done = 1
+            break
+        # range is entirely below
+        if max_val < cur_min:
+            ret.append([min_val, max_val])
+            ret.append([cur_min, cur_max])
+            done = 1
+            break
+        # range is partially below
+        if min_val < cur_min:
+            if max_val <= cur_max:
+                ret.append([min_val, cur_max])
+                done = 1
+                break
+            else:
+                ret.append([min_val, max_val])
+                check_next = 1
+                continue
+        # range already included
+        if max_val <= cur_max:
+            ret.append([cur_min, cur_max])
+            done = 1
+            break;
+        # range partially above
+        if min_val <= cur_max:
+            ret.append([cur_min, max_val])
+            check_next = 1
+            continue
+        # join 2 ranges on the other side
+        if min_val - 1 == cur_max:
+            ret.append([cur_min, max_val])
+            check_next = 1
+            continue
+        # range is above
+        ret.append([cur_min, cur_max])
+
+    if idx + 1 < len(rl):          # we hit a break statement
+        ret = ret + rl[idx + 1:]
+    elif done:                     # we hit a break on the last iteration
+        pass
+    elif not check_next:           # it's past the end of the rl
+        ret.append([min_val, max_val])
+
+    return ret;
+
+def rl_union(rl1, rl2):
+    ret = []
+    for r in rl1:
+        ret = add_range(ret, r[0], r[1])
+    for r in rl2:
+        ret = add_range(ret, r[0], r[1])
+
+    if (rl1 or rl2) and not ret:
+        print "bug: merging %s + %s gives empty" %(rl1, rl2)
+
+    return ret
+
+def txt_to_val(txt):
+    if txt == "s64min":
+        return -(2**63)
+    elif txt == "s32min":
+        return -(2**31)
+    elif txt == "s16min":
+        return -(2**15)
+    elif txt == "s64max":
+        return 2**63 - 1
+    elif txt == "s32max":
+        return 2**31 - 1
+    elif txt == "s16max":
+        return 2**15 - 1
+    elif txt == "u64max":
+        return 2**64 - 1
+    elif txt == "u32max":
+        return 2**32 - 1
+    elif txt == "u16max":
+        return 2**16 - 1
+    else:
+        try:
+            return int(txt)
+        except ValueError:
+            return 0
+
+def val_to_txt(val):
+    if val == -(2**63):
+        return "s64min"
+    elif val == -(2**31):
+        return "s32min"
+    elif val == -(2**15):
+        return "s16min"
+    elif val == 2**63 - 1:
+        return "s64max"
+    elif val == 2**31 - 1:
+        return "s32max"
+    elif val == 2**15 - 1:
+        return "s16max"
+    elif val == 2**64 - 1:
+        return "u64max"
+    elif val == 2**32 - 1:
+        return "u32max"
+    elif val == 2**16 - 1:
+        return "u16max"
+    elif val < 0:
+        return "(%d)" %(val)
+    else:
+        return "%d" %(val)
+
+def get_next_str(txt):
+    val = ""
+    parsed = 0
+
+    if txt[0] == '(':
+        parsed += 1
+        for char in txt[1:]:
+            if char == ')':
+                break
+            parsed += 1
+        val = txt[1:parsed]
+        parsed += 1
+    elif txt[0] == 's' or txt[0] == 'u':
+        parsed += 6
+        val = txt[:parsed]
+    else:
+        if txt[0] == '-':
+            parsed += 1
+        for char in txt[parsed:]:
+            if char == '-':
+                break
+            parsed += 1
+        val = txt[:parsed]
+    return [parsed, val]
+
+def txt_to_rl(txt):
+    if len(txt) == 0:
+        return []
+
+    ret = []
+    pairs = txt.split(",")
+    for pair in pairs:
+        cnt, min_str = get_next_str(pair)
+        if cnt == len(pair):
+            max_str = min_str
+        else:
+            cnt, max_str = get_next_str(pair[cnt + 1:])
+        min_val = txt_to_val(min_str)
+        max_val = txt_to_val(max_str)
+        ret.append([min_val, max_val])
+
+#    Hm...  Smatch won't call INT_MAX s32max if the variable is unsigned.
+#    if txt != rl_to_txt(ret):
+#        print "bug: converting: text = %s rl = %s internal = %s" %(txt, rl_to_txt(ret), ret)
+
+    return ret
+
+def rl_to_txt(rl):
+    ret = ""
+    for idx in range(len(rl)):
+        cur_min = rl[idx][0]
+        cur_max = rl[idx][1]
+
+        if idx != 0:
+            ret += ","
+
+        if cur_min == cur_max:
+            ret += val_to_txt(cur_min)
+        else:
+            ret += val_to_txt(cur_min)
+            ret += "-"
+            ret += val_to_txt(cur_max)
+    return ret
+
+def type_to_str(type_int):
+
+    t = int(type_int)
+    if db_types.has_key(t):
+        return db_types[t]
+    return type_int
+
+def type_to_int(type_string):
+    for k in db_types.keys():
+        if db_types[k] == type_string:
+            return k
+    return -1
+
+def display_caller_info(printed, cur, param_names):
+    for txt in cur:
+        if not printed:
+            print "file | caller | function | type | parameter | key | value |"
+        printed = 1
+
+        parameter = int(txt[6])
+        key = txt[7]
+        if len(param_names) and parameter in param_names:
+            key = key.replace("$", param_names[parameter])
+
+        print "%20s | %20s | %20s |" %(txt[0], txt[1], txt[2]),
+        print " %10s |" %(type_to_str(txt[5])),
+        print " %d | %s | %s" %(parameter, key, txt[8])
+    return printed
+
+def get_caller_info(filename, ptrs, my_type):
+    cur = con.cursor()
+    param_names = get_param_names(filename, func)
+    printed = 0
+    type_filter = ""
+    if my_type != "":
+        type_filter = "and type = %d" %(type_to_int(my_type))
+    for ptr in ptrs:
+        cur.execute("select * from caller_info where function = '%s' %s;" %(ptr, type_filter))
+        printed = display_caller_info(printed, cur, param_names)
+
+def print_caller_info(filename, func, my_type = ""):
+    ptrs = get_function_pointers(func)
+    get_caller_info(filename, ptrs, my_type)
+
+def merge_values(param_names, vals, cur):
+    for txt in cur:
+        parameter = int(txt[0])
+        name = txt[1]
+        rl = txt_to_rl(txt[2])
+        if parameter in param_names:
+            name = name.replace("$", param_names[parameter])
+
+        if not parameter in vals:
+            vals[parameter] = {}
+
+        # the first item on the list is the number of rows.  it's incremented
+        # every time we call merge_values().
+        if name in vals[parameter]:
+            vals[parameter][name] = [vals[parameter][name][0] + 1, rl_union(vals[parameter][name][1], rl)]
+        else:
+            vals[parameter][name] = [1, rl]
+
+def get_param_names(filename, func):
+    cur = con.cursor()
+    param_names = {}
+    cur.execute("select parameter, value from parameter_name where file = '%s' and function = '%s';" %(filename, func))
+    for txt in cur:
+        parameter = int(txt[0])
+        name = txt[1]
+        param_names[parameter] = name
+    if len(param_names):
+        return param_names
+
+    cur.execute("select parameter, value from parameter_name where function = '%s';" %(func))
+    for txt in cur:
+        parameter = int(txt[0])
+        name = txt[1]
+        param_names[parameter] = name
+    return param_names
+
+def get_caller_count(ptrs):
+    cur = con.cursor()
+    count = 0
+    for ptr in ptrs:
+        cur.execute("select count(distinct(call_id)) from caller_info where function = '%s';" %(ptr))
+        for txt in cur:
+            count += int(txt[0])
+    return count
+
+def print_merged_caller_values(filename, func, ptrs, param_names, call_cnt):
+    cur = con.cursor()
+    vals = {}
+    for ptr in ptrs:
+        cur.execute("select parameter, key, value from caller_info where function = '%s' and type = %d;" %(ptr, type_to_int("PARAM_VALUE")))
+        merge_values(param_names, vals, cur);
+
+    for param in sorted(vals):
+        for name in sorted(vals[param]):
+            if vals[param][name][0] != call_cnt:
+                continue
+            print "%d %s -> %s" %(param, name, rl_to_txt(vals[param][name][1]))
+
+
+def print_unmerged_caller_values(filename, func, ptrs, param_names):
+    cur = con.cursor()
+    for ptr in ptrs:
+        prev = -1
+        cur.execute("select file, caller, call_id, parameter, key, value from caller_info where function = '%s' and type = %d;" %(ptr, type_to_int("PARAM_VALUE")))
+        for filename, caller, call_id, parameter, name, value in cur:
+            if prev != int(call_id):
+                prev = int(call_id)
+
+            parameter = int(parameter)
+            if parameter < len(param_names):
+                name = name.replace("$", param_names[parameter])
+            else:
+                name = name.replace("$", "$%d" %(parameter))
+
+            print "%s | %s | %s | %s" %(filename, caller, name, value)
+        print "=========================="
+
+def print_caller_values(filename, func, ptrs):
+    param_names = get_param_names(filename, func)
+    call_cnt = get_caller_count(ptrs)
+
+    print_merged_caller_values(filename, func, ptrs, param_names, call_cnt)
+    print "=========================="
+    print_unmerged_caller_values(filename, func, ptrs, param_names)
+
+def caller_info_values(filename, func):
+    ptrs = get_function_pointers(func)
+    print_caller_values(filename, func, ptrs)
+
+def print_return_states(func):
+    cur = con.cursor()
+    cur.execute("select * from return_states where function = '%s';" %(func))
+    count = 0
+    for txt in cur:
+        printed = 1
+        if count == 0:
+            print "file | function | return_id | return_value | type | param | key | value |"
+        count += 1
+        print "%s | %s | %2s | %13s" %(txt[0], txt[1], txt[3], txt[4]),
+        print "| %13s |" %(type_to_str(txt[6])),
+        print " %2d | %20s | %20s |" %(txt[7], txt[8], txt[9])
+
+def print_return_implies(func):
+    cur = con.cursor()
+    cur.execute("select * from return_implies where function = '%s';" %(func))
+    count = 0
+    for txt in cur:
+        if not count:
+            print "file | function | type | param | key | value |"
+        count += 1
+        print "%15s | %15s" %(txt[0], txt[1]),
+        print "| %15s" %(type_to_str(txt[4])),
+        print "| %3d | %s | %15s |" %(txt[5], txt[6], txt[7])
+
+def print_type_size(struct_type, member):
+    cur = con.cursor()
+    cur.execute("select * from type_size where type like '(struct %s)->%s';" %(struct_type, member))
+    print "type | size"
+    for txt in cur:
+        print "%-15s | %s" %(txt[0], txt[1])
+
+    cur.execute("select * from function_type_size where type like '(struct %s)->%s';" %(struct_type, member))
+    print "file | function | type | size"
+    for txt in cur:
+        print "%-15s | %-15s | %-15s | %s" %(txt[0], txt[1], txt[2], txt[3])
+
+def print_data_info(struct_type, member):
+    cur = con.cursor()
+    cur.execute("select * from data_info where data like '(struct %s)->%s';" %(struct_type, member))
+    print "file | data | type | value"
+    for txt in cur:
+        print "%-15s | %-15s | %-15s | %s" %(txt[0], txt[1], type_to_str(txt[2]), txt[3])
+
+def print_fn_ptrs(func):
+    ptrs = get_function_pointers(func)
+    if not ptrs:
+        return
+    print "%s = " %(func),
+    print(ptrs)
+
+def print_functions(member):
+    cur = con.cursor()
+    cur.execute("select * from function_ptr where ptr like '%%->%s';" %(member))
+    print "File | Pointer | Function | Static"
+    for txt in cur:
+        print "%-15s | %-15s | %-15s | %s" %(txt[0], txt[2], txt[1], txt[3])
+
+def get_callers(func):
+    ret = []
+    cur = con.cursor()
+    ptrs = get_function_pointers(func)
+    for ptr in ptrs:
+        cur.execute("select distinct caller from caller_info where function = '%s';" %(ptr))
+        for row in cur:
+            ret.append(row[0])
+    return ret
+
+printed_funcs = []
+def call_tree_helper(func, indent = 0):
+    global printed_funcs
+    if func in printed_funcs:
+        return
+    print "%s%s()" %(" " * indent, func)
+    if func == "too common":
+        return
+    if indent > 6:
+        return
+    printed_funcs.append(func)
+    callers = get_callers(func)
+    if len(callers) >= 20:
+        print "Over 20 callers for %s()" %(func)
+        return
+    for caller in callers:
+        call_tree_helper(caller, indent + 2)
+
+def print_call_tree(func):
+    global printed_funcs
+    printed_funcs = []
+    call_tree_helper(func)
+
+def function_type_value(struct_type, member):
+    cur = con.cursor()
+    cur.execute("select * from function_type_value where type like '(struct %s)->%s';" %(struct_type, member))
+    for txt in cur:
+        print "%-30s | %-30s | %s | %s" %(txt[0], txt[1], txt[2], txt[3])
+
+def trace_callers(func, param):
+    sources = []
+    prev_type = 0
+
+    cur = con.cursor()
+    ptrs = get_function_pointers(func)
+    for ptr in ptrs:
+        cur.execute("select type, caller, value from caller_info where function = '%s' and (type = 0 or type = 1014 or type = 1028) and (parameter = -1 or parameter = %d);" %(ptr, param))
+        for row in cur:
+            data_type = int(row[0])
+            if data_type == 1014:
+                sources.append((row[1], row[2]))
+            elif data_type == 1028:
+                sources.append(("%", row[2])) # hack...
+            elif data_type == 0 and prev_type == 0:
+                sources.append((row[1], ""))
+            prev_type = data_type
+    return sources
+
+def trace_param_helper(func, param, indent = 0):
+    global printed_funcs
+    if func in printed_funcs:
+        return
+    print "%s%s(param %d)" %(" " * indent, func, param)
+    if func == "too common":
+        return
+    if indent > 20:
+        return
+    printed_funcs.append(func)
+    sources = trace_callers(func, param)
+    for path in sources:
+
+        if len(path[1]) and path[1][0] == 'p' and path[1][1] == ' ':
+            p = int(path[1][2:])
+            trace_param_helper(path[0], p, indent + 2)
+        elif len(path[0]) and path[0][0] == '%':
+            print "  %s%s" %(" " * indent, path[1])
+        else:
+            print "* %s%s %s" %(" " * (indent - 1), path[0], path[1])
+
+def trace_param(func, param):
+    global printed_funcs
+    printed_funcs = []
+    print "tracing %s %d" %(func, param)
+    trace_param_helper(func, param)
+
+def print_locals(filename):
+    cur = con.cursor()
+    cur.execute("select file,data,value from data_info where file = '%s' and type = 8029 and value != 0;" %(filename))
+    for txt in cur:
+        print "%s | %s | %s" %(txt[0], txt[1], txt[2])
+
+def constraint(struct_type, member):
+    cur = con.cursor()
+    cur.execute("select * from constraints_required where data like '(struct %s)->%s' or bound like '(struct %s)->%s';" %(struct_type, member, struct_type, member))
+    for txt in cur:
+        print "%-30s | %-30s | %s | %s" %(txt[0], txt[1], txt[2], txt[3])
+
+if len(sys.argv) < 2:
+    usage()
+
+if len(sys.argv) == 2:
+    func = sys.argv[1]
+    print_caller_info("", func)
+elif sys.argv[1] == "call_info":
+    if len(sys.argv) != 4:
+        usage()
+    filename = sys.argv[2]
+    func = sys.argv[3]
+    caller_info_values(filename, func)
+    print_caller_info(filename, func)
+elif sys.argv[1] == "user_data":
+    func = sys.argv[2]
+    print_caller_info(filename, func, "USER_DATA")
+elif sys.argv[1] == "param_value":
+    func = sys.argv[2]
+    print_caller_info(filename, func, "PARAM_VALUE")
+elif sys.argv[1] == "function_ptr" or sys.argv[1] == "fn_ptr":
+    func = sys.argv[2]
+    print_fn_ptrs(func)
+elif sys.argv[1] == "return_states":
+    func = sys.argv[2]
+    print_return_states(func)
+    print "================================================"
+    print_return_implies(func)
+elif sys.argv[1] == "return_implies":
+    func = sys.argv[2]
+    print_return_implies(func)
+elif sys.argv[1] == "type_size" or sys.argv[1] == "buf_size":
+    struct_type = sys.argv[2]
+    member = sys.argv[3]
+    print_type_size(struct_type, member)
+elif sys.argv[1] == "data_info":
+    struct_type = sys.argv[2]
+    member = sys.argv[3]
+    print_data_info(struct_type, member)
+elif sys.argv[1] == "call_tree":
+    func = sys.argv[2]
+    print_call_tree(func)
+elif sys.argv[1] == "where":
+    if len(sys.argv) == 3:
+        struct_type = "%"
+        member = sys.argv[2]
+    elif len(sys.argv) == 4:
+        struct_type = sys.argv[2]
+        member = sys.argv[3]
+    function_type_value(struct_type, member)
+elif sys.argv[1] == "local":
+    filename = sys.argv[2]
+    variable = ""
+    if len(sys.argv) == 4:
+        variable = sys.argv[3]
+    local_values(filename, variable)
+elif sys.argv[1] == "functions":
+    member = sys.argv[2]
+    print_functions(member)
+elif sys.argv[1] == "trace_param":
+    if len(sys.argv) != 4:
+        usage()
+    func = sys.argv[2]
+    param = int(sys.argv[3])
+    trace_param(func, param)
+elif sys.argv[1] == "locals":
+    if len(sys.argv) != 3:
+        usage()
+    filename = sys.argv[2]
+    print_locals(filename);
+elif sys.argv[1] == "constraint":
+    if len(sys.argv) == 3:
+        struct_type = "%"
+        member = sys.argv[2]
+    elif len(sys.argv) == 4:
+        struct_type = sys.argv[2]
+        member = sys.argv[3]
+    constraint(struct_type, member)
+elif sys.argv[1] == "test":
+    filename = sys.argv[2]
+    func = sys.argv[3]
+    caller_info_values(filename, func)
+else:
+    usage()
diff --git a/usr/src/tools/smatch/src/smatch_data/db/type_info.schema b/usr/src/tools/smatch/src/smatch_data/db/type_info.schema
new file mode 100644
index 0000000000..cf07a6419e
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/type_info.schema
@@ -0,0 +1,9 @@
+CREATE TABLE type_info (
+	file varchar(80),
+	type integer,
+	key varchar(80),
+	value varchar(80),
+
+	CONSTRAINT type_info_constraint UNIQUE (type, key, value)
+);
+
diff --git a/usr/src/tools/smatch/src/smatch_data/db/type_size.schema b/usr/src/tools/smatch/src/smatch_data/db/type_size.schema
new file mode 100644
index 0000000000..b5d26ba04c
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/type_size.schema
@@ -0,0 +1 @@
+CREATE TABLE type_size (type varchar(80), size integer);
diff --git a/usr/src/tools/smatch/src/smatch_data/db/type_value.schema b/usr/src/tools/smatch/src/smatch_data/db/type_value.schema
new file mode 100644
index 0000000000..7902a13b37
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/type_value.schema
@@ -0,0 +1 @@
+CREATE TABLE type_value (type varchar(80), value varchar(80));
diff --git a/usr/src/tools/smatch/src/smatch_data/db/vim_smdb b/usr/src/tools/smatch/src/smatch_data/db/vim_smdb
new file mode 100755
index 0000000000..5760066110
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/db/vim_smdb
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Add these lines to your .vimrc file
+#
+# map <C-r> :! vim_smdb return_states <cword> <CR> :execute 'edit' system("cat ~/.smdb_tmp/cur") <CR>
+# map <C-c> :! vim_smdb <cword> <CR> :execute 'edit' system("cat ~/.smdb_tmp/cur") <CR>
+#
+# Now you can move your cursor over a function and hit CTRL-c to see how it's
+# called or CTRL-r to see what it returns.  Use the ":bd" command to get back to
+# your source.
+
+DIR="$HOME/.smdb_tmp"
+mkdir -p $DIR
+
+for i in $(seq 1 100) ; do
+	if [ ! -e $DIR/$i ] ; then
+		break
+	fi
+done
+
+if [ $i == 100 ] ; then
+	i=1
+fi
+
+next=$(($i + 1))
+
+rm -f $DIR/$next
+rm $DIR/.${i}.swp
+smdb $* > $DIR/$i
+
+echo "$DIR/$i" > $DIR/cur
+
diff --git a/usr/src/tools/smatch/src/smatch_data/illumos_kernel.no_return_funcs b/usr/src/tools/smatch/src/smatch_data/illumos_kernel.no_return_funcs
new file mode 100644
index 0000000000..e5e288851d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/illumos_kernel.no_return_funcs
@@ -0,0 +1,18 @@
+/*
+ * These functions don't return.  Unfortunately, sparse today doesn't correctly
+ * respect __NORETURN, so we have to explicitly list them here for now.
+ */
+__assert_fail
+__builtin_unreachable
+bop_panic
+efi_reset
+panic
+pc_reset
+prom_exit_to_mon
+prom_panic
+prom_reboot
+reset
+resume_from_zombie
+swtch_from_zombie
+thread_exit
+vpanic
diff --git a/usr/src/tools/smatch/src/smatch_data/illumos_kernel.skipped_functions b/usr/src/tools/smatch/src/smatch_data/illumos_kernel.skipped_functions
new file mode 100644
index 0000000000..452d7f5871
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/illumos_kernel.skipped_functions
@@ -0,0 +1,8 @@
+/* These are "too hairy" for smatch. */
+dtrace_disx86
+elf32exec
+elfexec
+iscsi_ioctl
+lm_idle_chk
+segvn_fault_vnodepages
+tcp_input_data
diff --git a/usr/src/tools/smatch/src/smatch_data/illumos_user.no_return_funcs b/usr/src/tools/smatch/src/smatch_data/illumos_user.no_return_funcs
new file mode 100644
index 0000000000..730326547b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/illumos_user.no_return_funcs
@@ -0,0 +1,21 @@
+/*
+ * These functions don't return.  Unfortunately, sparse today doesn't correctly
+ * respect __NORETURN, so we have to explicitly list them here for now.
+ */
+__assert_fail
+__builtin_unreachable
+abort
+ctfmerge_fatal
+err
+errx
+_exit
+exit
+_longjmp
+longjmp
+pthread_exit
+reparsed_door_call_error
+siglongjmp
+terminate
+thr_exit
+verr
+verrx
diff --git a/usr/src/tools/smatch/src/smatch_data/illumos_user.skipped_functions b/usr/src/tools/smatch/src/smatch_data/illumos_user.skipped_functions
new file mode 100644
index 0000000000..ce1c807d97
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/illumos_user.skipped_functions
@@ -0,0 +1,40 @@
+/*
+ * The below functions cause smatch to fail with "turning off implications after
+ * 60 seconds" or similar, generally because they're too large for it to handle.
+ *
+ * This will disable analysis altogether.
+ */
+
+/* libast */
+_ast_optget
+_ast_opthelp
+/* libcmd */
+b_uname
+/* libcurses */
+_updateln
+/* libdisasm */
+dtrace_disx86
+/* libld */
+ld32_sym_process
+ld64_sym_process
+update_osym
+/* libsqlite */
+sqliteVdbeExec
+/* cmd/acpi/iasl */
+AslCompilerparse
+/* cmd/fs.d/autofs */
+nfsmount
+/* cmd/pppd */
+lcp_nakci
+
+/* generated code */
+ipf_yyparse
+ipmon_yyparse
+ipnat_yyparse
+ippool_yyparse
+ndr__ndr_hdr
+yyerror
+yylex
+yylook
+yyparse
+yywinput
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs b/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs
new file mode 100644
index 0000000000..5e1c8dca60
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs
@@ -0,0 +1,1194 @@
+// list of functions that return a new allocation.
+// generated by `gen_allocation_list.sh`
+__a2mp_build
+aa_alloc_profile
+__aa_kvmalloc
+aarp_alloc
+ablkcipher_request_alloc
+acpi_alloc_ipmi_msg
+acpi_processor_alloc_pdc
+acquire_group
+add_device
+add_missing_dev
+add_vol
+adfs_read_map
+aer_alloc_rpc
+afs_alloc_flat_call
+afs_alloc_server
+afs_vlocation_alloc
+aggr_init
+agp_alloc_bridge
+agp_create_client
+agp_create_controller
+agp_create_memory
+agp_create_user_memory
+ahc_alloc
+ahc_alloc_tstate
+ahd_alloc
+ahd_alloc_tstate
+ai_attach
+alloc_ai
+alloc_apertures
+alloc_area
+alloc_async
+allocate_bitmap_node
+__allocate_fw_buf
+allocate_partitions
+allocate_request
+__alloc_atm_dev
+alloc_backref_edge
+alloc_backref_node
+alloc_buf
+alloc_buffer
+alloc_cell
+alloc_channel
+alloc_chunk
+alloc_cld_upcall
+alloc_client
+alloc_conn
+alloc_context
+alloc_cpu_rmap
+alloc_ctrl_packet
+alloc_data_packet
+alloc_dca_provider
+alloc_dev
+alloc_dev_data
+alloc_ep
+alloc_fdtable
+__alloc_filter
+alloc_flex_gd
+alloc_ftrace_hash
+alloc_fw_cache_entry
+alloc_group_attrs
+alloc_i7core_dev
+alloc_jh
+alloc_journal_list
+alloc_lvn
+alloc_mpc
+alloc_mr
+alloc_msg
+alloc_msi_entry
+alloc_multipath
+alloc_namespace
+alloc_net_device
+alloc_nilfs
+alloc_parallel
+_alloc_path_selector
+alloc_pcie_link_state
+alloc_pci_root_info
+alloc_pdev
+alloc_perf_context
+alloc_pgpath
+alloc_pg_vec
+alloc_pipe_info
+alloc_pl
+alloc_priority_group
+alloc_pvd
+alloc_rdma
+alloc_read_gpt_entries
+alloc_read_gpt_header
+alloc_reloc_control
+alloc_resource
+alloc_rootdomain
+alloc_rx_struct
+alloc_sbridge_dev
+alloc_sched_domains
+alloc_scq
+alloc_selector
+alloc_session
+alloc_smp_req
+alloc_sock_iocb
+alloc_super
+alloc_switch_ctx
+alloc_symbol_cache
+alloc_tree
+alloc_tx_struct
+alloc_ubifs_info
+alloc_uprobe
+alloc_urbs
+alloc_watch_adapter
+alloc_worker
+alloc_workqueue_attrs
+__alloc_workqueue_key
+amp_ctrl_add
+amp_mgr_create
+aoedev_by_aoeaddr
+ap_add_sta
+ap_auth_make_challenge
+append_internal
+array_zalloc
+ast_i2c_create
+ast_ttm_tt_create
+ata_port_alloc
+ath10k_ce_init_state
+ath10k_htt_attach
+ath6kl_htc_mbox_create
+ath6kl_htc_pipe_create
+ath6kl_usb_create
+ath6kl_wmi_init
+ath9k_htc_hw_alloc
+ath9k_init_wmi
+ath_gen_timer_alloc
+atif_add_device
+atom_parse
+audit_alloc_context
+audit_alloc_name
+audit_buffer_alloc
+audit_init_entry
+audit_krule_to_data
+autofs4_new_ino
+avmcard_dma_alloc
+ax25_create_cb
+b1_alloc_card
+b43_bus_dev_bcma_init
+b43_bus_dev_ssb_init
+b43_calibrate_lo_setting
+b43_generate_dyn_tssi2dbm_tab
+b43legacy_generate_probe_resp
+b43legacy_setup_dmaring
+b43legacy_setup_pioqueue
+b43_setup_dmaring
+b43_setup_pioqueue_rx
+b43_setup_pioqueue_tx
+batadv_dat_select_candidates
+batadv_hardif_add_interface
+batadv_hash_new
+batadv_neigh_node_new
+batadv_new_tt_req_node
+bch_alloc
+bch_cache_set_alloc
+bfad_fcxp_map_sg
+binder_get_thread
+binder_new_node
+bin_to_hex_dup
+bio_alloc_map_data
+bio_integrity_alloc
+bioset_create
+bl_alloc_extent
+__blk_queue_init_tags
+bnx2fc_alloc_work
+bnx2fc_cmd_mgr_alloc
+bnx2fc_hba_create
+bnx2x_vfop_add
+brcmf_sdbrcm_probe
+brcmf_usbdev_qinit
+brcms_c_ampdu_attach
+brcms_c_antsel_attach
+brcms_c_attach_malloc
+brcms_c_bsscfg_malloc
+brcms_c_channel_mgr_attach
+brcms_init_timer
+brd_alloc
+br_multicast_new_port_group
+bsd_alloc
+bsg_alloc_device
+btmrvl_add_card
+btrfs_alloc_block_rsv
+btrfs_alloc_delayed_item
+btrfs_alloc_root
+btrfsic_block_alloc
+btrfsic_block_link_alloc
+btrfsic_dev_state_alloc
+btrfsic_stack_frame_alloc
+build_htc_txctrl_packet
+build_path_from_dentry
+c4iw_uld_add
+cachefiles_cook_key
+caif_device_alloc
+call_usermodehelper_setup
+capiminor_alloc
+capincci_alloc
+carl9170_cmd_buf
+cas_page_alloc
+cciss_allocate_sg_chain_blocks
+cdebbuf_alloc
+cdev_alloc
+cdv_intel_crtc_mode_get
+ceph_buffer_new
+ceph_create_snap_context
+cfcnfg_create
+cffrml_create
+cfi_read_pri
+cfi_staa_setup
+cfusbl_create
+cfv_alloc_and_copy_to_shm
+cgroup_alloc_name
+channel_detector_create
+cifs_build_path_to_root
+cifs_lock_init
+cifs_new_fileinfo
+cifs_readdata_alloc
+cifs_strndup_from_utf16
+cifs_strndup_to_utf16
+cifs_writedata_alloc
+cirrus_ttm_tt_create
+class_compat_register
+clusterip_config_init
+cmtp_application_add
+cnic_alloc_dev
+cn_queue_alloc_callback_entry
+cn_queue_alloc_dev
+composite_default_mfr
+conn_create
+convert_chmap
+copy_tlv
+core_dev_init_initiator_node_lun_acl
+cpia2_init_camera_struct
+create_a
+create_bounce_buffer
+create_driver
+create_durable_buf
+create_event
+create_l2
+create_lease_buf
+create_new_subsystem
+create_osd
+create_port
+create_portdata0
+create_reconnect_durable_buf
+create_regulator
+create_rmpp_recv
+create_serial
+create_trace_option_files
+create_unique_id
+create_uts_ns
+create_wlan
+__crypto_alloc_tfm
+crypto_create_tfm
+cs46xx_dsp_spos_create
+cs5535_mfgpt_alloc_timer
+cs_alloc_spec
+csio_hw_alloc
+CsrWifiEventCsrUint16CsrUint8Des
+CsrWifiEventCsrUint16Des
+CsrWifiEventCsrUint32Des
+CsrWifiEventCsrUint8Des
+CsrWifiEventDes
+CsrWifiNmeApConfigSetReqDes
+CsrWifiNmeApStaRemoveReqDes
+CsrWifiNmeApStartCfmDes
+CsrWifiNmeApStartReqDes
+CsrWifiNmeApStationIndDes
+CsrWifiNmeApStopCfmDes
+CsrWifiNmeApStopIndDes
+CsrWifiNmeApWmmParamUpdateReqDes
+CsrWifiNmeApWpsRegisterCfmDes
+CsrWifiNmeApWpsRegisterReqDes
+CsrWifiRouterCtrlBlockAckDisableCfmDes
+CsrWifiRouterCtrlBlockAckDisableReqDes
+CsrWifiRouterCtrlBlockAckEnableCfmDes
+CsrWifiRouterCtrlBlockAckEnableReqDes
+CsrWifiRouterCtrlBlockAckErrorIndDes
+CsrWifiRouterCtrlCapabilitiesCfmDes
+CsrWifiRouterCtrlConfigurePowerModeReqDes
+CsrWifiRouterCtrlConnectedIndDes
+CsrWifiRouterCtrlHipIndDes
+CsrWifiRouterCtrlHipReqDes
+CsrWifiRouterCtrlM4ReadyToSendIndDes
+CsrWifiRouterCtrlM4TransmitReqDes
+CsrWifiRouterCtrlM4TransmittedIndDes
+CsrWifiRouterCtrlMediaStatusReqDes
+CsrWifiRouterCtrlMicFailureIndDes
+CsrWifiRouterCtrlModeSetCfmDes
+CsrWifiRouterCtrlModeSetReqDes
+CsrWifiRouterCtrlMulticastAddressIndDes
+CsrWifiRouterCtrlMulticastAddressResDes
+CsrWifiRouterCtrlPeerAddCfmDes
+CsrWifiRouterCtrlPeerAddReqDes
+CsrWifiRouterCtrlPeerDelCfmDes
+CsrWifiRouterCtrlPeerDelReqDes
+CsrWifiRouterCtrlPeerUpdateCfmDes
+CsrWifiRouterCtrlPeerUpdateReqDes
+CsrWifiRouterCtrlPortConfigureCfmDes
+CsrWifiRouterCtrlPortConfigureReqDes
+CsrWifiRouterCtrlQosControlReqDes
+CsrWifiRouterCtrlRawSdioDeinitialiseCfmDes
+CsrWifiRouterCtrlRawSdioInitialiseCfmDes
+CsrWifiRouterCtrlResumeResDes
+CsrWifiRouterCtrlStaInactiveIndDes
+CsrWifiRouterCtrlSuspendIndDes
+CsrWifiRouterCtrlSuspendResDes
+CsrWifiRouterCtrlTclasAddCfmDes
+CsrWifiRouterCtrlTclasAddReqDes
+CsrWifiRouterCtrlTclasDelCfmDes
+CsrWifiRouterCtrlTclasDelReqDes
+CsrWifiRouterCtrlTrafficClassificationReqDes
+CsrWifiRouterCtrlTrafficConfigReqDes
+CsrWifiRouterCtrlTrafficProtocolIndDes
+CsrWifiRouterCtrlTrafficSampleIndDes
+CsrWifiRouterCtrlUnexpectedFrameIndDes
+CsrWifiRouterCtrlWapiRxMicCheckIndDes
+CsrWifiRouterCtrlWapiRxPktReqDes
+CsrWifiRouterCtrlWapiUnicastTxEncryptIndDes
+CsrWifiRouterCtrlWapiUnicastTxPktReqDes
+CsrWifiRouterCtrlWifiOnCfmDes
+CsrWifiRouterCtrlWifiOnIndDes
+CsrWifiRouterCtrlWifiOnReqDes
+CsrWifiRouterCtrlWifiOnResDes
+CsrWifiRouterMaPacketCancelReqDes
+CsrWifiRouterMaPacketCfmDes
+CsrWifiRouterMaPacketIndDes
+CsrWifiRouterMaPacketReqDes
+CsrWifiRouterMaPacketResDes
+CsrWifiRouterMaPacketSubscribeCfmDes
+CsrWifiRouterMaPacketSubscribeReqDes
+CsrWifiRouterMaPacketUnsubscribeCfmDes
+CsrWifiSmeAdhocConfigGetCfmDes
+CsrWifiSmeAdhocConfigSetReqDes
+CsrWifiSmeAssociationCompleteIndDes
+CsrWifiSmeAssociationStartIndDes
+CsrWifiSmeBlacklistCfmDes
+CsrWifiSmeBlacklistReqDes
+CsrWifiSmeCalibrationDataGetCfmDes
+CsrWifiSmeCalibrationDataSetReqDes
+CsrWifiSmeCcxConfigGetCfmDes
+CsrWifiSmeCcxConfigSetCfmDes
+CsrWifiSmeCcxConfigSetReqDes
+CsrWifiSmeCloakedSsidsGetCfmDes
+CsrWifiSmeCloakedSsidsSetReqDes
+CsrWifiSmeCoexConfigGetCfmDes
+CsrWifiSmeCoexConfigSetReqDes
+CsrWifiSmeCoexInfoGetCfmDes
+CsrWifiSmeConnectCfmDes
+CsrWifiSmeConnectionConfigGetCfmDes
+CsrWifiSmeConnectionInfoGetCfmDes
+CsrWifiSmeConnectionQualityIndDes
+CsrWifiSmeConnectionStatsGetCfmDes
+CsrWifiSmeConnectReqDes
+CsrWifiSmeCoreDumpIndDes
+CsrWifiSmeDisconnectCfmDes
+CsrWifiSmeErrorIndDes
+CsrWifiSmeHostConfigGetCfmDes
+CsrWifiSmeHostConfigSetCfmDes
+CsrWifiSmeHostConfigSetReqDes
+CsrWifiSmeIbssStationIndDes
+CsrWifiSmeInfoIndDes
+CsrWifiSmeInterfaceCapabilityGetCfmDes
+CsrWifiSmeKeyCfmDes
+CsrWifiSmeKeyReqDes
+CsrWifiSmeLinkQualityGetCfmDes
+CsrWifiSmeMediaStatusIndDes
+CsrWifiSmeMibConfigGetCfmDes
+CsrWifiSmeMibConfigSetReqDes
+CsrWifiSmeMibGetCfmDes
+CsrWifiSmeMibGetNextCfmDes
+CsrWifiSmeMibGetNextReqDes
+CsrWifiSmeMibGetReqDes
+CsrWifiSmeMibSetReqDes
+CsrWifiSmeMicFailureIndDes
+CsrWifiSmeMulticastAddressCfmDes
+CsrWifiSmeMulticastAddressReqDes
+CsrWifiSmePacketFilterSetCfmDes
+CsrWifiSmePacketFilterSetReqDes
+CsrWifiSmePermanentMacAddressGetCfmDes
+CsrWifiSmePmkidCandidateListIndDes
+CsrWifiSmePmkidCfmDes
+CsrWifiSmePmkidReqDes
+CsrWifiSmePowerConfigGetCfmDes
+CsrWifiSmePowerConfigSetReqDes
+CsrWifiSmeRegulatoryDomainInfoGetCfmDes
+CsrWifiSmeRoamCompleteIndDes
+CsrWifiSmeRoamingConfigGetCfmDes
+CsrWifiSmeRoamingConfigSetCfmDes
+CsrWifiSmeRoamingConfigSetReqDes
+CsrWifiSmeRoamStartIndDes
+CsrWifiSmeScanConfigGetCfmDes
+CsrWifiSmeScanConfigSetReqDes
+CsrWifiSmeScanFullReqDes
+CsrWifiSmeScanResultIndDes
+CsrWifiSmeScanResultsGetCfmDes
+CsrWifiSmeSetReqDes
+CsrWifiSmeSmeCommonConfigGetCfmDes
+CsrWifiSmeSmeCommonConfigSetReqDes
+CsrWifiSmeSmeStaConfigGetCfmDes
+CsrWifiSmeSmeStaConfigSetCfmDes
+CsrWifiSmeSmeStaConfigSetReqDes
+CsrWifiSmeStationMacAddressGetCfmDes
+CsrWifiSmeTspecCfmDes
+CsrWifiSmeTspecIndDes
+CsrWifiSmeTspecReqDes
+CsrWifiSmeVersionsGetCfmDes
+CsrWifiSmeWifiFlightmodeReqDes
+CsrWifiSmeWifiOnIndDes
+CsrWifiSmeWifiOnReqDes
+CsrWifiSmeWpsConfigurationReqDes
+ct_timer_instance_new
+ct_timer_new
+cx88_core_create
+cxgb_alloc_mem
+cxgbi_alloc_big_mem
+cxgbi_device_register
+cxgbi_sock_create
+cyberpro_alloc_fb_info
+DAC960_DetectController
+datablob_format
+dca_allocate_domain
+dcookie_register
+ddp_make_gl
+decode_device
+decode_ds_addr
+dell_wmi_prepare_new_keymap
+device_alloc
+devinfo_seq_start
+_dev_list_add
+dev_seq_start
+dfs_pattern_detector_init
+dib8000_attach
+dlm_allocate_lvb
+dlm_alloc_ctxt
+dlm_alloc_pagevec
+dma_attach
+dm_alloc_md_mempools
+dma_ops_domain_alloc
+dma_pin_iovec_pages
+dm_bio_prison_create
+dm_deferred_set_create
+dm_dirty_log_create
+dm_tm_create_non_blocking_clone
+dn_dev_alloc_ifa
+dn_dev_create
+dn_new_zone
+do_get_edid
+drm_agp_init
+drm_do_get_edid
+drm_gem_object_alloc
+drm_master_create
+drm_mm_kmalloc
+drm_mode_create
+drm_pci_alloc
+drm_property_create
+drm_property_create_blob
+dsp_cmx_new_conf
+dst_cow_metrics_generic
+dwc2_hcd_qh_create
+dwc2_hcd_urb_alloc
+dwmac1000_setup
+dwmac100_setup
+eb_create
+edac_device_alloc_ctl_info
+edac_mc_alloc
+edac_pci_alloc_ctl_info
+efx_alloc_channel
+efx_copy_channel
+eg_cache_add_entry
+ehci_qh_alloc
+ext3_htree_create_dir_info
+ext4_htree_create_dir_info
+ext4_kvmalloc
+ext4_kvzalloc
+ext4_li_request_new
+ezusb_alloc_ctx
+__fa_get_part
+fb_create_modedb
+fb_do_probe_ddc_edid
+fc_exch_mgr_add
+fc_exch_mgr_alloc
+fcoe_ctlr_device_add
+fc_rport_create
+fd_setup_write_same_buf
+fib6_alloc_table
+fib_trie_table
+fifo_alloc
+fir16_create
+fl_create
+flex_array_alloc
+flexcop_device_kmalloc
+fnic_dev_register
+fq_codel_zalloc
+fscache_alloc_retrieval
+fs_path_alloc
+fusbh200_qh_alloc
+fuse_file_alloc
+fw_create_instance
+fwnet_pd_new
+fw_node_create
+gameport_allocate_port
+gcov_info_dup
+gcov_iter_new
+genprobe_ident_chips
+get_client
+getdqbuf
+get_id
+get_indirect_ea
+get_irq_table
+get_rndis_device
+get_rndis_request
+get_scq
+get_unbound_pool
+get_vm_block
+get_xol_area
+gf128mul_init_4k_bbe
+gf128mul_init_4k_lle
+gf128mul_init_64k_bbe
+gf128mul_init_64k_lle
+gfs2_alloc_sort_buffer
+gigaset_initdriver
+gntdev_alloc_map
+go7007_alloc
+groups_alloc
+gru_alloc_vma_data
+gsm_alloc_mux
+gsm_control_send
+gsm_data_alloc
+gsm_dlci_alloc
+gsmi_buf_alloc
+gss_alloc_context
+hashbin_new
+hashtab_create
+hci_alloc_dev
+hci_chan_create
+hci_conn_add
+hfs_btree_open
+hfsplus_btree_open
+hidinput_allocate
+hid_register_field
+__hostap_add_bss
+hotadd_new_pgdat
+hpfs_get_4sectors
+hpfs_load_bitmap_directory
+hpfs_load_code_page
+hpfs_map_4sectors
+hpi_alloc_control_cache
+hsi_alloc_controller
+hsi_alloc_msg
+hso_create_device
+hso_create_shared_int
+hugepage_new_subpool
+i2c_matroxfb_probe
+i2c_new_device
+i2o_exec_wait_alloc
+i915_error_object_create_sized
+i915_pages_create_for_stolen
+ibmasm_new_command
+ibm_slot_from_id
+ib_ucm_ctx_alloc
+ics5342_init
+idt77252_init_est
+iio_alloc_pollfunc
+iio_device_alloc
+iio_trigger_alloc
+il4965_sta_alloc_lq
+imon_init_intf0
+in_cache_add_entry
+inetdev_init
+inet_frag_alloc
+init_bch
+init_list_set
+init_sbd
+init_temp_data
+init_test_block_group
+input_allocate_device
+input_allocate_polled_device
+intel_crtc_mode_get
+intel_display_capture_error_state
+intel_overlay_capture_error_state
+ioat2_alloc_ring
+ioat_dma_alloc_descriptor
+iommu_domain_alloc
+ipack_bus_register
+ipath_create_mmap_info
+ipath_mcast_alloc
+ipath_mcast_qp_alloc
+ipath_user_sdma_queue_create
+ipc_alloc
+ipmi_alloc_recv_msg
+ipmi_alloc_smi_msg
+ipoib_cm_create_tx
+ipoib_mcast_alloc
+ipoib_mcast_iter_init
+ipoib_neigh_ctor
+ipoib_path_iter_init
+ipr_alloc_ucode_buffer
+ip_set_alloc
+ipv6_add_dev
+ip_vs_lblc_new
+ip_vs_lblcr_new
+ip_vs_sync_buff_create
+ip_vs_sync_buff_create_v0
+ipw_alloc_error_log
+ipwireless_hardware_create
+ipwireless_network_create
+ipw_rx_queue_alloc
+ipxitf_alloc
+ircomm_open
+irda_usb_find_class_desc
+iriap_open
+irias_new_integer_value
+irias_new_missing_value
+irias_new_object
+irias_new_octseq_value
+irias_new_string_value
+irlap_open
+irlmp_copy_discoveries
+irlmp_open_lsap
+irlmp_register_client
+irlmp_register_service
+irq_alloc_generic_chip
+irttp_open_tsap
+iscsi_alloc_session
+iscsi_boot_create_kobj
+iscsi_boot_create_kset
+iscsi_create_conn
+iscsi_create_endpoint
+iscsi_create_flashnode_conn
+iscsi_create_flashnode_sess
+iscsi_create_iface
+iscsi_login_init_conn
+iscsi_set_default_param
+iscsit_alloc_portal_group
+isdn_audio_adpcm_init
+isdn_audio_dtmf_init
+isdn_audio_silence_init
+isdn_ppp_ccp_reset_alloc
+isdn_ppp_ccp_reset_alloc_state
+isdn_v110_open
+iser_device_find_by_ib_device
+iso_sched_alloc
+iso_stream_alloc
+it821x_firmware_command
+iwl_parse_eeprom_data
+iwl_parse_nvm_data
+iwl_phy_db_init
+iwl_sta_alloc_lq
+iwl_trans_pcie_alloc
+jffs2_alloc_full_dirent
+journal_init_common
+kcalloc
+kmalloc
+kmem_alloc
+kobject_create
+kobject_get_path
+kobj_map_init
+kset_create
+kstruprdup
+kvm_create_pic
+kvm_create_pit
+kzalloc
+l2cap_chan_create
+l2tp_session_create
+lapb_create_cb
+lc_create
+leaf_info_new
+lib80211_ccmp_init
+lib80211_tkip_init
+lib80211_wep_init
+libipw_alloc_txb
+line6_alloc_sysex_buffer
+linear_conf
+llc_nop_init
+llc_sap_alloc
+llc_shdlc_init
+locate_module_kobject
+lowpan_alloc_new_frame
+lpddr_cmdset
+lpddr_probe_chip
+lpfc_alloc_fast_evt
+lpfc_bsg_dma_page_alloc
+lpfc_bsg_event_new
+lpfc_create_vport_work_array
+lpfc_els_hbq_alloc
+lpfc_hba_alloc
+lpfc_sli4_create_rpi_hdr
+lpfc_sli4_queue_alloc
+lpfc_sli4_rb_alloc
+make_8023_client
+make_acpi_ec
+make_auth_domain_name
+make_cm_node
+make_EII_client
+make_entry
+make_slot_name
+map_absent_probe
+map_ram_probe
+map_rom_probe
+match_strdup
+matroxfb_crtc2_probe
+mb_cache_create
+mca_bucket_alloc
+mdiobus_alloc_size
+md_register_thread
+mei_cl_add_device
+mei_cl_allocate
+mei_io_cb_init
+mei_me_dev_init
+mem_cgroup_alloc
+memstick_alloc_card
+memstick_alloc_host
+memtype_get_idx
+merge_attr
+mesh_table_alloc
+mgag200_i2c_create
+mgag200_ttm_tt_create
+mgmt_pending_add
+mgsl_allocate_device
+mini_cm_listen
+minstrel_alloc
+minstrel_alloc_sta
+minstrel_ht_alloc_sta
+mISDN_register_clock
+mlx4_alloc_db_pgdir
+mlx4_alloc_icm
+mlx4_en_add
+mlx4_en_filter_alloc
+mlx5_alloc_db_pgdir
+mlx5_vzalloc
+mmc_alloc_host
+mmc_alloc_sg
+mmc_test_alloc_mem
+mousevsc_alloc_device
+mpi_alloc
+mpi_get_buffer
+mppe_alloc
+mpt2sas_transport_port_add
+mpt3sas_transport_port_add
+mptsas_expander_add
+mptscsih_info
+mthca_alloc_icm
+mthca_alloc_icm_table
+mv88e1xxx_phy_create
+mv88x201x_phy_create
+mvs_pci_alloc
+mv_u3d_build_trb_one
+mvumi_alloc_mem_resource
+mvumi_create_internal_cmd
+mwifiex_add_sta_entry
+mwifiex_wmm_allocate_ralist_node
+my3126_phy_create
+nand_bch_init
+nci_allocate_device
+ncp_alloc_req
+neigh_alloc
+neigh_hash_alloc
+nes_cm_alloc_core
+nes_get_cqp_request
+net_alloc_generic
+netdev_create_hash
+netlbl_secattr_cache_alloc
+netlbl_unlhsh_add_iface
+new_adapter
+new_compound_name
+_new_connect_scan_req
+new_coredump_node
+new_dir
+new_inode_smack
+new_l3_process
+new_lanai_vcc
+new_links
+new_ncci
+new_node
+new_plci
+new_pts_fs_info
+new_tape_buffer
+new_task_smack
+newtframe
+new_writequeue_entry
+nf_bridge_alloc
+nfc_allocate_device
+nfc_hci_allocate_device
+nfc_llc_allocate
+nfc_llcp_build_sdreq_tlv
+nfc_llcp_build_sdres_tlv
+nfc_llcp_build_tlv
+nfc_mei_phy_alloc
+nfs3_alloc_createdata
+nfs4_acl_new
+nfs4_alloc_createdata
+nfs4_alloc_lockdata
+nfs4_alloc_lock_state
+nfs4_alloc_open_state
+nfs4_alloc_pages
+nfs4_alloc_session
+nfs4_alloc_state_owner
+nfs4_alloc_unlockdata
+nfs4_blk_decode_device
+nfs4_new_slot
+nfs4_opendata_alloc
+nfs4_pnfs_ds_add
+nfs4_pnfs_remotestr
+nfs_alloc_createdata
+nfs_alloc_fattr
+nfs_alloc_fhandle
+nfs_alloc_parsed_mount_data
+nfs_alloc_seqid
+nfs_alloc_server
+nfs_cache_defer_req_alloc
+nfsd4_cltrack_legacy_recdir
+nfsd4_cltrack_legacy_topdir
+nfs_readdata_alloc
+nfs_writedata_alloc
+n_hdlc_alloc
+nilfs_segctor_new
+niu_new_parent
+nlm_alloc_call
+nlm_alloc_host
+nlmclnt_prepare_block
+nlmsvc_create_block
+nsm_create_handle
+nvme_alloc_iod
+nvme_alloc_ns
+nvme_alloc_queue
+nvme_bio_split
+ocfs2_allocate_refcount_tree
+ocfs2_alloc_quota_recovery
+ocfs2_dx_dir_kmalloc_leaves
+ocfs2_new_dlm_debug
+ocfs2_new_path
+ocfs2_xattr_bucket_new
+ocrdma_init_emb_mqe
+_osd_request_alloc
+OS_kmalloc
+oslec_create
+ovs_flow_tbl_alloc
+oz_alloc_urb_link
+oz_elt_info_alloc
+oz_ep_alloc
+oz_pd_alloc
+oz_tx_frame_alloc
+p54_convert_db
+p9_fcall_alloc
+padata_alloc
+padata_alloc_pd
+panel_bind_key
+parkbd_allocate_serio
+parport_register_device
+parport_register_port
+path_rec_create
+pch_uart_init_port
+pci_alloc_bus
+pci_alloc_dev
+pci_alloc_host_bridge
+pci_create_slot
+pcie_init
+pci_mmconfig_alloc
+pciserial_init_ports
+pci_store_saved_state
+pcistub_device_alloc
+pcmcia_device_add
+pcmcia_make_resource
+pcpu_get_vm_areas
+pcrypt_alloc_instance
+pfkey_sadb2xfrm_user_sec_ctx
+__phonet_device_alloc
+picolcd_send_and_wait
+pkt_alloc_packet_data
+pkt_kobj_create
+pm3393_mac_create
+pmcraid_alloc_sglist
+pneigh_lookup
+pnfs_mdsthreshold_alloc
+pnp_add_card_id
+pnp_add_id
+pnp_alloc
+pnp_alloc_card
+pnp_alloc_dev
+pnp_build_option
+pnp_new_resource
+pool_allocate
+pool_alloc_page
+posix_acl_alloc
+pps_register_source
+pri_detector_init
+prism2_read_pda
+__proc_create
+protection_domain_alloc
+psb_gtt_alloc_range
+psb_intel_crtc_mode_get
+psb_intel_i2c_create
+psb_mmu_alloc_pd
+psb_mmu_alloc_pt
+psb_mmu_driver_init
+pstore_ftrace_seq_start
+publ_create
+pvr2_context_create
+pvr2_dvb_create
+pvr2_eeprom_fetch
+pvr2_full_eeprom_fetch
+pvr2_hdw_create
+pvr2_ioread_create
+pvr2_std_create_enum
+pvr2_stream_create
+pvr2_sysfs_class_create
+pvr2_sysfs_create
+pvr2_v4l2_create
+qcam_init
+qdisc_class_hash_alloc
+qib_create_mmap_info
+qib_mcast_alloc
+qib_mcast_qp_alloc
+qib_qp_iter_init
+qib_user_sdma_queue_create
+qla2x00_alloc_fcport
+qla2x00_alloc_work
+qla4xxx_alloc_work
+qla4xxx_get_new_mrb
+qla84xx_get_chip
+qlcnic_sriov_get_free_node_async_work
+qlt_get_port_database
+qp_guest_endpoint_create
+qp_host_alloc_queue
+qset_new_std
+queue_new
+quickstart_buttons_add
+qxl_ring_create
+r8a66597_make_td
+radeon_atombios_get_lvds_info
+radeon_atombios_get_primary_dac_info
+radeon_atombios_get_tv_dac_info
+radeon_atombios_set_dac_info
+radeon_atombios_set_dig_info
+radeon_bios_get_hardcoded_edid
+radeon_combios_get_lvds_info
+radeon_combios_get_primary_dac_info
+radeon_combios_get_tv_dac_info
+radeon_i2c_create
+radeon_i2c_create_dp
+radeon_legacy_get_ext_tmds_info
+radeon_legacy_get_lvds_info_from_regs
+radeon_legacy_get_tmds_info
+radeon_vm_bo_add
+rate_control_alloc
+rate_control_pid_alloc
+rate_control_pid_alloc_sta
+rb_alloc
+rbd_dev_create
+rbd_spec_alloc
+rc_allocate_device
+rcu_string_strdup
+rdma_create_xprt
+rds_message_alloc
+read_rds_samples
+realloc_argv
+recent_entry_init
+record_old_file_extents
+regcache_rbtree_node_alloc
+regdom_intersect
+register_8022_client
+register_memory_resource
+register_snap_client
+__register_sysctl_paths
+__register_sysctl_table
+relay_create_buf
+relay_open
+result_init
+resv_map_alloc
+rfcomm_dlc_alloc
+rfcomm_session_add
+rfkill_alloc
+__ring_buffer_alloc
+ring_buffer_read_prepare
+rio_alloc_net
+rio_request_outb_dbell
+rio_setup_device
+rndis_add_response
+rproc_alloc
+rs_init
+rtl_rate_alloc_sta
+rxrpc_alloc_bundle
+rxrpc_alloc_connection
+rxrpc_alloc_local
+rxrpc_alloc_peer
+rxrpc_alloc_transport
+saa7164_buffer_alloc
+saa7164_buffer_alloc_user
+sas_alloc_device
+sas_phy_alloc
+sas_port_alloc
+sb_open
+sch56xx_watchdog_register
+scsi_alloc_sdev
+scsi_bios_ptable
+scsi_host_alloc
+scsi_prep_async_scan
+sctp_association_new
+sctp_auth_create_key
+sctp_auth_shkey_create
+sctp_datamsg_new
+sctp_endpoint_new
+sctp_pack_cookie
+sctp_ssnmap_new
+sctp_transport_new
+sd_alloc_ctl_entry
+sdebug_device_create
+sdev_evt_alloc
+sep_queue_status_add
+seq_create_client1
+__seq_open_private
+sesInfoAlloc
+sfi_sysfs_install_table
+sfq_alloc
+sf_sample_new
+sf_zone_new
+sg_add_sfp
+sid_to_key_str
+simple_xattr_alloc
+slhc_init
+sm_create_sysfs_attributes
+smi_info_alloc
+smk_import_entry
+smk_parse_smack
+smp_chan_create
+smscore_createbuffer
+smtc_alloc_fb_info
+snd_ctl_new
+snd_emux_create_port
+snd_info_create_entry
+snd_midi_channel_alloc_set
+snd_midi_channel_init_set
+snd_pdacf_create
+snd_seq_create_port
+snd_seq_fifo_new
+snd_seq_oss_readq_new
+snd_seq_oss_timer_new
+snd_seq_oss_writeq_new
+snd_seq_pool_new
+snd_seq_prioq_new
+snd_seq_timer_new
+snd_sf_new
+snd_timer_instance_new
+snd_usb_add_endpoint
+__snd_util_memblk_new
+snd_util_memhdr_new
+snd_vx_create
+sock_kmalloc
+sparse_index_alloc
+spi_alloc_device
+spi_alloc_master
+squashfs_cache_init
+srp_add_port
+srp_alloc_iu
+srp_ring_alloc
+srpt_alloc_ioctx
+srpt_alloc_ioctx_ring
+sta_info_alloc
+st_allocate_request
+stub_device_alloc
+submit_async_request
+subscr_named_msg_event
+subscr_subscribe
+__svc_create
+synaptics_i2c_touch_create
+sync_fence_alloc
+sync_pt_create
+sync_timeline_create
+sysfs_init_inode_attrs
+t1_espi_create
+t1_sge_create
+t1_tp_create
+t4_alloc_mem
+table_seq_start
+tconInfoAlloc
+tcpm_new
+tcp_v4_save_options
+td_alloc_init_desc
+tg3_vpd_readblock
+tifm_alloc_adapter
+tipc_alloc_entry
+tipc_createport
+tipc_link_create
+tipc_nameseq_create
+tipc_subseq_alloc
+tomoyo_commit_ok
+tomoyo_init_log
+tomoyo_print_bprm
+tomoyo_print_header
+tpm_bios_log_setup
+tpm_register_hardware
+trusted_options_alloc
+__ttm_dma_alloc_page
+ttm_object_device_init
+ttm_object_file_init
+tty_audit_buf_alloc
+tty_buffer_alloc
+tun_flow_create
+_ubh_bread_
+ucma_alloc_ctx
+ucma_alloc_multicast
+udf_sb_alloc_bitmap
+udl_encoder_init
+udl_gem_alloc_object
+udl_get_edid
+uf_sdio_mmc_register_pm_notifier
+ulist_alloc
+umc_device_create
+unifi_alloc_card
+usb_alloc_dev
+usb_alloc_urb
+usb_cache_string
+usb_create_shared_hcd
+usbctlx_alloc
+usbhsh_ureq_alloc
+usbip_alloc_iso_desc_pdu
+usbvision_alloc
+uvc_alloc_entity
+uvesafb_prep
+__uwb_beca_add
+uwb_drp_ie_alloc
+uwb_rc_alloc
+uwb_rsv_alloc
+v4l2_ctrl_new
+v9fs_alloc_rdir_buf
+vb2_dc_get_base_sgt
+vb2_dma_sg_alloc
+vb2_dma_sg_get_userptr
+vb2_get_vma
+vb2_vmalloc_alloc
+vb2_vmalloc_get_userptr
+via_aux_probe
+via_new_spec
+vic_provinfo_alloc
+__videobuf_alloc
+__videobuf_alloc_vb
+videobuf_dvb_alloc_frontend
+vlan_info_alloc
+vlan_vid_info_alloc
+vlsi_alloc_ring
+vmalloc_to_sg
+vmbus_device_create
+vmci_handle_arr_create
+vme_dma_pattern_attribute
+vme_dma_pci_attribute
+vme_dma_request
+vme_dma_vme_attribute
+vme_lm_request
+vme_master_request
+vme_new_dma_list
+vme_slave_request
+vmw_fence_manager_init
+vmxnet3_copy_mc
+vnic_dev_register
+vq_req_alloc
+vsc7326_mac_create
+vxfs_getfsh
+__vxge_hw_channel_allocate
+vxge_os_dma_malloc
+w1_alloc_dev
+wakeup_source_create
+wa_xfer_create_subset_sg
+wiimote_create
+wl1271_op_prepare_multicast
+wlc_phy_shared_attach
+wlc_phy_shim_attach
+wm_adsp_buf_alloc
+wpan_phy_alloc
+wusb_dev_alloc
+xbv_to_patch
+xfrm_hash_alloc
+xfrm_policy_alloc
+xfrm_state_alloc
+xhci_alloc_command
+xhci_alloc_container_ctx
+xhci_alloc_stream_info
+xhci_ring_alloc
+xhci_segment_alloc
+xprt_alloc
+xprt_dynamic_alloc_slot
+xt_alloc_table_info
+xz_dec_bcj_create
+xz_dec_init
+xz_dec_lzma2_create
+zbud_create_pool
+z_comp_alloc
+z_decomp_alloc
+zoran_setup_videocodec
+zram_meta_alloc
+zs_create_pool
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs.remove b/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs.remove
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs.remove
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs_gfp b/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs_gfp
new file mode 100644
index 0000000000..775884e83a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs_gfp
@@ -0,0 +1,744 @@
+// Automatically generated by add_gfp_to_allocations.sh
+aarp_alloc X
+acpi_processor_alloc_pdc X
+add_device X
+add_missing_dev X
+add_one_partition X
+adfs_read_map X
+aer_alloc_rpc X
+afs_alloc_flat_call X
+afs_alloc_server X
+afs_vlocation_alloc X
+agp_alloc_bridge X
+agp_create_client X
+agp_create_controller X
+agp_create_memory X
+agp_create_user_memory X
+ahc_alloc X
+ahc_alloc_tstate X
+ahd_alloc X
+ahd_alloc_tstate X
+alloc_area X
+alloc_async X
+allocate_bitmap_node X
+allocate_request X
+__alloc_atm_dev X
+alloc_bd_holder X
+alloc_behind_pages X
+alloc_buf X
+alloc_buffer X
+alloc_cell X
+alloc_chunk X
+alloc_client X
+alloc_context X
+alloc_ctrl_packet X
+alloc_data_packet X
+alloc_dca_provider X
+alloc_dev X
+alloc_dma_iso_ctx X
+alloc_ebda_hpc X
+alloc_ep 1
+alloc_error_bus X
+alloc_fdtable X
+alloc_group_attrs X
+alloc_ioapic_entries X
+alloc_jh X
+alloc_journal_list X
+alloc_mpc X
+alloc_msi_entry X
+alloc_multipath X
+AllocNetDevice X
+alloc_nfs_open_context X
+alloc_nilfs X
+_alloc_path_selector X
+alloc_pci_dev X
+alloc_pcie_link_state X
+alloc_pcpu_chunk X
+__alloc_pending_request 0
+alloc_pgpath X
+alloc_pg_vec X
+alloc_pipe_info X
+alloc_pl X
+alloc_priority_group X
+alloc_rdma X
+alloc_read_gpt_entries X
+alloc_read_gpt_header X
+alloc_resources X
+alloc_rootdomain X
+alloc_sched_domains X
+alloc_scq X
+alloc_selector X
+alloc_sglist X
+alloc_sock_iocb X
+alloc_super X
+alloc_symbol_cache X
+alloc_tree X
+alloc_tty_driver X
+alloc_urbs X
+AllocVmbusChannel X
+amd_alloc_nb X
+aoedev_by_sysminor_m X
+ap_add_sta X
+ap_auth_make_challenge X
+append_internal X
+argv_split 0
+ata_port_alloc X
+ath_gen_timer_alloc X
+ath_rate_alloc_sta 2
+atif_add_device X
+atom_parse X
+audit_buffer_alloc 1
+audit_krule_to_data X
+audit_krule_to_rule X
+autofs4_init_ino X
+avmcard_dma_alloc X
+ax25_create_cb X
+b1_alloc_card X
+b43_calibrate_lo_setting X
+b43_generate_dyn_tssi2dbm_tab X
+b43legacy_generate_probe_resp X
+b43legacy_setup_dmaring X
+b43legacy_setup_pioqueue X
+b43_setup_dmaring X
+b43_setup_pioqueue_rx X
+b43_setup_pioqueue_tx X
+bio_alloc_map_data 2
+bio_kmalloc 0
+bioset_create X
+bitmap_alloc_page X
+__blk_queue_init_tags X
+brd_alloc X
+br_multicast_new_group X
+bsd_alloc X
+bsg_alloc_device X
+btmrvl_add_card X
+build_path_from_dentry X
+cachefiles_cook_key X
+call_usermodehelper_setup 3
+capiminor_alloc X
+capincci_alloc X
+cas_page_alloc 1
+cciss_allocate_sg_chain_blocks X
+cdebbuf_alloc X
+cdev_alloc X
+cfi_read_pri X
+cfi_staa_setup X
+cifs_build_path_to_root X
+cifs_new_fileinfo X
+cifs_strndup_from_ucs X
+class_compat_register X
+clusterip_config_init X
+cmtp_application_add X
+cnic_alloc_dev X
+cn_queue_alloc_callback_entry X
+cn_queue_alloc_dev X
+Config_FileOperation X
+copy_tlv X
+country_ie_2_rd X
+cpia2_init_camera_struct X
+cpia_register_camera X
+cpqhp_slot_create X
+create_a X
+create_bounce_buffer X
+create_driver X
+create_event X
+create_l2 X
+create_logical_pred X
+create_neighbor X
+create_port X
+create_pred X
+create_regulator X
+create_rmpp_recv X
+create_serial X
+create_trace_option_files X
+create_unique_id X
+create_uts_ns X
+create_wlan X
+__create_workqueue_key X
+__crypto_alloc_tfm X
+crypto_create_tfm X
+cs46xx_dsp_spos_create X
+cs5535_mfgpt_alloc_timer X
+csr1212_create_csr X
+csr1212_new_keyval X
+ct_timer_instance_new X
+ct_timer_new X
+cx88_core_create X
+cxgb3i_c3cn_create X
+cxgb3i_ddp_make_gl 4
+cxgb_alloc_mem X
+cyberpro_alloc_fb_info X
+cypress_buf_alloc X
+DAC960_DetectController X
+dca_allocate_domain X
+dcookie_register X
+debug_buffer_allocate X
+device_alloc X
+devinfo_seq_start X
+dev_new X
+dev_seq_start X
+dlm_allocate_lvb X
+dlm_allocate_rsb X
+dlm_alloc_ctxt X
+dlm_alloc_pagevec X
+dm_alloc_md_mempools X
+dma_pin_iovec_pages X
+dm_dirty_log_create X
+dn_dev_alloc_ifa X
+dn_dev_create X
+dn_new_zone X
+drbd_new_device X
+drm_agp_init X
+drm_gem_object_alloc X
+drm_get_edid X
+drm_master_create X
+drm_mm_kmalloc 1
+drm_mode_create X
+drm_pci_alloc X
+drm_property_create X
+drm_property_create_blob X
+drm_sman_alloc X
+dsp_cmx_new_conf X
+edac_device_alloc_ctl_info X
+edac_mc_alloc X
+edac_pci_alloc_ctl_info X
+edge_buf_alloc X
+efx_tsoh_heap_alloc X
+eg_cache_add_entry X
+ehci_qh_alloc X
+ext3_htree_create_dir_info X
+ext4_htree_create_dir_info X
+ext4_init_io_end 1
+__fa_get_part 2
+fb_create_modedb X
+fb_do_probe_ddc_edid X
+fc_exch_mgr_add X
+fc_exch_mgr_alloc X
+fcoe_interface_create X
+fc_rport_create X
+fdtv_alloc X
+fib6_alloc_table X
+fib_hash_table X
+fl_create X
+flex_array_alloc 2
+flexcop_device_kmalloc X
+fnic_dev_register X
+fn_new_zone X
+frame_new X
+fscache_alloc_retrieval X
+fuse_file_alloc X
+fwnet_pd_new X
+fw_node_create X
+garp_attr_create X
+gcov_info_dup X
+gcov_iter_new X
+genprobe_ident_chips X
+getdqbuf X
+get_free_de X
+get_indirect_ea X
+GetRndisDevice X
+GetRndisRequest X
+get_scq X
+get_video_info X
+get_vm_block X
+gf128mul_init_4k_bbe X
+gf128mul_init_4k_lle X
+gf128mul_init_64k_bbe X
+gf128mul_init_64k_lle X
+gfs2_alloc_get X
+gigaset_initdriver X
+go7007_alloc X
+groups_alloc X
+gss_alloc_context X
+hashbin_new X
+hash_new X
+hashtab_create X
+hci_alloc_dev X
+hci_conn_add X
+hfs_btree_open X
+hfsplus_btree_open X
+hid_register_field X
+__hostap_add_bss X
+hpfs_get_4sectors X
+hpfs_load_bitmap_directory X
+hpfs_load_code_page X
+hpfs_map_4sectors X
+hpsb_alloc_host X
+hpsb_alloc_packet X
+hpsb_iso_common_init X
+hso_create_device X
+hso_create_shared_int X
+i1480u_tx_create 2
+__i2400m_work_setup 2
+i2c_matroxfb_probe X
+i2c_new_device X
+i2o_exec_wait_alloc X
+ibmasm_new_command X
+ibm_slot_from_id X
+ib_ucm_ctx_alloc X
+icn_initcard X
+ics5342_init X
+idt77252_init_est X
+ieee80211_alloc_txb 2
+ieee80211_ccmp_init X
+ieee80211_key_alloc X
+ieee80211_tkip_init X
+iio_allocate_device X
+iio_allocate_interrupt X
+iio_allocate_trigger X
+in_cache_add_entry X
+inetdev_init X
+inet_frag_alloc X
+init_sbd X
+init_send_hfcd X
+input_allocate_device X
+input_allocate_polled_device X
+ioat2_alloc_ring 2
+ioat_dma_alloc_descriptor 1
+iommu_domain_alloc X
+ipc_alloc X
+ipc_rcu_alloc X
+ipmi_alloc_recv_msg X
+ipmi_alloc_smi_msg X
+ipoib_cm_create_tx X
+ipoib_create_ah X
+ipoib_mcast_alloc X
+ipoib_mcast_iter_init X
+ipoib_neigh_alloc X
+ipoib_path_iter_init X
+ipr_alloc_ucode_buffer X
+ipv6_add_dev X
+ip_vs_dest_set_insert X
+ipw_alloc_error_log X
+ipwireless_hardware_create X
+ipwireless_network_create X
+ipw_rx_queue_alloc X
+ipxitf_alloc X
+ircomm_open X
+irda_usb_find_class_desc X
+iriap_open X
+irias_new_integer_value X
+irias_new_missing_value X
+irias_new_object X
+irias_new_octseq_value X
+irias_new_string_value X
+irlap_open X
+irlmp_copy_discoveries X
+irlmp_open_lsap X
+irlmp_register_client X
+irlmp_register_service X
+irttp_dup X
+irttp_open_tsap X
+iscsi_alloc_session X
+iscsi_create_conn X
+iscsi_create_endpoint X
+isdn_audio_adpcm_init X
+isdn_audio_dtmf_init X
+isdn_audio_silence_init X
+isdn_ppp_ccp_reset_alloc X
+isdn_ppp_ccp_reset_alloc_state X
+isdn_v110_open X
+iser_device_find_by_ib_device X
+iso_sched_alloc 1
+iso_stream_alloc 0
+it821x_firmware_command X
+jffs2_alloc_full_dirent X
+journal_init_common X
+kcalloc 2
+kmalloc 1
+kmem_alloc X
+kobject_create X
+kobject_get_path 1
+kobj_map_init X
+kset_create X
+kstruprdup 1
+kvasprintf 0
+kvm_create_pic X
+kvm_create_pit X
+kzalloc 1
+lapb_create_cb X
+lc_create X
+lib80211_ccmp_init X
+lib80211_tkip_init X
+lib80211_wep_init X
+libipw_alloc_txb 3
+line6_alloc_sysex_buffer X
+linear_conf X
+llc_sap_alloc X
+loop_alloc X
+lpddr_cmdset X
+lpddr_probe_chip X
+lpfc_alloc_fast_evt X
+lpfc_bsg_event_new X
+lpfc_create_vport_work_array X
+lpfc_els_hbq_alloc X
+lpfc_hba_alloc X
+lpfc_sli4_create_rpi_hdr X
+lpfc_sli4_queue_alloc X
+lpfc_sli4_rb_alloc X
+make_8023_client X
+make_acpi_ec X
+make_bind_capture X
+make_class_name X
+make_cm_node X
+make_driver_name X
+make_EII_client X
+make_entry X
+make_resource X
+make_slot_name X
+map_absent_probe X
+map_ram_probe X
+map_rom_probe X
+match_strdup X
+matroxfb_crtc2_probe X
+mb_cache_create X
+mca_attach_bus X
+mdiobus_alloc X
+md_register_thread X
+mem_cgroup_alloc X
+memstick_alloc_card X
+memstick_alloc_host X
+memtype_get_idx X
+mesh_table_alloc X
+mgsl_allocate_device X
+mini_cm_listen X
+minstrel_alloc X
+minstrel_alloc_sta 2
+mISDN_register_clock X
+mlx4_alloc_db_pgdir X
+mlx4_alloc_icm X
+mlx4_en_add X
+mmc_alloc_host X
+mppe_alloc X
+mpt2sas_transport_port_add X
+mptsas_expander_add X
+mptscsih_info X
+mthca_alloc_icm X
+mthca_alloc_icm_table X
+mv88e1xxx_phy_create X
+mv88x201x_phy_create X
+mvs_alloc_task X
+mvs_pci_alloc X
+my3126_phy_create X
+neigh_hash_alloc X
+nes_cm_alloc_core X
+nes_get_cqp_request X
+net_alloc_generic X
+netdev_create_hash X
+netfs_trans_alloc X
+netlbl_unlhsh_add_iface X
+new_adapter X
+new_inode_smack X
+new_l3_process X
+new_node X
+new_plci X
+new_pts_fs_info X
+new_tape_buffer X
+new_writequeue_entry 1
+nfs3_alloc_createdata X
+nfs4_acl_new X
+nfs4_alloc_createdata X
+nfs4_alloc_lockdata X
+nfs4_alloc_lock_state X
+nfs4_alloc_open_state X
+nfs4_alloc_session X
+nfs4_alloc_state_owner X
+nfs4_alloc_unlockdata X
+nfs4_opendata_alloc X
+nfs_alloc_parsed_mount_data X
+nfs_alloc_seqid X
+nfs_alloc_server X
+nfs_cache_defer_req_alloc X
+n_hdlc_alloc X
+ni_65xx_alloc_subdevice_private X
+ni_gpct_device_construct X
+nilfs_segctor_new X
+niu_new_parent X
+nlm_alloc_call X
+nlmclnt_prepare_block X
+nlm_lookup_host X
+nlmsvc_create_block X
+nodemgr_create_node X
+nodemgr_process_unit_directory X
+nsm_create_handle X
+ocfs2_allocate_refcount_tree X
+ocfs2_alloc_quota_recovery X
+ocfs2_dx_dir_kmalloc_leaves X
+ocfs2_new_dlm_debug X
+ocfs2_new_path X
+ocfs2_xattr_bucket_new X
+_osd_request_alloc 0
+osd_WaitEventCreate X
+oslec_create X
+oti6858_buf_alloc X
+p54_convert_db X
+padata_alloc X
+padata_alloc_pd X
+panel_bind_key X
+parkbd_allocate_serio X
+parport_register_device X
+parport_register_port X
+path_rec_create X
+pci_alloc_bus X
+pcibios_get_irq_routing_table X
+pci_create_slot X
+pcie_init X
+pci_mmconfig_add X
+pciserial_init_ports X
+pcmcia_device_add X
+pcpu_get_vm_areas X
+pcrypt_alloc_instance X
+perf_mmap_data_alloc X
+__phonet_device_alloc X
+pkt_alloc_packet_data X
+pkt_bio_alloc X
+pkt_kobj_create X
+pl2303_buf_alloc X
+pm3393_mac_create X
+pm8001_alloc_task X
+pmcraid_alloc_sglist X
+pneigh_lookup X
+pnp_add_card_id X
+pnp_add_id X
+pnp_alloc X
+pnp_alloc_card X
+pnp_alloc_dev X
+pnp_build_option X
+pnp_new_resource X
+pohmelfs_name_alloc X
+pool_allocate X
+pool_alloc_page 1
+posix_acl_alloc 1
+prism2_read_pda X
+prism2_wep_init X
+__proc_create X
+publ_create X
+pvr2_context_create X
+pvr2_dvb_create X
+pvr2_eeprom_fetch X
+pvr2_full_eeprom_fetch X
+pvr2_hdw_create X
+pvr2_ioread_create X
+pvr2_std_create_enum X
+pvr2_stream_create X
+pvr2_sysfs_class_create X
+pvr2_sysfs_create X
+pvr2_v4l2_create X
+qcam_init X
+qdisc_class_hash_alloc X
+qla2x00_alloc_fcport 1
+qla2x00_alloc_work X
+qla84xx_get_chip X
+qset_new_std 3
+queue_new X
+r10bio_pool_alloc 0
+r1bio_pool_alloc 0
+r8a66597_make_td X
+radeon_atombios_get_lvds_info X
+radeon_atombios_get_primary_dac_info X
+radeon_atombios_get_ss_info X
+radeon_atombios_get_tv_dac_info X
+radeon_atombios_set_dac_info X
+radeon_atombios_set_dig_info X
+radeon_combios_get_lvds_info X
+radeon_combios_get_primary_dac_info X
+radeon_combios_get_tv_dac_info X
+radeon_i2c_create X
+radeon_i2c_create_dp X
+radeon_legacy_get_ext_tmds_info X
+radeon_legacy_get_lvds_info_from_regs X
+radeon_legacy_get_tmds_info X
+rate_control_alloc X
+rate_control_pid_alloc X
+rate_control_pid_alloc_sta 2
+rdma_create_xprt X
+rds_message_alloc 1
+rds_rdma_prepare X
+read_rds_samples X
+Realloc X
+realloc_argv X
+recent_entry_init X
+regdom_intersect X
+register_8022_client X
+register_snap_client X
+__register_sysctl_paths X
+relay_alloc_page_array X
+relay_create_buf X
+relay_open X
+__request_region X
+resv_map_alloc X
+rfcomm_dlc_alloc 0
+rfcomm_session_add X
+rfkill_alloc X
+__ring_buffer_alloc X
+ring_buffer_read_start X
+rndis_add_response X
+rpc_alloc_iostats X
+rs_init X
+rxrpc_alloc_bundle 0
+rxrpc_alloc_connection 0
+rxrpc_alloc_local X
+rxrpc_alloc_peer 1
+rxrpc_alloc_transport 2
+saa7164_buffer_alloc X
+sas_ex_discover_end_dev X
+sas_ex_discover_expander X
+sas_phy_alloc X
+sas_port_alloc X
+savemem X
+sbp2_alloc_device X
+scan_behind_bridge X
+scm_fp_dup X
+scsi_alloc_sdev X
+scsi_bios_ptable X
+scsi_host_alloc X
+scsi_prep_async_scan X
+sctp_association_new 3
+sctp_auth_create_key 1
+sctp_auth_make_key_vector 3
+sctp_auth_shkey_create 1
+sctp_datamsg_new 0
+sctp_endpoint_new 1
+sctp_pack_cookie X
+sctp_ssnmap_new 2
+sctp_transport_new 1
+scx200_create_iface X
+sd_alloc_ctl_entry X
+sdebug_device_create 1
+sdev_evt_alloc 1
+seq_create_client1 X
+__seq_open_private X
+serial_buf_alloc X
+sesInfoAlloc X
+sf_sample_new X
+sf_zone_new X
+sg_add_sfp X
+slhc_init X
+slvl_init X
+smk_import_entry X
+smscore_createbuffer X
+smtc_alloc_fb_info X
+snd_ctl_new X
+snd_emux_create_port X
+snd_gf1_mem_xalloc X
+snd_info_create_entry X
+snd_midi_channel_alloc_set X
+snd_midi_channel_init_set X
+snd_pdacf_create X
+snd_seq_create_port X
+snd_seq_fifo_new X
+snd_seq_oss_readq_new X
+snd_seq_oss_timer_new X
+snd_seq_oss_writeq_new X
+snd_seq_pool_new X
+snd_seq_prioq_new X
+snd_seq_timer_new X
+snd_sf_new X
+snd_timer_instance_new X
+__snd_util_memblk_new X
+snd_util_memhdr_new X
+snd_vx_create X
+sock_kmalloc 1
+sock_kmalloc 2
+spi_alloc_device X
+spi_alloc_master X
+squashfs_cache_init X
+srp_add_port X
+srp_alloc_iu 2
+srp_ring_alloc X
+sta_info_alloc 2
+st_allocate_request X
+stl_allocbrd X
+stli_allocbrd X
+stub_device_alloc X
+submit_async_request 5
+subscr_subscribe X
+sv11_init X
+__svc_create X
+svc_setup_socket X
+synaptics_i2c_touch_create X
+sysfs_init_inode_attrs X
+t1_espi_create X
+t1_sge_create X
+t1_tp_create X
+table_seq_start X
+tconInfoAlloc X
+tcp_v4_save_options X
+ti_buf_alloc X
+tifm_alloc_adapter X
+tipc_cltr_create X
+tipc_disc_init_link_req X
+tipc_link_create X
+tipc_nameseq_create X
+tipc_subseq_alloc X
+tipc_zone_create X
+tomoyo_find_or_assign_new_profile X
+tomoyo_realpath_from_path X
+tpm_bios_log_setup X
+tpm_register_hardware X
+trace_create_file_ops X
+ttm_object_device_init X
+ttm_object_file_init X
+ttm_tt_create X
+tty_audit_buf_alloc X
+tty_buffer_alloc X
+_ubh_bread_ X
+ucma_alloc_ctx X
+ucma_alloc_multicast X
+udf_sb_alloc_bitmap X
+umc_device_create X
+usb_alloc_dev X
+usb_alloc_urb 1
+usb_cache_string X
+usb_create_hcd X
+usbctlx_alloc X
+usbip_alloc_iso_desc_pdu X
+usbvision_alloc X
+uvc_alloc_entity X
+uvesafb_prep X
+uvesafb_vbe_state_save X
+__uwb_beca_add X
+uwb_drp_ie_alloc X
+uwb_rc_alloc X
+uwb_rsv_alloc X
+via_new_spec X
+__videobuf_alloc X
+videobuf_dvb_alloc_frontend X
+videocodec_attach X
+vlan_group_alloc X
+vlsi_alloc_ring X
+vmalloc_to_sg X
+vme_dma_pattern_attribute X
+vme_dma_pci_attribute X
+vme_dma_request X
+vme_dma_vme_attribute X
+vme_lm_request X
+vme_master_request X
+vme_new_dma_list X
+vme_slave_request X
+vmxnet3_copy_mc X
+vnic_dev_register X
+vq_req_alloc X
+vsc7326_mac_create X
+vxfs_getfsh X
+__vxge_hw_channel_allocate X
+w1_alloc_dev X
+wl1271_op_prepare_multicast X
+wl_new_wavepoint X
+wlp_create_wssid_e X
+wpan_phy_alloc X
+wusb_dev_alloc X
+xfrm_hash_alloc X
+xfrm_policy_alloc 1
+xfrm_state_alloc X
+xhci_alloc_command 3
+xhci_alloc_container_ctx 2
+xhci_ring_alloc 3
+xhci_segment_alloc 1
+xt_alloc_table_info X
+xv_create_pool X
+z_comp_alloc X
+z_decomp_alloc X
+zfwMemAllocate X
+zlib_init X
+zoran_setup_videocodec X
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs_gfp.remove b/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs_gfp.remove
new file mode 100644
index 0000000000..78c093f6f8
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.allocation_funcs_gfp.remove
@@ -0,0 +1,2 @@
+acquire_group 2
+acquire_group X
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.bit_shifters b/usr/src/tools/smatch/src/smatch_data/kernel.bit_shifters
new file mode 100644
index 0000000000..996e2804de
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.bit_shifters
@@ -0,0 +1,4446 @@
+// list of macros used as shifters.
+// generated by `gen_bit_shifters.sh`
+AB8500_AD_DATA0_OFFSET 0
+AB8500_DA_DATA0_OFFSET 8
+ABORT_CONN 15
+ABORT_ISP_ACTIVE 3
+ABORT_UPCALL 6
+ABS_HAT0X 16
+ABS_HAT0Y 17
+ABS_HAT1X 18
+ABS_HAT1Y 19
+ABS_HAT2X 20
+ABS_HAT2Y 21
+ABS_HAT3X 22
+ABS_HAT3Y 23
+ABS_POS_BITS 13
+ABS_PRESSURE 24
+ABS_RX 3
+ABS_RY 4
+ABS_RZ 5
+ABS_X 0
+ABS_Y 1
+AC97_EI_DACS_SLOT_SHIFT 4
+AC97_SC_SPSR_SHIFT 12
+AC97_SLOT_LFE 9
+AC97_SLOT_MIC 6
+AC97_SLOT_PCM_CENTER 6
+AC97_SLOT_PCM_LEFT_0 7
+AC97_SLOT_PCM_LEFT 3
+AC97_SLOT_PCM_RIGHT_0 8
+AC97_SLOT_PCM_RIGHT 4
+AC97_SLOT_PCM_SLEFT 7
+AC97_SLOT_PCM_SRIGHT 8
+AC97_SLOT_SPDIF_LEFT1 6
+AC97_SLOT_SPDIF_LEFT2 10
+AC97_SLOT_SPDIF_LEFT 7
+AC97_SLOT_SPDIF_RIGHT1 9
+AC97_SLOT_SPDIF_RIGHT2 11
+AC97_SLOT_SPDIF_RIGHT 8
+AC_AMPCAP_MUTE_SHIFT 31
+AC_AMPCAP_NUM_STEPS_SHIFT 8
+AC_AMPCAP_OFFSET_SHIFT 0
+AC_AMPCAP_STEP_SIZE_SHIFT 16
+AC_AMP_SET_INDEX_SHIFT 8
+AC_DEFCFG_DEVICE_SHIFT 20
+AC_DEFCFG_PORT_CONN_SHIFT 30
+ACK_RATIO_SHIFT 4
+AC_PARAM_ECW_MAX_OFFSET 12
+AC_PARAM_ECW_MIN_OFFSET 8
+AC_PARAM_TXOP_OFFSET 16
+ACPI_BATTERY_ALARM_PRESENT 0
+ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY 2
+ACPI_BATTERY_QUIRK_THINKPAD_MAH 3
+ACPI_BATTERY_XINFO_PRESENT 1
+ACPI_X_SLEEP_TYPE_POSITION 2
+ACT_ESTAB 3
+ACT_OFLD_CONN 1
+ACT_OPEN_REQ 0
+ACT_OPEN_RPL 2
+ACT_RETRY_INUSE 21
+ACT_RETRY_NOMEM 20
+AD1836_ADC_WORD_OFFSET 4
+AD1836_DAC_WORD_LEN_OFFSET 3
+AD193X_ADC_CHAN_SHFT 4
+AD193X_DAC_CHAN_SHFT 1
+AD193X_DAC_WORD_LEN_SHFT 3
+AD5380_CTRL_PWR_DOWN_MODE_OFFSET 13
+AD5449_CTRL_SDO_OFFSET 10
+AD5755_DC_DC_FREQ_SHIFT 2
+AD5755_DC_DC_MAXV 0
+AD5755_DC_DC_PHASE_SHIFT 4
+AD5755_SLEW_RATE_SHIFT 3
+AD5755_SLEW_STEP_SIZE_SHIFT 0
+AD7816_TEMP_FLOAT_OFFSET 2
+AD799X_CHANNEL_SHIFT 4
+AD9832_FREQ_BITS 32
+AD9832_PHASE_BITS 12
+AD9834_FREQ_BITS 28
+AD9834_PHASE_BITS 12
+ADAP_INIT 0
+ADAP_SLEEP 1
+ADAP_STREAMING 2
+ADAPTER_STATE_GOING_DOWN 1
+ADAPTER_STATE_INIT_FAILED 31
+ADAPTER_STATE_LINK_DOWN 2
+ADAPTER_STATE_READY 3
+ADAPTER_STATE_UP 0
+ADAU1373_EP_CTRL_MICBIAS1_OFFSET 4
+ADAU1373_EP_CTRL_MICBIAS2_OFFSET 2
+ADC_FRAC_BITS 14
+ADDR_LEN 6
+addr_shift 12
+ADM1031_UPDATE_RATE_SHIFT 2
+ADMA_MMIO_BAR 4
+ADT7316_T_VALUE_FLOAT_OFFSET 2
+ADT7462_PWM_CHANNEL_SHIFT 5
+ADT7462_PWM_RANGE_SHIFT 4
+AEL2020_GPIO_MODDET 1
+AF_82XX_DUMP_READING 26
+AF_82XX_FW_DUMPED 24
+AF_83XX_IOCB_INTR_ON 28
+AF_83XX_MBOX_INTR_ON 29
+AF_83XX_NO_FW_DUMP 27
+AF_8XXX_RST_OWNER 25
+AF_BUILD_DDB_LIST 22
+AF_EEH_BUSY 20
+AF_FW_RECOVERY 19
+AF_GET_CRASH_RECORD 7
+AF_HA_REMOVAL 12
+AF_INIT_DONE 1
+AF_INTERRUPTS_ON 6
+AF_INTx_ENABLED 15
+AF_IRQ_ATTACHED 10
+AF_LINK_UP 8
+AF_LOOPBACK 9
+AF_MBOX_COMMAND 2
+AF_MBOX_COMMAND_DONE 3
+AF_MBOX_COMMAND_NOPOLL 18
+AF_MSI_ENABLED 16
+AF_MSIX_ENABLED 17
+AF_ONLINE 0
+AF_PCI_CHANNEL_IO_PERM_FAILURE 21
+AF_ST_DISCOVERY_IN_PROGRESS 4
+AFS_VNODE_AUTOCELL 10
+AFS_VNODE_CB_BROKEN 0
+AFS_VNODE_DELETED 4
+AFS_VNODE_LOCKING 6
+AFS_VNODE_MODIFIED 2
+AFS_VNODE_MOUNTPOINT 5
+AFS_VNODE_PSEUDODIR 11
+AFS_VNODE_READLOCKED 7
+AFS_VNODE_UNSET 1
+AFS_VNODE_WRITELOCKED 8
+AFS_VNODE_ZAP_DATA 3
+AGP_FF_ALLOW_CLIENT 0
+AGP_FF_ALLOW_CONTROLLER 1
+AGP_FF_IS_CLIENT 2
+AGP_FF_IS_CONTROLLER 3
+AGP_FF_IS_VALID 4
+AHCI_PCI_BAR 5
+AIC32X4_DOSRMSB_SHIFT 4
+AIC32X4_PLLJ_SHIFT 6
+ALARM_ENABLE_SHIFT 7
+ALI_AC97_GPIO_DATA_SHIFT 16
+_ALLOC_dirid_groups 10
+_ALLOC_packing_groups 12
+_ALLOC_skip_busy 5
+ALSA_CAPTURE_OPEN 2
+ALSA_CAPTURE_RUNNING 4
+ALSA_PLAYBACK_OPEN 3
+ALSA_PLAYBACK_RUNNING 5
+ALT_NAK_OUT_PACKETS 7
+ALX_DEV_CTRL_MAXRRS_MIN 2
+ALX_DMA_RCHNL_SEL_SHIFT 26
+ALX_DMA_RDLY_CNT_SHIFT 11
+ALX_DMA_RORDER_MODE_SHIFT 0
+ALX_DMA_RREQ_BLEN_SHIFT 4
+ALX_DMA_WDLY_CNT_SHIFT 16
+ALX_HQTPD_Q1_NUMPREF_SHIFT 0
+ALX_HQTPD_Q2_NUMPREF_SHIFT 4
+ALX_HQTPD_Q3_NUMPREF_SHIFT 8
+ALX_IRQ_MODU_TIMER1_SHIFT 0
+ALX_MAC_CTRL_PRMBLEN_SHIFT 10
+ALX_MDIO_CLK_SEL_SHIFT 24
+ALX_MDIO_DATA_SHIFT 0
+ALX_MDIO_EXTN_DEVAD_SHIFT 16
+ALX_MDIO_EXTN_REG_SHIFT 0
+ALX_MDIO_REG_SHIFT 16
+ALX_MSI_RETRANS_TM_SHIFT 0
+ALX_RXQ0_IDT_TBL_SIZE_SHIFT 8
+ALX_RXQ0_NUM_RFD_PREF_SHIFT 20
+ALX_RXQ0_RSS_MODE_SHIFT 26
+ALX_RXQ2_RXF_XOFF_THRESH_SHIFT 16
+ALX_RXQ2_RXF_XON_THRESH_SHIFT 0
+ALX_TXQ0_TPD_BURSTPREF_SHIFT 0
+ALX_TXQ0_TXF_BURST_PREF_SHIFT 16
+ALX_WRR_PRI0_SHIFT 0
+ALX_WRR_PRI1_SHIFT 8
+ALX_WRR_PRI2_SHIFT 16
+ALX_WRR_PRI3_SHIFT 24
+ALX_WRR_PRI_SHIFT 29
+AMP_VAL_IDX_SHIFT 19
+ANALOG_FUZZ_BITS 2
+ANAPARAM_PWR0_SHIFT 28
+ANAPARAM_PWR1_SHIFT 20
+ANAPARAM_TXDACOFF_SHIFT 27
+APDS990X_APERS_SHIFT 0
+APDS990X_PPERS_SHIFT 4
+APERFMPERF_PRESENT 0
+AR5416_EEPROM_S 2
+AR5523_CONNECTED 2
+AR5523_HW_UP 0
+AR5523_USB_DISCONNECTED 1
+AR5K_BSS_ID1_AID_S 16
+AR5K_EEPROM_SIZE_ENDLOC_SHIFT 12
+AR5K_IFS0_DIFS_S 11
+AR5K_IFS1_CS_EN_S 26
+AR5K_NODCU_RETRY_LMT_CW_MIN_S 20
+AR5K_RSSI_THR_BMISS_S 8
+AR_ANT_DIV_CTRL_ALL_S 25
+AR_BufLen_S 16
+AR_CtrlStat_S 14
+AR_DescId_S 16
+AR_FAST_DIV_ENABLE_S 13
+ARITH_SHIFT 8
+ARIZONA_AIF1_RATE_SHIFT 11
+ARIZONA_AIF1TX_WL_SHIFT 8
+ARIZONA_CABLE_HEADPHONE 2
+ARIZONA_CABLE_MICROPHONE 1
+ARIZONA_FLL1_CLK_REF_DIV_SHIFT 6
+ARIZONA_FLL1_CLK_REF_SRC_SHIFT 0
+ARIZONA_FLL1_FRATIO_SHIFT 8
+ARIZONA_FLL1_GAIN_SHIFT 2
+ARIZONA_FLL1_OUTDIV_SHIFT 1
+ARIZONA_HAP_CTRL_SHIFT 2
+ARIZONA_HP_IMPEDANCE_RANGE_SHIFT 9
+ARIZONA_IN1_DMIC_SUP_SHIFT 11
+ARIZONA_IN1_MODE_SHIFT 9
+ARIZONA_LDO1_VSEL_SHIFT 5
+ARIZONA_MICD_BIAS_STARTTIME_SHIFT 12
+ARIZONA_MICD_DBTIME_SHIFT 1
+ARIZONA_MICD_RATE_SHIFT 8
+ARIZONA_OPCLK_DIV_SHIFT 3
+ARIZONA_SYSCLK_FREQ_SHIFT 8
+ARIZONA_SYSCLK_SRC_SHIFT 0
+AR_PHY_9285_ANT_DIV_ALT_LNACONF_S 25
+AR_PHY_9285_ANT_DIV_MAIN_LNACONF_S 27
+AR_PHY_9285_FAST_DIV_BIAS_S 9
+AR_PHY_ANT_DIV_ALT_GAINTB_S 29
+AR_PHY_ANT_DIV_ALT_LNACONF_S 25
+AR_PHY_ANT_DIV_LNADIV_S 24
+AR_PHY_ANT_DIV_MAIN_GAINTB_S 30
+AR_PHY_ANT_DIV_MAIN_LNACONF_S 27
+AR_PHY_ANT_FAST_DIV_BIAS_S 9
+AR_PHY_ANT_SW_RX_PROT_S 23
+AR_PHY_SFCORR_SPUR_SUBCHNL_SD_S 28
+AR_TxQcuNum_S 8
+AR_TxRxDesc_S 15
+AS_EIO 25
+AS_ENOSPC 26
+AS_PUSH_SHIFT 62
+ASYNCB_CHECK_CD 25
+ASYNCB_CLOSING 27
+ASYNCB_CTS_FLOW 26
+ASYNCB_INITIALIZED 31
+ASYNCB_SUSPENDED 30
+ATA_SHIFT_MWDMA 7
+ATA_SHIFT_PIO 0
+ATA_SHIFT_UDMA 12
+__AT_DOWN 3
+ATH10K_PCI_FEATURE_HW_1_0_WARKAROUND 1
+ATH10K_PCI_FEATURE_MSI_X 0
+ATH9K_NUM_TX_QUEUES 10
+ATH9K_TXDESC_PAPRD_S 16
+ATH_STAT_STARTED 3
+ATI_REG_CMD_SPDF_THRESHOLD_SHIFT 6
+ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT 16
+ATI_REG_OUT_DMA_THRESHOLD_SHIFT 11
+ATI_REG_PHYS_OUT_ADDR_SHIFT 9
+ATI_REG_PHYS_OUT_DATA_SHIFT 16
+ATL1C_WORK_EVENT_LINK_CHANGE 1
+ATL1C_WORK_EVENT_RESET 0
+__ATL2_DOWN 2
+ATM_DF_REMOVED 0
+ATMEL_AT45DB0X1B_PAGE_POS 9
+ATM_HDR_GFC_SHIFT 28
+ATM_HDR_PTI_SHIFT 1
+ATM_HDR_VCI_SHIFT 4
+ATM_HDR_VPI_SHIFT 20
+ATM_VF_ADDR 0
+ATM_VF_BOUND 4
+ATM_VF_CLOSE 11
+ATM_VF_HASQOS 6
+ATM_VF_HASSAP 10
+ATM_VF_IS_CLIP 13
+ATM_VF_LISTEN 7
+ATM_VF_META 8
+ATM_VF_PARTIAL 2
+ATM_VF_READY 1
+ATM_VF_REGIS 3
+ATM_VF_RELEASED 5
+ATM_VF_SESSION 9
+ATM_VF_WAITING 12
+ATOM_PPLL0 2
+ATOM_PPLL1 0
+ATOM_PPLL2 1
+ATOM_PPLL_SS_AMOUNT_V2_NFRAC_SHIFT 8
+ATOM_S2_CURRENT_BL_LEVEL_SHIFT 8
+ATP867X_BAR_IOBASE 0
+ATP867X_IO_DMAMODE_MSTR_SHIFT 0
+ATP867X_IO_DMAMODE_SLAVE_SHIFT 4
+ATP867X_IO_PIOSPD_ACTIVE_SHIFT 4
+ATP867X_IO_PIOSPD_RECOVER_SHIFT 0
+AutoDetected 4
+AUTOVALIDATE 5
+AXF_ERROR 2
+AXF_ESCAPE 1
+AXF_INUSE 0
+B1_HDLC 0
+B43_DMA32_DCTL_ADDREXT_SHIFT 16
+B43_DMA32_RXADDREXT_SHIFT 16
+B43_DMA32_RXFROFF_SHIFT 1
+B43_DMA32_TXADDREXT_SHIFT 16
+B43_DMA64_DCTL1_ADDREXT_SHIFT 16
+B43_DMA64_RXADDREXT_SHIFT 16
+B43_DMA64_RXFROFF_SHIFT 1
+B43_DMA64_TXADDREXT_SHIFT 16
+B43legacy_DMA32_DCTL_ADDREXT_SHIFT 16
+B43legacy_DMA32_RXADDREXT_SHIFT 16
+B43legacy_DMA32_RXFROFF_SHIFT 1
+B43legacy_DMA32_TXADDREXT_SHIFT 16
+B43legacy_TX4_MAC_KEYALG_SHIFT 16
+B43legacy_TX4_MAC_KEYIDX_SHIFT 20
+B43_NPHY_BPHY_CTL3_SCALE_SHIFT 0
+B43_NPHY_C1_INITGAIN_HPVGA2_SHIFT 7
+B43_NPHY_C1_MINGAIN_SHIFT 0
+B43_NPHY_C2_INITGAIN_HPVGA2_SHIFT 7
+B43_NPHY_C2_MINGAIN_SHIFT 0
+B43_NPHY_OVER_DGAIN_CCKDGECV_SHIFT 8
+B43_NPHY_RFCTL_CMD_CORESEL_SHIFT 3
+B43_NPHY_RFSEQCA_RXDIS_SHIFT 12
+B43_NPHY_RFSEQCA_RXEN_SHIFT 4
+B43_NPHY_TXPCTL_ITSSI_0_SHIFT 0
+B43_NPHY_TXPCTL_ITSSI_1_SHIFT 8
+B43_NPHY_TXPCTL_N_NPTIL2_SHIFT 8
+B43_NPHY_TXPCTL_N_TSSID_SHIFT 0
+B43_NPHY_TXPCTL_TPWR_0_SHIFT 0
+B43_NPHY_TXPCTL_TPWR_1_SHIFT 8
+B43_PHY_BBANDCFG_RXANT_SHIFT 7
+B43_PHY_HT_TXPCTL_IDLE_TSSI2_C3_SHIFT 0
+B43_PHY_HT_TXPCTL_IDLE_TSSI_C1_SHIFT 0
+B43_PHY_HT_TXPCTL_IDLE_TSSI_C2_SHIFT 8
+B43_PHY_HT_TXPCTL_N_NPTIL2_SHIFT 8
+B43_PHY_HT_TXPCTL_TARG_PWR2_C3_SHIFT 0
+B43_PHY_HT_TXPCTL_TARG_PWR_C1_SHIFT 0
+B43_PHY_HT_TXPCTL_TARG_PWR_C2_SHIFT 8
+B43_TXH_MAC_KEYALG_SHIFT 16
+B43_TXH_MAC_KEYIDX_SHIFT 20
+B577XX_DOORBELL_HDR_CONN_TYPE_SHIFT 4
+B577XX_DOORBELL_HDR_DB_TYPE_SHIFT 1
+B577XX_DOORBELL_HDR_RX_SHIFT 0
+B577XX_FCOE_RX_DOORBELL_NEGATIVE_ARM_SHIFT 0
+B577XX_FCOE_RX_DOORBELL_OPCODE_SHIFT 5
+BBSHIFT 9
+BCD_EN_SHIFT 0
+BC_FLG_ACTIV 2
+BC_FLG_BUSY 3
+BCMA_CC_PMU15_PLL_PC0_FREQTGT_SHIFT 2
+BCMA_CC_PMU1_PLL0_PC0_P1DIV_SHIFT 20
+BCMA_CC_PMU1_PLL0_PC2_NDIV_INT_SHIFT 20
+BCMA_CC_PMU_CTL_RES_SHIFT 13
+BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF 23
+BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD 22
+BCMA_CORE_PCI_MDIODATA_REGADDR_SHF 18
+BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD 18
+BCMA_CORE_PCI_SPROM_PI_SHIFT 12
+BCN_TCFG_CW_SHIFT 8
+BCN_TCFG_IFS 0
+BDC_FLAG_VER_SHIFT 4
+BDI_async_congested 1
+BDINFO_FLAGS_MAXLEN_SHIFT 16
+BDI_registered 3
+B_DIRTY 2
+BDI_sync_congested 2
+BDI_writeback_running 4
+BEACON_BLINK_NEEDED 11
+BFI_MSIX_CT_MAX 9
+BFUSB_TX_WAKEUP 2
+BH_Delay 9
+BH_Dirty 1
+BH_JWrite 17
+BH_Lock 2
+BH_Mapped 5
+BH_New 6
+BH_NILFS_Node 17
+BH_Pinned 16
+BH_Quiet 13
+BH_Uptodate 0
+BIAS_MOD_LEVEL_SHIFT 8
+BICTCP_HZ 10
+BIO_BOUNCED 5
+BIO_CLONED 4
+BIO_EOF 2
+BIO_EOPNOTSUPP 7
+BIO_MAPPED_INTEGRITY 11
+BIO_NULL_MAPPED 8
+BIO_OWNS_VEC 13
+BIO_QUIET 10
+BIO_RESET_BITS 13
+BIO_SEG_VALID 3
+BIO_SNAP_STABLE 12
+BIO_UPTODATE 0
+BIO_USER_MAPPED 6
+BIT_AGGREGATION 3
+BITMAP_HOSTENDIAN 15
+BITMAP_IO 9
+BITMAP_STALE 1
+BITMAP_WRITE_ERROR 2
+BIT_MULTI_CS 0
+BIT_QOS 2
+BIT_WIMAX 1
+BLOCKACKPARAM_WINSIZE_POS 6
+Blocked 5
+BlockedBadBlocks 8
+BLOCK_FREED 2
+BLOCK_HASH_SHIFT 16
+BLOCK_NEEDS_FLUSH 4
+BLUE_IS_PULSE 4
+BLUE_LED 0
+BLUE_PULSE_LED 1
+BME_LOCKED 1
+BME_NO_WRITES 0
+BM_PAGE_HINT_WRITEOUT 27
+BM_PAGE_IO_ERROR 30
+BM_PAGE_LAZY_WRITEOUT 28
+BM_PAGE_NEED_WRITEOUT 29
+BM_RCTL_MO_SHIFT 3
+BNAD_RF_CEE_RUNNING 0
+BNAD_RF_DIM_TIMER_RUNNING 4
+BNAD_RF_MBOX_IRQ_DISABLED 2
+BNAD_RF_NETDEV_REGISTERED 3
+BNAD_RXQ_POST_OK 1
+BNAD_RXQ_STARTED 0
+BNAD_TXQ_TX_STARTED 1
+BNX2FC_CNIC_REGISTERED 1
+BNX2FC_CTLR_INIT_DONE 0
+BNX2FC_FLAG_CMD_LOST 12
+BNX2FC_FLAG_CTX_ALLOC_FAILURE 6
+BNX2FC_FLAG_DESTROY_CMPL 1
+BNX2FC_FLAG_DESTROYED 4
+BNX2FC_FLAG_DISABLED 3
+BNX2FC_FLAG_DISABLE_FAILED 9
+BNX2FC_FLAG_EH_ABORT 8
+BNX2FC_FLAG_ELS_TIMEOUT 11
+BNX2FC_FLAG_ENABLED 10
+BNX2FC_FLAG_FW_INIT_DONE 0
+BNX2FC_FLAG_IO_CLEANUP 6
+BNX2FC_FLAG_IO_COMPL 9
+BNX2FC_FLAG_ISSUE_ABTS 2
+BNX2FC_FLAG_ISSUE_RRQ 1
+BNX2FC_FLAG_OFFLOADED 2
+BNX2FC_FLAG_OFLD_REQ_CMPL 5
+BNX2FC_FLAG_RETIRE_OXID 7
+BNX2FC_FLAG_SESSION_READY 1
+BNX2FC_FLAG_SRR_SENT 13
+BNX2FC_FLAG_TM_COMPL 4
+BNX2FC_FLAG_TM_TIMEOUT 5
+BNX2FC_FLAG_UPLD_REQ_COMPL 7
+BNX2I_CNIC_REGISTERED 1
+BNX2I_NX2_DEV_5706 0
+BNX2I_NX2_DEV_5708 1
+BNX2I_NX2_DEV_5709 2
+BNX2I_NX2_DEV_57710 3
+BNX2_L2CTX_L2_STATUSB_NUM_SHIFT 24
+BNX2_PCICFG_INT_ACK_CMD_INT_NUM_SHIFT 24
+BNX2X_AFEX_FCOE_Q_UPDATE_PENDING 12
+BNX2X_AFEX_PENDING_VIFSET_MCP_ACK 13
+BNX2X_DB_SHIFT 7
+BNX2X_DONT_CONSUME_CAM_CREDIT 4
+BNX2X_ETH_MAC 1
+BNX2X_FILTER_RX_MODE_PENDING 3
+BNX2X_FILTER_RX_MODE_SCHED 4
+BNX2X_PRI_FLAG_FCOE 1
+BNX2X_PRI_FLAG_ISCSI 0
+BNX2X_PRI_FLAG_STORAGE 2
+BNX2X_Q_TYPE_HAS_RX 0
+BNX2X_Q_TYPE_HAS_TX 1
+BNX2X_SP_RTNL_AFEX_F_UPDATE 3
+BNX2X_SP_RTNL_ENABLE_SRIOV 4
+BNX2X_SP_RTNL_FAN_FAILURE 2
+BNX2X_SP_RTNL_HYPERVISOR_VLAN 8
+BNX2X_SP_RTNL_TX_TIMEOUT 1
+BNX2X_SP_RTNL_VFPF_CHANNEL_DOWN 6
+BNX2X_SP_RTNL_VFPF_MCAST 5
+BNX2X_SP_RTNL_VFPF_STORM_RX_MODE 7
+BNX2X_VF_CID_WND 0
+BOOST_DPM_LEVEL 7
+BPP_TUNED18_SHIFT_8411 4
+BP_VECTOR 3
+BRCMF_FWS_FIFO_AC_BE 1
+BRCMF_P2P_STATUS_ACTION_TX_COMPLETED 6
+BRCMF_P2P_STATUS_ACTION_TX_NOACK 7
+BRCMF_P2P_STATUS_DISCOVER_LISTEN 9
+BRCMF_P2P_STATUS_ENABLED 0
+BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL 13
+BRCMF_P2P_STATUS_GO_NEG_PHASE 8
+BRCMF_P2P_STATUS_SENDING_ACT_FRAME 10
+BRCMF_P2P_STATUS_WAITING_NEXT_ACT_FRAME 12
+BRCMF_P2P_STATUS_WAITING_NEXT_AF_LISTEN 11
+BRCMF_SCAN_STATUS_ABORT 1
+BRCMF_SCAN_STATUS_BUSY 0
+BRCMF_SCAN_STATUS_SUPPRESS 2
+BRCMF_VIF_STATUS_AP_CREATED 5
+BRCMF_VIF_STATUS_AP_CREATING 4
+BRCMF_VIF_STATUS_CONNECTED 2
+BRCMF_VIF_STATUS_CONNECTING 1
+BRCMF_VIF_STATUS_READY 0
+B_READING 0
+BR_PORT_BITS 10
+B_RS_H_DONE 20
+BSG_F_BLOCK 1
+BS_READABLE 1
+BS_WRITABLE 2
+BTN_A 304
+BTN_DEAD 303
+BTN_EXTRA 276
+BTN_LEFT 272
+BTN_MIDDLE 274
+BTN_RIGHT 273
+BTN_SIDE 275
+BTN_TOOL_DOUBLETAP 333
+BTN_TOOL_FINGER 325
+BTN_TOOL_QUADTAP 335
+BTN_TOOL_TRIPLETAP 334
+BTN_TOUCH 330
+BT_OP_PRIORITY_DETECTED 0
+BT_OP_SCAN 1
+BTRFS_FS_STATE_ERROR 0
+BTRFS_FS_STATE_REMOUNTING 1
+BTRFS_INODE_COPY_EVERYTHING 8
+BTRFS_INODE_DELALLOC_META_RESERVED 4
+BTRFS_INODE_DUMMY 2
+BTRFS_INODE_HAS_ASYNC_EXTENT 6
+BTRFS_INODE_HAS_ORPHAN_ITEM 5
+BTRFS_INODE_IN_DEFRAG 3
+BTRFS_INODE_IN_DELALLOC_LIST 9
+BTRFS_INODE_NEEDS_FULL_SYNC 7
+BTRFS_INODE_ORDERED_DATA_CLOSE 0
+BTRFS_ORDERED_COMPLETE 1
+BTRFS_ORDERED_DIRECT 5
+BTRFS_ORDERED_IOERR 6
+BTRFS_ORDERED_UPDATED_ISIZE 7
+BTRFS_STRIPE_HASH_TABLE_BITS 11
+BTR_SJW_SHIFT 6
+BTR_TSEG1_SHIFT 8
+BTR_TSEG2_SHIFT 12
+BT_SK_DEFER_SETUP 0
+BT_SK_SUSPEND 1
+BTUSB_BULK_RUNNING 1
+BTUSB_DID_ISO_RESUME 4
+BTUSB_SUSPENDING 3
+BUFFER_EMPTY 6
+BUFFER_FLUSH 7
+BUFFER_FULL 7
+BUFFERING_RX 2
+BUFF_FLAGS_OFFSET 24
+BurstLenShift 8
+BUS_CNTL1_MOBILE_PLATFORM_SEL_SHIFT 26
+BUS_WIDTH 0
+BUSWIDTH 1
+BYTE_SHIFT 3
+CACHE_CLEANED 3
+CACHEFILES_DEAD 1
+CACHEFILES_READY 0
+CACHE_NEGATIVE 1
+CACHE_SET_STOPPING_2 2
+CACHE_SET_UNREGISTERING 0
+CACHE_VALID 0
+CALIB_FRAC_BITS 10
+CALLBACK_PENDING 11
+CALShift 14
+CAM_CTRL_INDEX_SHIFT 16
+CAM_OUT_CQ_ID_SHIFT 5
+CAM_OUT_FUNC_SHIFT 2
+CANCEL_DC_I_SHIFT 5
+CANCEL_DC_Q_SHIFT 0
+CAN_SFF_ID_BITS 11
+CAPTURE_URB_COMPLETED 6
+CARD_HAS_ACTIVITY_LED 6
+CARD_HAS_PCCARD_ID 4
+CARD_HAS_POWER_LED 5
+CARD_READY 1
+CARL9170_TX_SUPER_AMPDU_DENSITY_S 0
+CARL9170_TX_SUPER_AMPDU_FACTOR_S 3
+CARL9170_TX_SUPER_RI_ERP_PROT_S 3
+CB710_MMC_CMD_CODE_SHIFT 8
+CDC_DCMD_ID_SHIFT 16
+CDC_DCMD_IF_SHIFT 12
+CEPH_BLOCK_SHIFT 22
+CF_CLOSE 6
+CF_CONFIG_NEEDED 1
+CF_CONFIG_NEEDED 4
+CF_CONNECTED 1
+CF_DMA_ACTIVE 3
+CFG_CHARGE_CURRENT_FCC_SHIFT 5
+CFG_CHARGE_CURRENT_PCC_SHIFT 3
+CFG_CURRENT_LIMIT_DC_SHIFT 4
+CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT 6
+CFG_OTG_CC_COMPENSATION_SHIFT 6
+CFG_OTG_TEMP_THRESHOLD_SHIFT 4
+CFG_Q_SHIFT 8
+CFGR_BLV_SHIFT 3
+CFG_TEMP_LIMIT_HARD_COLD_SHIFT 6
+CFG_TEMP_LIMIT_HARD_HOT_SHIFT 4
+CFG_TEMP_LIMIT_SOFT_COLD_SHIFT 2
+CFG_TEMP_LIMIT_SOFT_HOT_SHIFT 0
+CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT 2
+CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT 0
+CFHSI_AWAKE 3
+CFHSI_FLUSH_FIFO 6
+CFHSI_SHUTDOWN 5
+CFHSI_WAKE_DOWN_ACK 2
+CFHSI_WAKE_UP_ACK 1
+CF_IS_OTHERCON 5
+CFPREP_CBI_SHIFT 6
+CFQ_SERVICE_SHIFT 12
+CF_SG_RESTART 6
+CF_SINGLE_BUFFER 5
+CF_WRITE_PENDING 2
+CGRP_CPUSET_CLONE_CHILDREN 3
+CGRP_DEAD 0
+CGRP_NOTIFY_ON_RELEASE 2
+CGRP_RELEASABLE 1
+CH7017_LOOP_FILTER_SHIFT 5
+CH7017_LVDS_PLL_FEED_BACK_DIVIDER_SHIFT 4
+CH7017_LVDS_PLL_FEED_FORWARD_DIVIDER_SHIFT 0
+CH7017_LVDS_PLL_POST_SCALE_DIV_SHIFT 0
+CH7017_LVDS_PLL_VCO_SHIFT 4
+CH7017_PHASE_DETECTOR_SHIFT 0
+CHANNEL_ABORT 2
+CHANNEL_CLEAR_INTERRUPT 3
+CHANNEL_DONE 4
+CHANNEL_DOWN 2
+CHANNEL_ENABLE 0
+CHANNEL_START 1
+CHIP_RESET 3
+CHIP_SELECT_BIT12 12
+CHUNK_SHIFT 6
+CISTPL_POWER_VNOM 0
+CLEAN_LIST_BUSY_BIT 0
+CLEAN_SHUTDOWN 0
+CLEAR_BSSFILTER_ON_BEACON 5
+CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE 3
+CLEAR_ENDPOINT_HALT 0
+CLEAR_ENDPOINT_TOGGLE 1
+CLEAR_EP_FORCE_CRC_ERROR 5
+CLEAR_EP_HIDE_STATUS_PHASE 6
+CLEAR_INTERRUPT_MODE 4
+CLEAR_NAK_OUT_PACKETS 7
+CLEAR_NAK_OUT_PACKETS_MODE 2
+CLK_27M_MCLK_SHIFT 3
+CLK312_EN_LBN 3
+CLK_32K_SR_SHIFT 4
+CLKDIV_IN_SHIFT 6
+CLKOUT_SL_SHIFT 4
+CLK_PWRMGT_CNTL__ACTIVE_HILO_LAT__SHIFT 13
+CLK_RATIO_SHIFT 1
+CLK_SPEED_SHIFT 5
+CLOCK_SELECT_SHIFT 4
+CLOSE_SENT 3
+CLOSE_UPCALL 8
+CL_SEL_POS 1
+CL_ST_CHG_FAIL 4
+CL_ST_CHG_SUCCESS 3
+CMA_OPTION_AFONLY 0
+CM_ASFC_SHIFT 10
+CM_CH0FMT_SHIFT 0
+CM_CH1FMT_SHIFT 2
+CMDQ_STAT_LAST_PKT_DB 2
+CMDQ_STAT_RUNNING 1
+CM_DSFC_SHIFT 13
+CMTP_LOOPBACK 0
+CNF1_SJW_SHIFT 6
+CNF2_PS1_SHIFT 3
+CNIC_F_BNX2_CLASS 3
+CNIC_F_BNX2X_CLASS 4
+CNIC_F_CNIC_UP 1
+CNIC_LCL_FL_KWQ_INIT 0
+CNIC_LCL_FL_L2_WAIT 1
+CNIC_LCL_FL_RINGS_INITED 2
+CNIC_LCL_FL_STOP_ISCSI 4
+COMMANDII_RANGE_SHIFT 0
+COMMANDII_RESOLUTION_SHIFT 2
+COMMANDII_SCHEME_SHIFT 7
+COMMMAND1_OPMODE_SHIFT 5
+CONF_CONNECT_PEND 5
+CONF_EWS_RECV 8
+CONFIG_CHANNEL_HT40 6
+CONFIG_HT_DISABLED 8
+CONFIG_POWERSAVING 7
+CONFIG_QOS_DISABLED 9
+CONFIGURE_PROX_SLP_SH 4
+CONFIG_WIZNET_BUS_SHIFT 0
+CONF_INPUT_DONE 1
+CONF_LOC_CONF_PEND 9
+CONF_MODE_DONE 4
+CONF_MTU_DONE 3
+CONF_NOT_COMPLETE 11
+CONF_OUTPUT_DONE 2
+CONF_RECV_NO_FCS 6
+CONF_REM_CONF_PEND 10
+CONF_REQ_SENT 0
+CONF_STATE2_DEVICE 7
+CONN_DRY_RUN 8
+CONNECTED 0
+CONNECT_PEND 1
+CONN_LOCAL_BUSY 5
+CONN_REJ_ACT 6
+CONN_REMOTE_BUSY 4
+CONNREQ_UPCALL 14
+CONN_RNR_SENT 8
+CONN_RPL_UPCALL 19
+CONN_SEND_FBIT 7
+CONN_SREJ_ACT 2
+CONN_WD_ST_CHG_FAIL 7
+CONN_WD_ST_CHG_OKAY 6
+CONN_WD_ST_CHG_REQ 5
+CONSIDER_RESYNC 6
+CONTROL_INV_TIMEOUT 5
+CONTROL_SHIFT 6
+CONTROL_STATUS_INTERRUPT 1
+CONTROL_STATUS_INTERRUPT 6
+CONTROL_STATUS_PHASE_HANDSHAKE 3
+COOKIEBITS 24
+COUNTER_SHIFT 16
+CPHY_SATA_DPLL_SHIFT 8
+CPL_RX_DDP_STATUS_DCRC_SHIFT 21
+CPL_RX_DDP_STATUS_DDP_SHIFT 16
+CPL_RX_DDP_STATUS_HCRC_SHIFT 20
+CPL_RX_DDP_STATUS_PAD_SHIFT 19
+cpuset_subsys_id 0
+CRASHED_PRIMARY 5
+CR_MAXPEXP 4
+CRQB_CMD_ADDR_SHIFT 8
+CRQB_HOSTQ_SHIFT 17
+CRQB_PMP_SHIFT 12
+CRQB_TAG_SHIFT 1
+CRVML_CLOCK_SHIFT 8
+CS2000_LOCK_CLK_SHIFT 1
+CS2000_R_SEL_SHIFT 3
+CS42L52_BEEP_RATE_SHIFT 4
+CS42L52_CHARGE_PUMP_SHIFT 4
+CS42L52_MIC_CTL_MIC_SEL_SHIFT 6
+CS42L52_MIC_CTL_TYPE_SHIFT 5
+CS_ONLINE 0
+CS_SCHED_LOAD_BALANCE 5
+CS_SPREAD_PAGE 6
+CS_SPREAD_SLAB 7
+CTL_A_GAIN_SHIFT 28
+CTL_A_SEL_SHIFT 24
+CTL_DA_SDR_SHIFT 8
+CTL_SLEW_SHIFT 4
+CT_PAGE_SHIFT 12
+CTRL_BITPOS_A 30
+CTRL_BITPOS_DESCLIMIT 18
+CTRL_BITPOS_FIFOINDEXMASK 4
+CTRL_BITPOS_G 31
+CTRL_BITPOS_L2SZ 0
+CTX_FL_CID_ERROR 2
+CTX_FL_DELETE_WAIT 1
+CTX_FL_OFFLD_START 0
+CURSOR_A_FIFO_WM_SHIFT 8
+CURSOR_B_FIFO_WM1_SHIFT 8
+CURSOR_B_FIFO_WM_SHIFT 16
+CURSOR_FIFO_SR_WM1_SHIFT 0
+CURSOR_X_SHIFT 0
+CURSOR_Y_SHIFT 16
+CX18_F_I_EOS 4
+CX18_F_I_FAILED 22
+CX18_F_I_LOADED_FW 0
+CX18_F_I_RADIO_USER 5
+CX18_F_M_NEED_SWAP 0
+CX18_F_S_APPL_IO 8
+CX18_F_S_CLAIMED 3
+CX18_F_S_INTERNAL_USE 5
+CX18_F_S_STOPPING 9
+CX18_F_S_STREAMING 4
+CX20442_AGC 4
+CX20442_MIC 2
+CX20442_SPKOUT 3
+CX20442_TELIN 0
+CX20442_TELOUT 1
+CX23885_IR_RX_END_OF_RX_DETECTED 1
+CX23885_IR_RX_FIFO_SERVICE_REQ 0
+CX23885_IR_RX_HW_FIFO_OVERRUN 2
+CX23885_IR_RX_SW_FIFO_OVERRUN 3
+CX23885_IR_TX_FIFO_SERVICE_REQ 0
+CYC2NS_SCALE_FACTOR 10
+D64_CTRL2_AE_SHIFT 16
+D64_RC_AE_SHIFT 16
+D64_RC_RO_SHIFT 1
+D64_XC_AE_SHIFT 16
+DA7213_DMIC_CLK_RATE_SHIFT 2
+DA7213_DMIC_DATA_SEL_SHIFT 0
+DA7213_DMIC_SAMPLEPHASE_SHIFT 1
+DA7213_MICBIAS1_LEVEL_SHIFT 0
+DA7213_MICBIAS2_LEVEL_SHIFT 4
+DA732X_HP_DAC_COMPO_SHIFT 3
+DA9052_GPIO_EVEN_SHIFT 3
+DA9052_GPIO_NIBBLE_SHIFT 4
+DA9052_GPIO_ODD_SHIFT 7
+DA9052_NIBBLE_SHIFT 4
+DA9055_E_GPI_SHIFT 1
+DA9055_RTC_MODE_SD_SHIFT 1
+DA9055_TWDSCALE_SHIFT 4
+DA9055_V_GPI_SHIFT 5
+DAC960_BlockSizeBits 9
+DAC960_MaxPartitionsBits 3
+DAC_CTRL_ONDACL 4
+DAC_CTRL_ONDACR 5
+DAC_CTRL_ONLNOL 2
+DAC_CTRL_ONLNOR 3
+DAC_FORCE_DATA_SHIFT 8
+DACK_POLARITY 2
+DAC_PRECH_ONMSTR 0
+DATA_IN_TOKEN_INTERRUPT 0
+DATA_IN_TOKEN_INTERRUPT_ENABLE 0
+DATA_OUT_PING_TOKEN_INTERRUPT 1
+DATA_OUT_TOKEN_INTERRUPT 1
+DATA_OUT_TOKEN_INTERRUPT_ENABLE 1
+DATA_PACKET_RECEIVED_INTERRUPT 3
+DATA_PACKET_RECEIVED_INTERRUPT_ENABLE 3
+DATA_PACKET_TRANSMITTED_INTERRUPT 2
+DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE 2
+DATA_WIDTH 0
+DB_DEF_PDU_CQPROC_SHIFT 16
+DB_DEF_PDU_EVENT_SHIFT 15
+DB_DEF_PDU_NUM_POSTED_SHIFT 24
+DB_DEF_PDU_REARM_SHIFT 14
+DB_DEF_PDU_WRB_INDEX_SHIFT 16
+DB_MCCQ_NUM_POSTED_SHIFT 16
+DB_RESET 26
+DB_VECTOR 1
+DCB_OUTPUT_ANALOG 0
+DCB_OUTPUT_DP 6
+DCB_OUTPUT_LVDS 3
+DCB_OUTPUT_TMDS 2
+DCB_OUTPUT_TV 1
+DCBX_CEE_VERSION_SHIFT 12
+DC_GCFG_DFHPEL_POS 12
+DC_GCFG_DFHPSL_POS 8
+DC_GENERAL_CFG_DFHPEL_SHIFT 12
+DC_GENERAL_CFG_DFHPSL_SHIFT 8
+DDS_ENT_AMP_LSB 14
+DDS_ENT_MAIN_LSB 9
+DDS_ENT_POST_LSB 5
+DDS_ENT_PRE_LSB 0
+DEBUG_SHIFT 0
+DE_HAVE_BARRIER_NUMBER 0
+DELAYED_UPDATE_BEACON 0
+DEMAND_MODE 12
+DESTROY_IN_PROGRESS 4
+DEST_SHIFT 24
+DEVCTRL_RTC_PWDN_SHIFT 6
+DEV_ENTRY_MODE_SHIFT 9
+DEVICE_CTRL_MAXRRS_MIN 2
+DEVICE_REMOTE_WAKEUP_ENABLE 1
+DEVICE_SET_CLEAR_DEVICE_REMOTE_WAKEUP 11
+DEVICE_STATE_ENABLED_RADIO 4
+DEVICE_STATE_INITIALIZED 2
+DEVICE_STATE_PRESENT 0
+DEVICE_STATE_REGISTERED_HW 1
+DEVICE_STATE_SCANNING 5
+DEVICE_STATE_STARTED 3
+devnum 1
+DF_BOOT_TGT 1
+DFL_BLOCK_LOCKS 0
+DFL_DLM_RECOVERY 6
+DFL_FIRST_MOUNT 2
+DFL_FIRST_MOUNT_DONE 3
+DFL_MOUNT_DONE 4
+DFL_NO_DLM_OPS 1
+DFL_UNMOUNT 5
+DF_RELOGIN 0
+DIRECTION_OF_TRANSFER 3
+DIRECT_LOOKUP_SHIFT 5
+DISCARD_MY_DATA 21
+DISCE_REVALIDATE_DOMAIN 1
+DISCONNECTED 0
+DISCONNECTED 8
+DISCONNECT_SENT 12
+DISCONN_UPCALL 16
+DLC_RTR_SHIFT 6
+DLM_PROC_FLAGS_CLOSING 1
+DLM_PROC_FLAGS_COMPAT 2
+DMA_ABORT 1
+DMA_BUFFER_VALID 7
+DMA_BURST_SHIFT 24
+DMA_BUS_MODE_PBL_SHIFT 8
+DMA_BUS_MODE_RPBL_SHIFT 17
+DMA_CFG_DESC_TX_0_QID_POS 16
+DMA_CHANNEL_INTERRUPT_SELECT 17
+DMA_CONTROL_DACK 4
+DMA_CTL_DACK 6
+DMA_CTRL_DMAR_BURST_LEN_SHIFT 4
+DMA_CTRL_DMAR_DLY_CNT_SHIFT 11
+DMA_CTRL_DMAW_BURST_LEN_SHIFT 7
+DMA_CTRL_DMAW_DLY_CNT_SHIFT 16
+DMA_DIRECTION 30
+DMA_DONE_INTERRUPT 6
+DMA_DONE_INTERRUPT_ENABLE 29
+DMA_DONE_INTERRUPT_ENABLE 6
+DMAE_CMD_E1HVN_SHIFT 15
+DMAE_COMMAND_C_DST_SHIFT 3
+DMAE_COMMAND_C_FUNC_SHIFT 19
+DMAE_COMMAND_DST_SHIFT 1
+DMAE_COMMAND_DST_VFID_SHIFT 8
+DMAE_COMMAND_DST_VFPF_SHIFT 14
+DMAE_COMMAND_DST_VN_SHIFT 17
+DMAE_COMMAND_ERR_POLICY_SHIFT 20
+DMAE_COMMAND_SRC_SHIFT 0
+DMAE_COMMAND_SRC_VFID_SHIFT 0
+DMAE_COMMAND_SRC_VFPF_SHIFT 6
+DMA_ENABLE 1
+DMA_ENDPOINT_SELECT 0
+DMA_EOT_ENABLE 14
+DMA_FIFO_VALIDATE 2
+DMA_MEMORY_WRITE_AND_INVALIDATE_ENABLE 10
+DMA_MODE 0
+DMA_READ_LINE_ENABLE 8
+DMA_READ_MULTIPLE_ENABLE 9
+DMA_REQUEST 6
+DMA_REQUEST_ENABLE 5
+DMAR_IQ_SHIFT 4
+DMA_RWCTRL_PCI_READ_CMD_SHIFT 24
+DMA_RWCTRL_PCI_WRITE_CMD_SHIFT 28
+DMA_RWCTRL_READ_WATER_SHIFT 16
+DMA_RWCTRL_WRITE_WATER_SHIFT 19
+DMARX_CTRL_ROSHIFT 1
+DMA_SCATTER_GATHER_DONE_INTERRUPT 25
+DMA_START 0
+DMA_TIMEOUT_ENABLE 5
+DMA_TRANSACTION_DONE_INTERRUPT 24
+DM_BUFIO_HASH_BITS 20
+DM_CRYPT_KEY_VALID 1
+DM_CRYPT_SUSPENDED 0
+DMF_BLOCK_IO_FOR_SUSPEND 0
+DMF_DELETING 4
+DMF_FREEING 3
+DMF_FROZEN 2
+DMF_MERGE_IS_OPTIONAL 6
+DMF_NOFLUSH_SUSPENDING 5
+DMF_SUSPENDED 1
+DM_KCOPYD_IGNORE_ERROR 1
+DOC_ADDR_BLOCK_SHIFT 6
+DONE_INTERRUPT_ENABLE 10
+DOORBELL_FROM_CARD_RX 4
+DPC_AEN 9
+DPC_GET_DHCP_IP_ADDR 15
+DPC_HA_NEED_QUIESCENT 22
+DPC_HA_UNRECOVERABLE 21
+DPC_LINK_CHANGED 18
+DPC_POST_IDC_ACK 23
+DPC_RELOGIN_DEVICE 3
+DPC_RESET_ACTIVE 20
+DPC_RESET_HA 1
+DPC_RESET_HA_FW_CONTEXT 4
+DPC_RESET_HA_INTR 5
+DPC_RETRY_RESET_HA 2
+DPLL_FPA01_P1_POST_DIV_SHIFT 16
+DPLL_FPA01_P1_POST_DIV_SHIFT_PINEVIEW 15
+DPLL_FPA1_P1_POST_DIV_SHIFT 0
+DPLL_MD_UDI_MULTIPLIER_SHIFT 8
+DP_TRAIN_PRE_EMPHASIS_SHIFT 3
+DP_TRAIN_VOLTAGE_SWING_SHIFT 0
+DQ_ACTIVE_B 5
+DQ_FAKE_B 3
+DQF_INFO_DIRTY_B 31
+DQ_READ_B 4
+DREQ_POLARITY 1
+DRV_FLAGS_DCB_CONFIGURED 0
+DRV_FLAGS_DCB_MFW_CONFIGURED 2
+DS1621_REG_CONFIG_RESOL_SHIFT 2
+DSP_DBGCNTL_EXEC_LOBIT 0
+DSP_DBGCNTL_SS_LOBIT 4
+DSPDMAC_DMACFG_AINCR_LOBIT 18
+DSPDMAC_DMACFG_DBADR_LOBIT 0
+DSPDMAC_XFRCNT_BCNT_LOBIT 16
+DSPDMAC_XFRCNT_CCNT_LOBIT 0
+DSP_FIFO_SR_WM_SHIFT 23
+DSPFW_CURSOR_SR_SHIFT 24
+DSPFW_HPLL_CURSOR_SHIFT 16
+DSPFW_SR_SHIFT 23
+DSP_PLANE_A_FIFO_WM1_SHIFT 16
+DSP_PLANE_B_FIFO_WM1_SHIFT 24
+DSP_PLANE_C_FIFO_WM_SHIFT 0
+DTE_GCR3_SHIFT_A 58
+DTE_GCR3_SHIFT_B 16
+DTE_GCR3_SHIFT_C 43
+DTIM_EXPIRED 4
+DTIM_PERIOD_AVAIL 6
+E1000_ADVTXD_L4LEN_SHIFT 8
+E1000_ADVTXD_MACLEN_SHIFT 9
+E1000_ADVTXD_MSS_SHIFT 16
+E1000_ADVTXD_PAYLEN_SHIFT 14
+E1000_COLD_SHIFT 12
+E1000_CT_SHIFT 4
+E1000_DMACR_DMACTHR_SHIFT 16
+__E1000_DOWN 2
+__E1000_DOWN 3
+E1000_FCRTC_RTH_COAL_SHIFT 4
+E1000_FWSM_MODE_SHIFT 1
+E1000_GEN_CTL_ADDRESS_SHIFT 8
+E1000_I2CCMD_PHY_ADDR_SHIFT 24
+E1000_I2CCMD_REG_ADDR_SHIFT 16
+E1000_KMRNCTRLSTA_OFFSET_SHIFT 16
+E1000_LEDCTL_LED0_MODE_SHIFT 0
+E1000_LTRV_NOSNOOP_SHIFT 16
+E1000_LTRV_REQ_SHIFT 15
+E1000_MDIC_PHY_SHIFT 21
+E1000_MDIC_REG_SHIFT 16
+E1000_NVM_RW_ADDR_SHIFT 2
+E1000_NVM_RW_REG_DATA 16
+E1000_PBA_BYTES_SHIFT 10
+E1000_PSRCTL_BSIZE2_SHIFT 6
+E1000_PSRCTL_BSIZE3_SHIFT 14
+E1000_RCTL_MO_SHIFT 12
+E1000_RTTBCNRC_RF_INT_SHIFT 14
+E1000_SRRCTL_BSIZEHDRSIZE_SHIFT 2
+__E1000_TESTING 0
+E1000_TIMINCA_INCPERIOD_SHIFT 24
+E1000_TIPG_IPGR1_SHIFT 10
+E1000_TIPG_IPGR2_SHIFT 20
+E1000_TX_FLAGS_VLAN_SHIFT 16
+E1000_TX_HEAD_ADDR_SHIFT 7
+E1000_VT_CTL_DEFAULT_POOL_SHIFT 7
+E1000_VT_MSGINFO_SHIFT 16
+EBLOCK_IDX_SHIFT 5
+EC_FLAGS_BLOCKED 3
+EC_FLAGS_GPE_STORM 1
+EC_FLAGS_HANDLERS_INSTALLED 2
+EC_FLAGS_QUERY_PENDING 0
+EDMA_REQ_Q_PTR_SHIFT 5
+EDMA_RSP_Q_PTR_SHIFT 3
+EEPROM_CTRL_ADDR_SHIFT 16
+__EE_WAS_ERROR 3
+EFI_64BIT 5
+EFI_BOOT 0
+EFI_CONFIG_TABLES 2
+EFI_MEMMAP 4
+EFI_PAGE_SHIFT 12
+EFI_RUNTIME_SERVICES 3
+EFI_SYSTEM_TABLES 1
+EFS_DIRBSIZE_BITS 9
+EFX_FILTER_INDEX_WIDTH 13
+EhnMIIdataShift 16
+EhnMIIpmdShift 6
+EhnMIIregShift 11
+EM28XX_SNAPSHOT_KEY 212
+EMAC_MDIO_MODE_CLOCK_CNT_BITSHIFT 16
+EMPTYWAIT 3
+Enabled 0
+END_OF_CHAIN 28
+ENDPOINT_0_INTERRUPT 0
+ENDPOINT_0_INTERRUPT_ENABLE 0
+ENDPOINT1 0
+ENDPOINT_BYTE_COUNT 16
+ENDPOINT_DIRECTION 4
+ENDPOINT_ENABLE 10
+ENDPOINT_ENABLE 7
+ENDPOINT_HALT 0
+ENDPOINT_NUMBER 0
+ENDPOINT_TOGGLE 1
+ENET_SERDES_CTRL_EMPH_0_SHIFT 4
+ENET_SERDES_CTRL_EMPH_1_SHIFT 7
+ENET_SERDES_CTRL_EMPH_2_SHIFT 10
+ENET_SERDES_CTRL_EMPH_3_SHIFT 13
+ENET_SERDES_CTRL_LADJ_0_SHIFT 16
+ENET_SERDES_CTRL_LADJ_1_SHIFT 19
+ENET_SERDES_CTRL_LADJ_2_SHIFT 22
+ENET_SERDES_CTRL_LADJ_3_SHIFT 25
+ENET_SERDES_TEST_MD_0_SHIFT 0
+ENET_SERDES_TEST_MD_1_SHIFT 2
+ENET_SERDES_TEST_MD_2_SHIFT 4
+ENET_SERDES_TEST_MD_3_SHIFT 6
+ENTRY_BITPOS_DESCRIPTOR 10
+ENTRY_BITPOS_QWORDS 0
+ENTRY_DATA_IO_FAILED 3
+ENTRY_DATA_PENDING 2
+ENTRY_DATA_STATUS_PENDING 4
+ENTRY_DATA_STATUS_SET 5
+ENTRY_OWNER_DEVICE_DATA 1
+EOT_POLARITY 3
+EP_DISC_ABORT 18
+EP_DISC_CLOSE 17
+EP_FLAG_RUNNING 1
+EP_FLAG_STOPPING 2
+EPLD_DMA_ENABLE 7
+EP_QUEUE_HEAD_MAX_PKT_LEN_POS 16
+EP_QUEUE_HEAD_MULT_POS 30
+ESD_USB2_TSEG1_SHIFT 16
+ESD_USB2_TSEG2_SHIFT 20
+ESPC_PIO_STAT_ADDR_SHIFT 8
+ESR_GLUE_CTRL0_BLTIME_SHIFT 24
+ESR_GLUE_CTRL0_SRATE_SHIFT 8
+ESR_GLUE_CTRL0_THCNT_SHIFT 0
+ESR_RXTX_CTRL_VMUXLO_SHIFT 22
+ESTAB_UPCALL 7
+ETH_CLASSIFY_CMD_HEADER_OPCODE_SHIFT 2
+ETH_TX_BD_FLAGS_VLAN_MODE_SHIFT 2
+ETH_TX_PARSE_2ND_BD_IP_HDR_LEN_OUTER_W_SHIFT 8
+ETH_TX_PARSE_2ND_BD_IP_HDR_TYPE_OUTER_SHIFT 4
+ETH_TX_PARSE_2ND_BD_LLC_SNAP_EN_SHIFT 5
+ETH_TX_PARSE_BD_E1X_ETH_ADDR_TYPE_SHIFT 4
+ETH_TX_PARSE_BD_E2_ETH_ADDR_TYPE_SHIFT 30
+ETH_TX_PARSE_BD_E2_L4_HDR_START_OFFSET_W_SHIFT 0
+ETH_TX_PARSE_BD_E2_LSO_MSS_SHIFT 16
+ETH_TX_PARSE_BD_E2_TCP_HDR_LENGTH_DW_SHIFT 11
+ETH_TX_START_BD_HDR_NBDS_SHIFT 0
+ET_MAC_CFG2_PREAMBLE_SHIFT 12
+ET_MAC_STATION_ADDR1_OC4_SHIFT 8
+ET_MAC_STATION_ADDR1_OC5_SHIFT 16
+ET_MAC_STATION_ADDR1_OC6_SHIFT 24
+ET_MAC_STATION_ADDR2_OC1_SHIFT 16
+ET_MAC_STATION_ADDR2_OC2_SHIFT 24
+ET_RX_PFCTRL_MIN_PKT_SZ_SHIFT 16
+ET_RX_UNI_PF_ADDR1_1_SHIFT 8
+ET_RX_UNI_PF_ADDR1_3_SHIFT 24
+ET_RX_UNI_PF_ADDR1_4_SHIFT 16
+ET_RX_UNI_PF_ADDR1_5_SHIFT 8
+ET_RX_UNI_PF_ADDR2_1_SHIFT 24
+ET_RX_UNI_PF_ADDR2_2_SHIFT 16
+ET_RX_UNI_PF_ADDR2_3_SHIFT 24
+ET_RX_UNI_PF_ADDR2_4_SHIFT 16
+ET_RX_UNI_PF_ADDR2_5_SHIFT 8
+ET_RX_WOL_HI_SA1_SHIFT 8
+ET_RX_WOL_LO_SA3_SHIFT 24
+ET_RX_WOL_LO_SA4_SHIFT 16
+ET_RX_WOL_LO_SA5_SHIFT 8
+ET_TXDMA_CACHE_SHIFT 4
+EV_ABS 3
+EVENT_DEV_ASLEEP 6
+EVENT_DEV_OPEN 7
+EVENT_NO_RUNTIME_PM 9
+EVENT_RX_KILL 10
+EVENT_RX_PAUSED 5
+EVENT_STS_SPLIT 3
+EV_KEY 1
+EV_LED 17
+EV_MSC 4
+EV_REL 2
+EV_REP 20
+EV_SW 5
+EV_SYN 0
+EXHCH_HSIZE_SHIFT 0
+EXHCH_VSIZE_SHIFT 2
+EXT4_GROUP_INFO_NEED_INIT_BIT 0
+EXTENT_BUFFER_CORRUPT 3
+EXTENT_BUFFER_DUMMY 9
+EXTENT_BUFFER_IOERR 8
+EXTENT_BUFFER_READAHEAD 4
+EXTENT_BUFFER_STALE 6
+EXTENT_BUFFER_UPTODATE 0
+EXTENT_BUFFER_WRITEBACK 7
+EXTENT_FLAG_COMPRESSED 1
+EXTENT_FLAG_FILLING 5
+EXTENT_FLAG_LOGGING 4
+EXTENT_FLAG_PINNED 0
+EXTENT_FLAG_PREALLOC 3
+EXTENT_FLAG_VACANCY 2
+EXTIN_AC97_L 0
+EXTIN_AC97_R 1
+EXTIN_COAX_SPDIF_L 10
+EXTIN_COAX_SPDIF_R 11
+EXTIN_LINE1_L 8
+EXTIN_LINE1_R 9
+EXTIN_LINE2_L 12
+EXTIN_LINE2_R 13
+EXTIN_SPDIF_CD_L 2
+EXTIN_SPDIF_CD_R 3
+EXTIN_TOSLINK_L 6
+EXTIN_TOSLINK_R 7
+EXTIN_ZOOM_L 4
+EXTIN_ZOOM_R 5
+EXTOUT_AC97_CENTER 4
+EXTOUT_AC97_L 0
+EXTOUT_AC97_LFE 5
+EXTOUT_AC97_R 1
+EXTOUT_AC97_REAR_L 13
+EXTOUT_AC97_REAR_R 14
+EXTOUT_HEADPHONE_L 6
+EXTOUT_HEADPHONE_R 7
+EXTOUT_MIC_CAP 12
+EXTOUT_REAR_L 8
+EXTOUT_REAR_R 9
+EXTOUT_TOSLINK_L 2
+EXTOUT_TOSLINK_R 3
+EXTRA_FLAGS 16
+FAM10H_MMIO_CONF_BASE_SHIFT 20
+FAM10H_MMIO_CONF_BUSRANGE_SHIFT 2
+FAST_SLOW_TERMINATE_MODE_SELECT 15
+FaultRecorded 7
+Faulty 0
+FCOE_CQE_TOGGLE_BIT_SHIFT 15
+FCOE_CTX_RESET_NEEDED 18
+FCOE_IOS_PER_CONNECTION_SHIFT 0
+FCOE_KWQE_CONN_ENABLE_DISABLE_PRIORITY_SHIFT 13
+FCOE_KWQE_CONN_ENABLE_DISABLE_VLAN_ID_SHIFT 0
+FCOE_KWQE_CONN_OFFLOAD3_B_CONF_REQ_SHIFT 3
+FCOE_KWQE_CONN_OFFLOAD3_B_CONT_INCR_SEQ_CNT_SHIFT 2
+FCOE_KWQE_CONN_OFFLOAD3_B_E_D_TOV_RES_SHIFT 1
+FCOE_KWQE_CONN_OFFLOAD3_B_REC_VALID_SHIFT 4
+FCOE_KWQE_CONN_OFFLOAD3_B_VLAN_FLAG_SHIFT 7
+FCOE_KWQE_CONN_OFFLOAD3_PRIORITY_SHIFT 13
+FCOE_KWQE_CONN_OFFLOAD3_VLAN_ID_SHIFT 0
+FCOE_KWQE_HEADER_LAYER_CODE_SHIFT 4
+FCOE_KWQE_INIT1_LOG_PAGE_SIZE_SHIFT 0
+FCOE_LOGINS_PER_PORT_SHIFT 16
+FCOE_NPIV_WWN_PER_PORT_SHIFT 16
+FCOE_NUMBER_OF_EXCHANGES_SHIFT 0
+FCOE_OUTSTANDING_COMMANDS_SHIFT 16
+FCOE_SQE_TASK_ID_SHIFT 0
+FCOE_SQE_TOGGLE_BIT_SHIFT 15
+FCOE_TARGETS_SUPPORTED_SHIFT 0
+FCOE_TCE_RX_WR_TX_RD_CONST_CID_SHIFT 0
+FCOE_TCE_RX_WR_TX_RD_VAR_EXP_FIRST_FRAME_SHIFT 12
+FCOE_TCE_TX_WR_RX_RD_CONST_CACHED_SGE_SHIFT 5
+FCOE_TCE_TX_WR_RX_RD_CONST_CLASS_TYPE_SHIFT 4
+FCOE_TCE_TX_WR_RX_RD_CONST_DEV_TYPE_SHIFT 3
+FCOE_TCE_TX_WR_RX_RD_CONST_TASK_TYPE_SHIFT 0
+FCOE_TCE_TX_WR_RX_RD_CONST_TX_STATE_SHIFT 1
+FCPORT_UPDATE_NEEDED 13
+FCRAM_REF_TMR_MAX_SHIFT 16
+FCRAM_REF_TMR_MIN_SHIFT 0
+FD_DISK_CHANGED_BIT 4
+FD_DISK_NEWCHANGE_BIT 2
+FD_DISK_WRITABLE_BIT 5
+FD_NEED_TWADDLE_BIT 0
+FD_VERIFY_BIT 1
+FF_AUTOCENTER 97
+FF_CONSTANT 82
+FF_CORE_SHOULD_PLAY 4
+FF_CORE_UPDATE 5
+FF_DAMPER 85
+FF_FRICTION 84
+FF_GAIN 96
+FF_INERTIA 86
+FFLP_CFG_1_CAMLAT_SHIFT 16
+FFLP_CFG_1_CAMRATIO_SHIFT 12
+FFLP_CFG_1_FCRAMRATIO_SHIFT 8
+FF_MOD1_IS_USED 0
+FF_MOD2_IS_USED 1
+FF_PERIODIC 81
+FF_RAMP 87
+FF_RUMBLE 80
+FF_SAW_DOWN 92
+FF_SAW_UP 91
+FF_SINE 90
+FF_SPRING 83
+FF_SQUARE 88
+FF_TRIANGLE 89
+FH_MEM_TFDIB_REG1_ADDR_BITSHIFT 28
+FIELD_SIZE 5
+FIFO_EMPTY 10
+FIFO_FLUSH 9
+FIFO_FULL 11
+FIFO_OVERFLOW 13
+FIFOSIZE_DEPTH_SHIFT 16
+FIFOSIZE_STARTADDR_SHIFT 0
+FIFO_SOFT_RESET 4
+FIFO_UNDERFLOW 12
+FIP_DT_MAC 2
+FIRST_BOOT 7
+FirstUse 10
+FLAG_802_11 7
+FLAG_ACTIVE_LOW 6
+FLAG_ADHOC 3
+FLAG_COMMIT 13
+FLAG_EFS_ENABLE 5
+FLAG_ENABLED 2
+FLAG_EXITING 0
+FLAG_EXPORT 2
+FLAG_EXT_CTRL 4
+FLAG_FLASHING 15
+FLAG_FLUSHABLE 3
+FLAG_FORCE_ACTIVE 1
+FLAG_FORCE_RELIABLE 2
+FLAG_IRQ_ENABLE 1
+FLAG_IS_OUT 1
+FLAG_MIC_CAPABLE 4
+FLAG_MPI 11
+FLAG_OPEN_DRAIN 7
+FLAG_OPEN_SOURCE 8
+FLAG_PENDING_XMIT11 10
+FLAG_PENDING_XMIT 9
+FLAG_RADIO_DOWN 1
+FLAG_RADIO_OFF 0
+FLAG_REGISTERED 12
+FLAG_RESET 14
+FLAG_ROLE_SWITCH 0
+FLAG_SYSFS 3
+FLAG_UPDATE_MULTI 5
+FLAG_UPDATE_UNI 6
+FLAG_VBUS_CHANGED 0
+FLAG_WPA_CAPABLE 16
+FLASH_SECTOR_ADDR_SHIFT 12
+FLG_ACTIVE 6
+FLG_HDLC 13
+FLG_L1_DBUSY 5
+FLG_L1_PULL_REQ 6
+FLG_TRANSPARENT 12
+FLIDX_ABORTING 2
+FLIDX_DISCONNECTING 3
+FLIDX_SG_ACTIVE 1
+FLIDX_TIMED_OUT 5
+FLIDX_URB_ACTIVE 0
+FLOW_KEY_L4_0_SHIFT 2
+FLOW_KEY_L4_1_SHIFT 0
+FLT_SHIFT 0
+FLW_PRT_SEL_BASE_SHIFT 0
+FLW_PRT_SEL_MASK_SHIFT 8
+FM801_AC97_ADDR_SHIFT 10
+FM801_RATE_SHIFT 8
+FM_AF_SWITCH_INPROGRESS 5
+FM_CORE_READY 3
+FM_CORE_TX_XMITING 6
+FM_FW_DW_INPROGRESS 2
+FM_INTTASK_RUNNING 0
+FM_INTTASK_SCHEDULE_PENDING 1
+FNIC_INTX_ERR 1
+FNIC_INTX_NOTIFY 2
+FNIC_INTX_WQ_RQ_COPYWQ 0
+FORCE_DETACH 14
+FORCE_FULL_SPEED_MODE 30
+FORCE_HIGH_SPEED 3
+FP_PT1_VSIZE_SHIFT 16
+FP_SHIFT 12
+FRAC_BITS 14
+FRAC_BITS 8
+FREQ_RATIO_OFFSET 19
+FS155_VCI_BITS 6
+FS155_VPI_BITS 4
+FSCACHE_COOKIE_LOOKING_UP 0
+FSCACHE_COOKIE_NO_DATA_YET 1
+FSCACHE_COOKIE_RELINQUISHED 4
+FSCACHE_COOKIE_RETIRED 5
+FSCACHE_COOKIE_UNAVAILABLE 2
+FSCACHE_OBJECT_EV_CLEARED 4
+FSCACHE_OBJECT_IS_AVAILABLE 5
+FSCACHE_OBJECT_IS_LIVE 3
+FSCACHE_OP_EXCLUSIVE 5
+FSCACHE_OP_UNUSE_COOKIE 7
+FSCACHE_OP_WAITING 4
+FSHIFT 11
+FTRACE_EVENT_FL_ENABLED_BIT 0
+FTRACE_EVENT_FL_RECORDED_CMD_BIT 1
+FTRACE_EVENT_FL_SOFT_DISABLED_BIT 3
+FTRACE_EVENT_FL_SOFT_MODE_BIT 2
+FULLNESS_BITS 4
+FULL_SPEED 6
+FUNC_MF_CFG_MAX_BW_SHIFT 24
+FUSE_I_ADVISE_RDPLUS 0
+FW_STATUS_ABORT 2
+FW_STATUS_DONE 1
+FW_STATUS_LOADING 0
+FX00_RESET_RECOVERY 25
+FX00_TARGET_SCAN 26
+GAIN_ALPHA 5
+GBF_FULL 1
+GDFIFOCFG_EPINFOBASE_SHIFT 16
+GEN6_BLITTER_LOCK_SHIFT 16
+GEN6_MBC_SNPCR_SHIFT 21
+GEN6_PCODE_FREQ_IA_RATIO_SHIFT 8
+GEN6_PCODE_FREQ_RING_RATIO_SHIFT 16
+GENERATE_RESUME 3
+GENERATE_RESUME 5
+GET_DEVICE_STATUS 0
+GET_INTERFACE_STATUS 1
+GI2CCTL_I2CDEVADDR_SHIFT 26
+GIF_ALLOC_FAILED 2
+GIF_INVALID 0
+GIF_QD_LOCKED 1
+GIF_SW_PAGED 3
+GLF_BLOCKING 15
+GLF_DEMOTE 3
+GLF_DEMOTE_IN_PROGRESS 5
+GLF_DIRTY 6
+GLF_FROZEN 11
+GLF_INITIAL 10
+GLF_INVALIDATE_IN_PROGRESS 8
+GLF_LFLUSH 7
+GLF_LRU 13
+GLF_QUEUED 12
+GLF_REPLY_PENDING 9
+GLOBAL_BEEP_ENABLE_SHIFT 15
+GMAC_FLOW_CTRL_PT_SHIFT 16
+GMBUS_SLAVE_INDEX_SHIFT 8
+GMCR_GAPBB_SHIFT 14
+GMCR_GAPR1_SHIFT 7
+GMCR_GAPR2_SHIFT 0
+GPIO_LLI_BIT 5
+GPIO_MIC_RELAY 4
+GPIO_OVRUN_BIT 4
+GPIO_RXUVL_BIT 3
+GRC_MISC_CFG_PRESCALAR_SHIFT 1
+GRCR_HASHSIZE_SHIFT 17
+GREG_SWRST_CACHE_SHIFT 16
+GRSTCTL_TXFNUM_SHIFT 6
+GS40G_PAGE_SHIFT 16
+H5_RX_ESC 0
+H5_TX_ACK_REQ 1
+HAS_ALARM 1
+HASH_FN_SHIFT 13
+HAS_NVRAM 0
+HCCHAR_DEVADDR_SHIFT 22
+HCCHAR_EPNUM_SHIFT 11
+HCCHAR_EPTYPE_SHIFT 18
+HCCHAR_MPS_SHIFT 0
+HCCHAR_MULTICNT_SHIFT 20
+HCD_FLAG_DEAD 6
+HCD_FLAG_HW_ACCESSIBLE 0
+HCD_FLAG_POLL_PENDING 3
+HCD_FLAG_POLL_RH 2
+HCD_FLAG_RH_RUNNING 5
+HCD_FLAG_WAKEUP_PENDING 4
+HCI_AUTH 5
+HCI_AUTO_OFF 1
+HCI_CONNECTABLE 12
+HCI_CONN_ENCRYPT_PEND 2
+HCI_CONN_POWER_SAVE 9
+HCI_CONN_REAUTH_PEND 1
+HCI_CONN_REMOTE_OOB 10
+HCI_CONN_SCO_SETUP_PEND 5
+HCI_CONN_SSP_ENABLED 8
+HCI_DEBUG_KEYS 5
+HCI_ENCRYPT 6
+HCI_FAST_CONNECTABLE 16
+HCI_HS_ENABLED 9
+HCI_INIT 1
+HCI_INQUIRY 7
+HCI_ISCAN 4
+HCI_LE_ENABLED 10
+HCI_LE_PERIPHERAL 11
+HCI_LE_SCAN 7
+HC_INDEX_DATA_HC_ENABLED_SHIFT 1
+HC_INDEX_DATA_SM_ID_SHIFT 0
+HCI_PAIRABLE 3
+HCI_PERIODIC_INQ 15
+HCI_PSCAN 3
+HCI_QUIRK_FIXUP_BUFFER_SIZE 2
+HCI_QUIRK_RAW_DEVICE 1
+HCI_QUIRK_RESET_ON_CLOSE 0
+HCI_RAW 8
+HCI_RESET 9
+HCI_RUNNING 2
+HCI_SETUP 0
+HCI_SSP_ENABLED 8
+HCI_UART_INIT_PENDING 3
+HCI_UART_REGISTERED 1
+HCI_UART_SENDING 1
+HCI_UART_TX_WAKEUP 2
+HCI_UNREGISTER 6
+HCI_UP 0
+HCSPLT_HUBADDR_SHIFT 7
+HCSPLT_PRTADDR_SHIFT 0
+HCSPLT_XACTPOS_SHIFT 14
+HDPVR_RCA_BACK 0
+HDPVR_RCA_FRONT 1
+HDPVR_SPDIF 2
+HERMES_MIC_KEY_ID_SHIFT 11
+HFIR_FRINT_SHIFT 0
+HFS_BNODE_DELETED 2
+HFS_BNODE_DELETED 4
+HFS_BNODE_ERROR 0
+HFS_BNODE_ERROR 1
+HFS_BNODE_NEW 1
+HFS_BNODE_NEW 2
+HFS_FLG_ALT_MDB_DIRTY 2
+HFS_FLG_MDB_DIRTY 1
+HFSPLUS_I_CAT_DIRTY 1
+HFSPLUS_I_EXT_DIRTY 2
+HFSPLUS_I_RSRC 0
+HFSPLUS_SB_CASEFOLD 4
+HFSPLUS_SB_FORCE 2
+HFSPLUS_SB_HFSX 3
+HFSPLUS_SB_NOBARRIER 5
+HFSPLUS_SB_NODECOMPOSE 1
+HFSPLUS_SB_WRITEBACKUP 0
+HFSPLUS_SECTOR_SHIFT 9
+HFS_SECTOR_SIZE_BITS 9
+HID_CLEAR_HALT 6
+HID_CTRL_RUNNING 1
+HID_DISCONNECTED 7
+HIDE_STATUS_PHASE 6
+HID_KEYS_PRESSED 10
+HID_NO_BANDWIDTH 11
+HID_OUT_RUNNING 2
+HIDP_BLUETOOTH_VENDOR_ID 9
+HIDP_VIRTUAL_CABLE_UNPLUG 0
+HIDP_WAITING_FOR_RETURN 10
+HIDP_WAITING_FOR_SEND_ACK 11
+HID_RESET_PENDING 4
+HID_STARTED 8
+HID_SUSPENDED 5
+HI_EARLY_ALLOC_IRAM_BANKS_SHIFT 0
+HI_EARLY_ALLOC_MAGIC_SHIFT 16
+HIF_HOLDER 6
+HIGH_SPEED 7
+HighThresholdShift 2
+HI_OPTION_FW_BRIDGE_SHIFT 4
+HI_OPTION_FW_MODE_SHIFT 12
+HI_OPTION_FW_SUBMODE_SHIFT 20
+HI_OPTION_MAC_ADDR_METHOD_SHIFT 3
+HI_OPTION_NUM_DEV_SHIFT 9
+HMC5843_RANGE_GAIN_OFFSET 5
+HMC5843_RATE_OFFSET 2
+HORZ_PANEL_SHIFT 16
+HOST_CONTROL_IF_SHIFT 4
+HOST_DMA_ISOC_NBYTES_SHIFT 0
+HOST_DMA_NBYTES_SHIFT 0
+HOST_RAMP_DOWN_QUEUE_DEPTH 22
+HOST_SLEEP_MODE_CMD_PROCESSED 9
+HREF_HSIZE_SHIFT 0
+HREF_HSTART_SHIFT 4
+HREF_VSIZE_SHIFT 2
+HREF_VSTART_SHIFT 6
+HSO_NET_RUNNING 0
+HT_AGG_STATE_OPERATIONAL 2
+HT_AGG_STATE_STOPPING 3
+HT_AGG_STATE_WANT_STOP 5
+HTC_CONN_FLGS_SET_RECV_ALLOC_SHIFT 8
+HTC_MAILBOX 0
+HTS2_PRST_SHIFT 10
+HTS_PCPL_SHIFT 21
+HTS_PTL_SHIFT 1
+HV_KMRN_FIFO_CTRLSTA_PREAMBLE_SHIFT 12
+HV_SMB_ADDR_FREQ_LOW_SHIFT 8
+HW_HT_RATES_OFFSET 16
+HW_MIMO_RATES_OFFSET 24
+HWTSTAMP_FILTER_ALL 1
+HWTSTAMP_FILTER_NONE 0
+HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ 5
+HWTSTAMP_FILTER_PTP_V1_L4_EVENT 3
+HWTSTAMP_FILTER_PTP_V1_L4_SYNC 4
+HWTSTAMP_FILTER_PTP_V2_DELAY_REQ 14
+HWTSTAMP_FILTER_PTP_V2_EVENT 12
+HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ 11
+HWTSTAMP_FILTER_PTP_V2_L2_EVENT 9
+HWTSTAMP_FILTER_PTP_V2_L2_SYNC 10
+HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ 8
+HWTSTAMP_FILTER_PTP_V2_L4_EVENT 6
+HWTSTAMP_FILTER_PTP_V2_L4_SYNC 7
+HWTSTAMP_FILTER_PTP_V2_SYNC 13
+HWTSTAMP_TX_OFF 0
+HWTSTAMP_TX_ON 1
+HWTSTAMP_TX_ONESTEP_SYNC 2
+I2C_HID_READ_PENDING 4
+I2C_HID_RESET_PENDING 2
+I2C_HID_STARTED 1
+i2c_m_status_wdat_done_pos 1
+i2c_m_status_wdat_fail_pos 2
+I2F_FRAC_BITS 23
+I830_FENCE_PITCH_SHIFT 4
+I830_FENCE_TILING_Y_SHIFT 12
+I965_FENCE_TILING_Y_SHIFT 1
+IA32_SYSCALL_VECTOR 128
+IBA6120_R_PKEY_DIS_SHIFT 30
+IBA7220_IBCC_LINKCMD_SHIFT 19
+IBA7220_IBC_RXPOL_SHIFT 7
+IBA7220_LEDBLINK_OFF_SHIFT 0
+IBA7220_LEDBLINK_ON_SHIFT 32
+IBA7220_R_CTXTCFG_SHIFT 36
+IBA7220_R_INTRAVAIL_SHIFT 17
+IBA7220_R_PKEY_DIS_SHIFT 34
+IBA7220_R_TAILUPD_SHIFT 35
+IBA7220_TID_PA_SHIFT 11
+IBA7220_TID_SZ_SHIFT 37
+IBA7322_HDRHEAD_PKTINT_SHIFT 32
+IBA7322_TID_PA_SHIFT 11
+IBA7322_TID_SZ_SHIFT 37
+IB_ACK_REQUESTED 1
+IB_MGMT_METHOD_GET 1
+IB_MGMT_METHOD_SEND 3
+IB_MGMT_METHOD_SET 2
+IBSHIFT 16
+IBS_STARTED 1
+IBS_STOPPING 2
+IB_USER_VERBS_CMD_ALLOC_MW 14
+IB_USER_VERBS_CMD_ALLOC_PD 3
+IB_USER_VERBS_CMD_ATTACH_MCAST 30
+IB_USER_VERBS_CMD_BIND_MW 15
+IB_USER_VERBS_CMD_CLOSE_XRCD 38
+IB_USER_VERBS_CMD_CREATE_AH 5
+IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL 17
+IB_USER_VERBS_CMD_CREATE_CQ 18
+IB_USER_VERBS_CMD_CREATE_QP 24
+IB_USER_VERBS_CMD_CREATE_SRQ 32
+IB_USER_VERBS_CMD_CREATE_XSRQ 39
+IB_USER_VERBS_CMD_DEALLOC_MW 16
+IB_USER_VERBS_CMD_DEALLOC_PD 4
+IB_USER_VERBS_CMD_DEREG_MR 13
+IB_USER_VERBS_CMD_DESTROY_AH 8
+IB_USER_VERBS_CMD_DESTROY_CQ 20
+IB_USER_VERBS_CMD_DESTROY_QP 27
+IB_USER_VERBS_CMD_DESTROY_SRQ 35
+IB_USER_VERBS_CMD_DETACH_MCAST 31
+IB_USER_VERBS_CMD_GET_CONTEXT 0
+IB_USER_VERBS_CMD_MODIFY_AH 6
+IB_USER_VERBS_CMD_MODIFY_QP 26
+IB_USER_VERBS_CMD_MODIFY_SRQ 33
+IB_USER_VERBS_CMD_OPEN_QP 40
+IB_USER_VERBS_CMD_OPEN_XRCD 37
+IB_USER_VERBS_CMD_POLL_CQ 21
+IB_USER_VERBS_CMD_POST_RECV 29
+IB_USER_VERBS_CMD_POST_SEND 28
+IB_USER_VERBS_CMD_POST_SRQ_RECV 36
+IB_USER_VERBS_CMD_QUERY_AH 7
+IB_USER_VERBS_CMD_QUERY_DEVICE 1
+IB_USER_VERBS_CMD_QUERY_PORT 2
+IB_USER_VERBS_CMD_QUERY_QP 25
+IB_USER_VERBS_CMD_QUERY_SRQ 34
+IB_USER_VERBS_CMD_REG_MR 9
+IB_USER_VERBS_CMD_REQ_NOTIFY_CQ 23
+IB_USER_VERBS_CMD_RESIZE_CQ 19
+ICH_DI1L_SHIFT 4
+ICH_DI2L_SHIFT 6
+IDE_CAST_CMD_SHIFT 24
+IDEV_ABORT_PATH_ACTIVE 7
+IDEV_ABORT_PATH_RESUME_PENDING 8
+IDEV_GONE 3
+IDEV_IO_NCQERROR 5
+IDEV_IO_READY 4
+IDEV_START_PENDING 0
+IDEV_STOP_PENDING 1
+IDLE_CODE 25
+ID_SHIFT 16
+IDT77252_BIT_INIT 1
+IEEE80211_BAR_CTRL_TID_INFO_SHIFT 12
+IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT 2
+IEEE80211_HT_CAP_RX_STBC_SHIFT 8
+IEEE80211_HT_CAP_SM_PS_SHIFT 2
+IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT 2
+IEEE80211_RADIOTAP_EXT 31
+IEEE80211_RADIOTAP_MCS_STBC_SHIFT 5
+IEEE80211_SEQ_SEQ_SHIFT 4
+IEEE80211_TX_CTL_STBC_SHIFT 23
+IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT 23
+IEEE80211_WMM_IE_STA_QOSINFO_SP_SHIFT 5
+IEEE802154_FC_DAMODE_SHIFT 10
+IEEE802154_FC_SAMODE_SHIFT 14
+IFORCE_XMIT_AGAIN 1
+IFX_SPI_DTR 4
+IFX_SPI_MORE_BIT 4
+IFX_SPI_RTS 5
+IFX_SPI_STATE_IO_AVAILABLE 4
+IFX_SPI_STATE_IO_READY 2
+IFX_SPI_STATE_PRESENT 0
+IFX_SPI_UPDATE 8
+IGB_82576_TSYNC_SHIFT 19
+__IGB_DOWN 2
+IGB_RING_FLAG_RX_LB_VLAN_BSWAP 1
+IGB_RING_FLAG_RX_SCTP_CSUM 0
+IGB_RING_FLAG_TX_CTX_IDX 2
+IGB_RING_FLAG_TX_DETECT_HANG 3
+__IGB_TESTING 0
+IGB_TX_FLAGS_VLAN_SHIFT 16
+__IGBVF_DOWN 2
+__IGBVF_TESTING 0
+IGBVF_TX_FLAGS_VLAN_SHIFT 16
+IGNORE_NEXT_INT 2
+IGP_PAGE_SHIFT 5
+IGU_ACK_REGISTER_INTERRUPT_MODE_SHIFT 9
+IGU_ACK_REGISTER_STATUS_BLOCK_ID_SHIFT 0
+IGU_ACK_REGISTER_STORM_ID_SHIFT 5
+IGU_ACK_REGISTER_UPDATE_INDEX_SHIFT 8
+IGU_CTRL_REG_ADDRESS_SHIFT 0
+IGU_CTRL_REG_FID_SHIFT 12
+IGU_CTRL_REG_TYPE_SHIFT 20
+IGU_FID_ENCODE_IS_PF_SHIFT 6
+IGU_REGULAR_BUPDATE_SHIFT 24
+IGU_REGULAR_CLEANUP_TYPE_SHIFT 28
+IGU_REGULAR_ENABLE_INT_SHIFT 25
+IGU_REGULAR_SB_INDEX_SHIFT 0
+IGU_REGULAR_SEGMENT_ACCESS_SHIFT 21
+IGU_VF_CONF_PARENT_SHIFT 2
+IHFLG_IFSHFT 2
+IHOST_IRQ_ENABLED 2
+IHOST_START_PENDING 0
+IHOST_STOP_PENDING 1
+IL_FIRST_OFDM_RATE 4
+IMG_REQ_CHILD 1
+IMG_REQ_LAYERED 2
+IMG_REQ_WRITE 0
+IMGSZ_V_SHIFT 16
+IMM 6
+INFINIPATH_HWE_HTCMEMPARITYERR_SHIFT 0
+INFINIPATH_HWE_RXEMEMPARITYERR_SHIFT 44
+INFINIPATH_HWE_TXEMEMPARITYERR_SHIFT 40
+INFINIPATH_IBCC_CREDITSCALE_SHIFT 40
+INFINIPATH_IBCC_FLOWCTRLPERIOD_SHIFT 0
+INFINIPATH_IBCC_FLOWCTRLWATERMARK_SHIFT 8
+INFINIPATH_IBCC_LINKINITCMD_SHIFT 16
+INFINIPATH_IBCC_OVERRUNTHRESHOLD_SHIFT 36
+INFINIPATH_IBCC_PHYERRTHRESHOLD_SHIFT 32
+INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT 0
+INFINIPATH_I_RCVAVAIL_SHIFT 12
+INFINIPATH_I_RCVURG_SHIFT 0
+INFINIPATH_RT_BUFSIZE_SHIFT 48
+INFINIPATH_S_DISARMPIOBUF_SHIFT 16
+INFINIPATH_SENDPIOAVAIL_BUSY_SHIFT 1
+INFINIPATH_S_UPDTHRESH_SHIFT 24
+INFINIPATH_XGXS_RX_POL_SHIFT 19
+INIT_HCA_DEVICE_MANAGED_FLOW_STEERING_EN 6
+INIT_IB_MTU_SHIFT 12
+INIT_IB_PORT_WIDTH_SHIFT 8
+INIT_IB_VL_SHIFT 4
+INIT_PORT_PORT_WIDTH_SHIFT 8
+INIT_PORT_VL_SHIFT 4
+INPUT_PROP_SEMI_MT 3
+In_sync 1
+INTA_ASSERTED 12
+INTEL_ANALOG_CLONE_BIT 9
+INTEL_OUTPUT_ANALOG 1
+INTEL_OUTPUT_DISPLAYPORT 9
+INTEL_OUTPUT_EDP 10
+INTEL_OUTPUT_HDMI 6
+INTEL_OUTPUT_LVDS 4
+INTEL_OUTPUT_MIPI2 8
+INTEL_OUTPUT_MIPI 7
+INTEL_OUTPUT_SDVO 3
+INTEL_OUTPUT_TVOUT 5
+INTEL_PMC_IDX_FIXED 32
+INTEL_SDVO_LVDS_CLONE_BIT 8
+INTEL_SDVO_NON_TV_CLONE_BIT 6
+INTEL_SDVO_TV_CLONE_BIT 7
+INT_EN 1
+INTERCEPT_IOIO_PROT 27
+INTERCEPT_MSR_PROT 28
+INTERCEPT_NMI 1
+INTERCEPT_SELECTIVE_CR0 5
+INTERCEPT_VMRUN 32
+INTERRUPT_AFTER_TERMINAL_COUNT 2
+INTERRUPT_MODE 4
+INT_MASK_WE 8
+INTR_COAL_COUNT_SHIFT 16
+INV_MPU6050_ACCL_CONFIG_FSR_SHIFT 3
+INV_MPU6050_GYRO_CONFIG_FSR_SHIFT 3
+IOAT_COMPLETION_ACK 1
+IOAT_COMPLETION_PENDING 0
+IOAT_KOBJ_INIT_FAIL 3
+IOAT_MMIO_BAR 0
+IOAT_RESET_PENDING 2
+IOAT_RUN 5
+_IOC_NR 101
+_IOC_NR 102
+_IOC_NR 2
+_IOC_NR 21
+_IOC_NR 25
+_IOC_NR 27
+_IOC_NR 28
+_IOC_NR 36
+_IOC_NR 37
+_IOC_NR 4
+_IOC_NR 5
+_IOC_NR 58
+_IOC_NR 59
+_IOC_NR 60
+_IOC_NR 64
+_IOC_NR 67
+_IOC_NR 68
+_IOC_NR 71
+_IOC_NR 72
+_IOC_NR 73
+_IOC_NR 79
+_IOC_NR 80
+IOCR_INPUTS_OFFSET 8
+IOCR_OUTPUTS_OFFSET 0
+IO_DONE_BIT 0
+IO_ERROR_SHIFT 20
+IOMMU_CAP_EFR 27
+IOMMU_CAP_IOTLB 24
+IOMMU_CAP_NPCACHE 26
+IOPM_ALLOC_ORDER 2
+IOPOLL_F_DISABLE 1
+IOPOLL_F_SCHED 0
+IOSF_BAR_SHIFT 1
+IOSF_BYTE_ENABLES_SHIFT 4
+IOSF_DEVFN_SHIFT 24
+IOSF_OPCODE_SHIFT 16
+IOSF_PORT_SHIFT 8
+IO_TLB_SHIFT 11
+IO_WAKEUP_ENABLE 1
+IPATH_AETH_CREDIT_SHIFT 24
+IPATH_GPIO_LLI_BIT 5
+IPATH_GPIO_OVRUN_BIT 4
+IPATH_GPIO_PORT0_BIT 2
+IPATH_GPIO_RXUVL_BIT 3
+IPATH_PORT_MASTER_UNINIT 4
+IPATH_PORT_WAITING_RCV 2
+IPATH_PORT_WAITING_URG 5
+IPATH_R_WRID_VALID 0
+IPATH_SDMA_DISARMED 1
+IPCT_ASSURED 4
+IPCT_DESTROY 2
+IPCT_HELPER 6
+IPCT_LABEL 10
+IPCT_MARK 7
+IPCT_NATSEQADJ 8
+IPCT_NEW 0
+IPCT_PROTOINFO 5
+IPCT_RELATED 1
+IPCT_REPLY 3
+IPCT_SECMARK 9
+IPEXP_DESTROY 1
+IPEXP_NEW 0
+IPMI_FLAGS_HANDLER_INSTALL 0
+IPOIB_FLAG_ADMIN_CM 9
+IPOIB_FLAG_ADMIN_UP 2
+IPOIB_FLAG_INITIALIZED 1
+IPOIB_FLAG_OPER_UP 0
+IPOIB_FLAG_SUBINTERFACE 5
+IPOIB_FLAG_UMCAST 10
+IPOIB_MCAST_FLAG_BUSY 2
+IPOIB_MCAST_FLAG_FOUND 0
+IPOIB_MCAST_FLAG_SENDONLY 1
+IPOIB_NEIGH_TBL_FLUSH 12
+IPOIB_PKEY_ASSIGNED 3
+IPOIB_PKEY_STOP 4
+IPOIB_STOP_NEIGH_GC 11
+IPOIB_STOP_REAPER 7
+IPORT_RESET_PENDING 0
+IPP_CFIG_IP_MAX_PKT_SHIFT 8
+IPS_ASSURED_BIT 2
+IPS_DYING_BIT 9
+IPS_HELPER_BIT 13
+IPS_SEQ_ADJUST_BIT 6
+IP_VS_DEST_STATE_REMOVING 1
+IP_VS_SCTP_S_CLOSED 13
+IP_VS_SCTP_S_ESTABLISHED 8
+IP_VS_SCTP_S_SHUTDOWN_ACK_SENT 11
+IP_VS_SCTP_S_SHUTDOWN_RECEIVED 10
+IP_VS_SCTP_S_SHUTDOWN_SENT 9
+IP_VS_TCP_S_CLOSE 6
+IP_VS_TCP_S_CLOSE_WAIT 7
+IP_VS_TCP_S_ESTABLISHED 1
+IP_VS_TCP_S_FIN_WAIT 4
+IP_VS_TCP_S_TIME_WAIT 5
+IQM_CF_MIDTAP_IM__B 1
+IQM_CF_MIDTAP_RE__B 0
+IQM_CF_OUT_ENA_QAM__B 1
+IQM_RC_RATE_OFS_LO__W 16
+IREQ_ABORT_PATH_ACTIVE 6
+IREQ_ACTIVE 3
+IREQ_COMPLETE_IN_TARGET 0
+IREQ_NO_AUTO_FREE_TAG 7
+IREQ_PENDING_ABORT 4
+IREQ_TC_ABORT_POSTED 5
+IREQ_TERMINATED 1
+IREQ_TMF 2
+IRL_FC_SHIFT 24
+IRQ_MODRT_RX_TIMER_SHIFT 16
+IRQ_MODRT_TX_TIMER_SHIFT 0
+IRQ_MOVE_CLEANUP_VECTOR 32
+IRQTF_AFFINITY 2
+IRQTF_FORCED_THREAD 3
+IS_ANY_T0 9
+IS_ANY_T1 10
+IS_ATR_PRESENT 11
+IS_ATR_VALID 12
+IS_AUTOPPS_ACT 6
+IS_BAD_CARD 16
+IS_CMM_ABSENT 13
+ISCSI_CMD_REQUEST_TYPE_SHIFT 14
+ISCSI_KWQE_HEADER_LAYER_CODE_SHIFT 4
+ISCSI_KWQE_INIT1_PAGE_SIZE_SHIFT 0
+ISCSI_LOGIN_REQUEST_NUM_RESP_BDS_SHIFT 24
+ISCSI_LOGIN_REQUEST_RESP_BUFFER_LENGTH_SHIFT 0
+ISCSI_LOGIN_REQUEST_TYPE_SHIFT 14
+ISCSI_LOGOUT_REQUEST_TYPE_SHIFT 14
+ISCSI_SUSPEND_BIT 1
+ISCSI_TEXT_REQUEST_NUM_RESP_BDS_SHIFT 24
+ISCSI_TEXT_REQUEST_RESP_BUFFER_LENGTH_SHIFT 0
+ISCSI_TEXT_REQUEST_TYPE_SHIFT 14
+ISCSI_TMF_REQUEST_TYPE_SHIFT 14
+ISDN_P_NT_E1 4
+ISDN_P_NT_S0 2
+ISDN_P_TE_E1 3
+ISDN_P_TE_S0 1
+IS_INVREV 8
+ISP_ABORT_NEEDED 2
+ISP_ABORT_RETRY 10
+ISP_QUIESCE_NEEDED 20
+ISP_UNRECOVERABLE 17
+IT87_CFQ_SHIFT 3
+IVTV_F_I_DECODING_YUV 12
+IVTV_F_I_DEC_PAUSED 20
+IVTV_F_I_DEC_YUV 7
+IVTV_F_I_DMA 0
+IVTV_F_I_EOS 4
+IVTV_F_I_EV_DEC_STOPPED 28
+IVTV_F_I_EV_VSYNC 29
+IVTV_F_I_EV_VSYNC_ENABLED 31
+IVTV_F_I_EV_VSYNC_FIELD 30
+IVTV_F_I_FAILED 22
+IVTV_F_I_HAVE_WORK 15
+IVTV_F_I_PIO 19
+IVTV_F_I_RADIO_USER 5
+IVTV_F_I_UDMA 1
+IVTV_F_I_UDMA_PENDING 2
+IVTV_F_I_UPDATE_CC 9
+IVTV_F_I_UPDATE_VPS 11
+IVTV_F_I_UPDATE_WSS 10
+IVTV_F_I_VALID_DEC_TIMINGS 14
+IVTV_F_I_WORK_HANDLER_PCM 23
+IVTV_F_I_WORK_HANDLER_PIO 18
+IVTV_F_I_WORK_HANDLER_VBI 16
+IVTV_F_I_WORK_HANDLER_YUV 17
+IVTV_F_S_APPL_IO 8
+IVTV_F_S_DMA_HAS_VBI 1
+IVTV_F_S_DMA_PENDING 0
+IVTV_F_S_INTERNAL_USE 5
+IVTV_F_S_NEEDS_DATA 2
+IVTV_F_S_PASSTHROUGH 6
+IVTV_F_S_PIO_PENDING 9
+IVTV_F_S_STREAMING 4
+IVTV_F_S_STREAMOFF 7
+IWCM_F_CALLBACK_DESTROY 1
+IWCM_F_CONNECT_WAIT 2
+IWLAGN_BT_FLAG_COEX_MODE_SHIFT 3
+IWLAGN_EXT_BEACON_TIME_POS 22
+IWL_FIRST_OFDM_RATE 4
+IWL_MVM_STATUS_HW_CTKILL 1
+IWL_MVM_STATUS_HW_RFKILL 0
+IWL_MVM_STATUS_IN_HW_RESTART 3
+IWL_MVM_STATUS_ROC_RUNNING 2
+__IXGB_DOWN 0
+IXGBE_ADVTXD_IDX_SHIFT 4
+IXGBE_ADVTXD_L4LEN_SHIFT 8
+IXGBE_ADVTXD_MACLEN_SHIFT 9
+IXGBE_ADVTXD_MSS_SHIFT 16
+IXGBE_ADVTXD_PAYLEN_SHIFT 14
+__IXGBE_DOWN 2
+IXGBE_DPMCS_MTSOS_SHIFT 16
+IXGBE_EEPROM_RW_ADDR_SHIFT 2
+IXGBE_EEPROM_RW_REG_DATA 16
+IXGBE_ETQF_POOL_SHIFT 20
+IXGBE_FCBUFF_BUFFCNT_SHIFT 8
+IXGBE_FCBUFF_BUFFSIZE_SHIFT 3
+IXGBE_FCBUFF_OFFSET_SHIFT 16
+IXGBE_FCDMARW_LASTSIZE_SHIFT 16
+__IXGBE_FCOE_TARGET 1
+IXGBE_FDIRCMD_FLOW_TYPE_SHIFT 5
+IXGBE_FDIRCMD_RX_QUEUE_SHIFT 16
+IXGBE_FDIRCMD_VT_POOL_SHIFT 24
+IXGBE_FDIRCTRL_DROP_Q_SHIFT 8
+IXGBE_FDIRCTRL_FLEX_SHIFT 16
+IXGBE_FDIRCTRL_FULL_THRESH_SHIFT 28
+IXGBE_FDIRCTRL_MAX_LENGTH_SHIFT 24
+IXGBE_FDIRHASH_SIG_SW_INDEX_SHIFT 16
+IXGBE_MFLCN_RPFCE_SHIFT 4
+IXGBE_MHADD_MFS_SHIFT 16
+IXGBE_MSCA_DEV_TYPE_SHIFT 16
+IXGBE_MSCA_NP_ADDR_SHIFT 0
+IXGBE_MSCA_PHY_ADDR_SHIFT 21
+IXGBE_RAH_VIND_SHIFT 18
+__IXGBE_READ_I2C 5
+IXGBE_RT2CR_MCL_SHIFT 12
+IXGBE_RTRPT4C_BWG_SHIFT 9
+IXGBE_RTRPT4C_MCL_SHIFT 12
+IXGBE_RTRUP2TC_UP_SHIFT 3
+IXGBE_RTTDT2C_BWG_SHIFT 9
+IXGBE_RTTDT2C_MCL_SHIFT 12
+IXGBE_RTTPCS_ARBD_SHIFT 22
+IXGBE_RTTPT2C_BWG_SHIFT 9
+IXGBE_RTTPT2C_MCL_SHIFT 12
+__IXGBE_RX_CSUM_UDP_ZERO_ERR 5
+__IXGBE_RX_FCOE 6
+IXGBE_RXPBSIZE_SHIFT 10
+IXGBE_SFF_VENDOR_OUI_BYTE0_SHIFT 24
+IXGBE_SFF_VENDOR_OUI_BYTE1_SHIFT 16
+IXGBE_SFF_VENDOR_OUI_BYTE2_SHIFT 8
+IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT 2
+IXGBE_TDPT2TCCR_BWG_SHIFT 9
+IXGBE_TDPT2TCCR_MCL_SHIFT 12
+IXGBE_TDTQ2TCCR_BWG_SHIFT 9
+IXGBE_TDTQ2TCCR_MCL_SHIFT 12
+__IXGBE_TESTING 0
+__IXGBE_TX_FDIR_INIT_DONE 0
+IXGBE_TX_FLAGS_VLAN_PRIO_SHIFT 29
+IXGBE_TX_FLAGS_VLAN_SHIFT 16
+__IXGBEVF_DOWN 2
+__IXGBEVF_TESTING 0
+IXGBE_VT_CTL_POOL_SHIFT 7
+IXGBE_VT_MSGINFO_SHIFT 16
+IXGB_MSCA_DEV_TYPE_SHIFT 16
+IXGB_MSCA_NP_ADDR_SHIFT 0
+IXGB_MSCA_PHY_ADDR_SHIFT 21
+IXGB_RCTL_MO_SHIFT 12
+J_ABORTED 3
+JC42_CFG_HYST_SHIFT 9
+__JI_COMMIT_RUNNING 0
+JIFFIES_SHIFT 8
+JME_FLAG_MSI 1
+JME_FLAG_POLL 5
+JME_FLAG_SHUTDOWN 6
+JME_FLAG_SSET 2
+JOB_AUTOWEP 7
+JOB_DIE 0
+JOB_EVENT 6
+JOB_MIC 5
+JOB_PROMISC 4
+JOB_SCAN_RESULTS 9
+JOB_STATS 3
+JOB_WSTATS 8
+JOB_XMIT 1
+JOB_XMIT11 2
+JSET_BITS 3
+J_WRITERS_BLOCKED 1
+J_WRITERS_QUEUED 2
+KDB_DEBUG_FLAG_SHIFT 16
+KEY_BRIGHTNESS_CYCLE 243
+KEY_BRIGHTNESSDOWN 224
+KEY_BRIGHTNESSUP 225
+KEY_BRIGHTNESS_ZERO 244
+KEY_DISPLAY_OFF 245
+KEY_F14 184
+KEY_F15 185
+KEY_F16 186
+KEY_F17 187
+KEY_F18 188
+KEY_FLAG_DEAD 1
+KEY_FLAG_IN_QUOTA 3
+KEY_FLAG_INSTANTIATED 0
+KEY_FLAG_INVALIDATED 7
+KEY_FLAG_NEGATIVE 5
+KEY_FLAG_REVOKED 2
+KEY_FLAG_ROOT_CAN_CLEAR 6
+KEY_FLAG_USER_CONSTRUCT 4
+KEY_GC_KEY_EXPIRED 0
+KEY_GC_REAPING_KEYTYPE 2
+KEY_GC_REAP_KEYTYPE 1
+KEY_NUMLOCK 69
+KEYP_LK_PTV_PTV_SHIFT 5
+KEY_POWER 116
+KEY_SLEEP 142
+KEY_SWITCHVIDEOMODE 227
+KEY_UNKNOWN 240
+KEY_VIDEO_NEXT 241
+KEY_VIDEO_PREV 242
+KEY_VOLUMEDOWN 114
+KEY_VOLUMEUP 115
+KG_SHIFT 0
+KMEM_ACCOUNTED_ACTIVATED 1
+KMEM_ACCOUNTED_ACTIVE 0
+KMEM_ACCOUNTED_DEAD 2
+KPF_ANON 12
+KPF_BUDDY 10
+KPF_COMPOUND_HEAD 15
+KPF_COMPOUND_TAIL 16
+KPF_HUGE 17
+KPF_KSM 21
+KPF_MMAP 11
+KPF_NOPAGE 20
+KPF_THP 22
+KP_ROW_SHIFT 4
+KTHREAD_IS_PER_CPU 0
+KTHREAD_SHOULD_PARK 2
+KTHREAD_SHOULD_STOP 1
+KVM_APIC_INIT 0
+KVM_APIC_SIPI 1
+KVM_FEATURE_ASYNC_PF 4
+KVM_FEATURE_CLOCKSOURCE 0
+KVM_FEATURE_CLOCKSOURCE2 3
+KVM_FEATURE_CLOCKSOURCE_STABLE_BIT 24
+KVM_FEATURE_NOP_IO_DELAY 1
+KVM_FEATURE_PV_EOI 6
+KVM_FEATURE_STEAL_TIME 5
+KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID 1
+KVM_MMU_HASH_SHIFT 10
+KVM_REQ_CLOCK_UPDATE 8
+KVM_REQ_MASTERCLOCK_UPDATE 18
+KVM_USERSPACE_IRQ_SOURCE_ID 0
+KWQE_LAYER_SHIFT 28
+KWQE_OPCODE_SHIFT 16
+L2BPERDMAP 13
+L2CAP_CTRL_FINAL_SHIFT 7
+L2CAP_CTRL_POLL_SHIFT 4
+L2CAP_CTRL_REQSEQ_SHIFT 8
+L2CAP_CTRL_SAR_SHIFT 14
+L2CAP_CTRL_SUPER_SHIFT 2
+L2CAP_CTRL_TXSEQ_SHIFT 1
+L2CAP_EXT_CTRL_FINAL_SHIFT 1
+L2CAP_EXT_CTRL_POLL_SHIFT 18
+L2CAP_EXT_CTRL_REQSEQ_SHIFT 2
+L2CAP_EXT_CTRL_SAR_SHIFT 16
+L2CAP_EXT_CTRL_SUPER_SHIFT 16
+L2CAP_EXT_CTRL_TXSEQ_SHIFT 18
+L2_DB_SIZE 14
+L2DBWORD 5
+L2DISIZE 9
+L2DTSLOTSIZE 5
+L2EXTSPERSUM 5
+L2INOSPEREXT 5
+L2INOSPERIAG 12
+L2LOGPSIZE 12
+L2_QENTRY_SZ 12
+L2XTSLOTSIZE 4
+L3_CLS_PID_SHIFT 16
+L3_CLS_TOSMASK_SHIFT 8
+L3_CLS_TOS_SHIFT 0
+L4_KWQ_CLOSE_REQ_LAYER_CODE_SHIFT 4
+L4_KWQ_CONNECT_REQ1_LAYER_CODE_SHIFT 4
+L4_KWQ_CONNECT_REQ2_LAYER_CODE_SHIFT 4
+L4_KWQ_CONNECT_REQ3_LAYER_CODE_SHIFT 4
+L4_KWQ_OFFLOAD_PG_LAYER_CODE_SHIFT 4
+L4_KWQ_RESET_REQ_LAYER_CODE_SHIFT 4
+L4_KWQ_UPDATE_PG_LAYER_CODE_SHIFT 4
+L4_KWQ_UPLOAD_LAYER_CODE_SHIFT 4
+LAS_BIT_BIGENDIAN 24
+LC_LINK_WIDTH_SHIFT 0
+LC_SPEED_CHANGE_ATTEMPTS_ALLOWED_SHIFT 3
+LDO_I2C_EN_SHIFT 0
+LDO_SEL_SHIFT 2
+LDO_SEQ_SHIFT 2
+LED_CAPSL 1
+LED_COMPOSE 3
+LED_KANA 4
+LED_LINK_SHIFT 12
+LED_NUML 0
+LED_SCROLLL 2
+LED_TXRX_SHIFT 8
+LFA_LINK_FLAP_REASON_OFFSET 0
+LINE6_INDEX_PAUSE_PLAYBACK 12
+LINK_FLAP_AVOIDANCE_COUNT_OFFSET 8
+LINK_FLAP_COUNT_OFFSET 16
+__LINK_STATE_DORMANT 4
+__LINK_STATE_NOCARRIER 2
+__LINK_STATE_PRESENT 1
+__LINK_STATE_START 0
+LK_STATE_IN_USE 0
+LM3533_ALS_FLAG_INT_ENABLED 1
+LM3533_BOOST_FREQ_SHIFT 0
+LM3533_BOOST_OVP_SHIFT 1
+LM73_CTRL_RES_SHIFT 5
+LmRAMPAGE_LSHIFT 8
+LOCAL_ADDRESSING_MODE 11
+LOCAL_BURST_ENABLE 8
+LOCAL_BUS_WIDTH 0
+LOCAL_DMA_CHANNEL_0_INTERRUPT_ENABLE 18
+LOCAL_INTERRUPT_INPUT_ENABLE 11
+LOCAL_LOOP_UPDATE 6
+LOCAL_OUT_ZLP 6
+LOG2_LOG_TABLE_SIZE 5
+log_FLUSH 4
+log_INLINELOG 1
+log_QUIESCE 3
+log_SYNCBARRIER 2
+LOOPBACK_NONE 0
+LOOPBACK_XGMII 3
+LOOP_RESYNC_NEEDED 4
+LowThresholdShift 12
+LOWWAIT 2
+LP8725_BUCK_CL_S 6
+LP8727_ICHG_SHIFT 4
+LP8788_ALM_EN_S 7
+LP8788_BL_DIM_MODE_SHIFT 1
+LP8788_BL_FULLSCALE_SHIFT 2
+LP8788_BL_PWM_POLARITY_SHIFT 6
+LP8788_BL_RAMP_RISE_SHIFT 4
+LPFC_DATA_READY 1
+LPFC_ELS_RING 2
+LPFC_FCP_RING 0
+LPFC_FIP_ELS_ID_SHIFT 14
+LP_PREEMPT_REQUEST 1
+LSFL_CB_DELAY 9
+LSFL_NODIR 10
+LSFL_RCOM_READY 5
+LSFL_RCOM_WAIT 6
+LSFL_RECOVER_DOWN 1
+LSFL_RECOVER_LOCK 2
+LSFL_RECOVER_STOP 0
+LSFL_RECOVER_WORK 3
+LSFL_RUNNING 4
+LSFL_TIMEWARN 8
+LSFL_UEVENT_WAIT 7
+LVDS_BL_MOD_LEVEL_SHIFT 8
+LZMA_LEN_NUM_LOW_BITS 3
+LZMA_LEN_NUM_MID_BITS 3
+LZMA_NUM_POS_BITS_MAX 4
+LZMA_NUM_POS_SLOT_BITS 6
+M8051_RESET 0
+M98088_MICPRE_SHIFT 5
+M98090_ADCHP_SHIFT 0
+M98090_DACHP_SHIFT 0
+M98090_DMIC_COMP_SHIFT 4
+M98090_FREQ_SHIFT 4
+M98090_IJDET_SHIFT 2
+M98090_MICCLK_SHIFT 4
+M98090_MIC_PA1EN_SHIFT 5
+M98090_MIC_PA2EN_SHIFT 5
+M98090_PERFMODE_SHIFT 1
+M98090_TDM_SLOTDLY_SHIFT 0
+M98090_TDM_SLOTL_SHIFT 6
+M98090_TDM_SLOTR_SHIFT 4
+M98090_USE_M1_SHIFT 0
+M98095_MICPRE_SHIFT 5
+MAC_ADDR_IDX_SHIFT 4
+MAC_ADDR_TYPE_SHIFT 16
+MAC_ADDR_VALID 0
+MACB_REV_SIZE 16
+MAC_CFG_DESC_TX_1_DST_INDEX_POS 16
+MAC_CFG_DESC_TX_2_L2_TRANSLATION_TYPE_POS 18
+MAC_CFG_DESC_TX_2_NUM_OF_DESCRIPTORS_POS 0
+MAC_CTRL_HALF_LEFT_BUF_SHIFT 28
+MAC_CTRL_PRMLEN_SHIFT 10
+MAC_CTRL_SPEED_SHIFT 20
+MAC_FLOW_CTRL_PT_SHIFT 16
+MAC_HALF_DUPLX_CTRL_ABEBT_SHIFT 20
+MAC_HALF_DUPLX_CTRL_JAMIPG_SHIFT 24
+MAC_HALF_DUPLX_CTRL_RETRY_SHIFT 12
+MAC_IPG_IFG_IPGR1_SHIFT 16
+MAC_IPG_IFG_IPGR2_SHIFT 24
+MAC_IPG_IFG_IPGT_SHIFT 0
+MAC_IPG_IFG_MIFG_SHIFT 8
+Magic 1
+MAP_ISR_S2_CST 6
+MAP_ISR_S2_GTT 6
+MAX77686_OPMODE_BUCK234_SHIFT 4
+MAX77686_OPMODE_SHIFT 6
+MAX8925_IRQ_RTC_ALARM0 22
+MAX8997_LED_FLASH_SHIFT 3
+MAX8997_LED_MOVIE_SHIFT 4
+MAX9877_OSC_OFFSET 4
+MAX_HWIFS 10
+MAX_ORDER 11
+MAX_PFC_PRIORITIES 8
+MAX_READ_REQUEST_SHIFT 12
+MAX_READ_REQUEST_SZ_SHIFT 12
+MAX_SWAPFILES_SHIFT 5
+M_BITS 9
+MB_RFD_PROD_INDX_SHIFT 0
+MB_RRD_CONS_INDX_SHIFT 11
+MB_TPD_PROD_INDX_SHIFT 22
+MBX_INTR_WAIT 2
+MBX_UPDATE_FLASH_ACTIVE 3
+MC13783_ADC1_ATO_SHIFT 11
+MC13783_POWER_CONTROL_2_ON1BDBNC 4
+MC13783_POWER_CONTROL_2_ON2BDBNC 6
+MC13783_POWER_CONTROL_2_ON3BDBNC 8
+MC13XXX_ADC1_CHAN0_SHIFT 5
+MC13XXX_ADC1_CHAN1_SHIFT 8
+MC_CHP_IO_CNTL_A1__MEM_SYNC_ENA__SHIFT 24
+MC_CHP_IO_CNTL_B1__MEM_SYNC_ENB__SHIFT 24
+MC_CMD_CAPABILITIES_TURBO_ACTIVE_LBN 2
+MC_CMD_GET_LINK_OUT_FULL_DUPLEX_LBN 1
+MC_CMD_GET_LINK_OUT_LINK_UP_LBN 0
+MC_CMD_GET_PHY_CFG_OUT_BIST_CABLE_LONG_LBN 2
+MC_CMD_GET_PHY_CFG_OUT_BIST_CABLE_SHORT_LBN 1
+MC_CMD_GET_PHY_CFG_OUT_BIST_LBN 6
+MC_CMD_GET_PHY_CFG_OUT_LOWPOWER_LBN 3
+MC_CMD_GET_PHY_CFG_OUT_POWEROFF_LBN 4
+MC_CMD_GET_PHY_CFG_OUT_TXDIS_LBN 5
+MC_CMD_MMD_CLAUSE22 0
+MC_CMD_NVRAM_INFO_OUT_PROTECTED_LBN 0
+MC_CMD_PHY_CAP_10000FDX_LBN 7
+MC_CMD_PHY_CAP_1000FDX_LBN 6
+MC_CMD_PHY_CAP_1000HDX_LBN 5
+MC_CMD_PHY_CAP_100FDX_LBN 4
+MC_CMD_PHY_CAP_100HDX_LBN 3
+MC_CMD_PHY_CAP_10FDX_LBN 2
+MC_CMD_PHY_CAP_10HDX_LBN 1
+MC_CMD_PHY_CAP_AN_LBN 10
+MC_CMD_PHY_CAP_ASYM_LBN 9
+MC_CMD_PHY_CAP_PAUSE_LBN 8
+MC_CMD_SET_LINK_IN_LOWPOWER_LBN 0
+MC_CMD_SET_LINK_IN_POWEROFF_LBN 1
+MC_CMD_SET_LINK_IN_TXDIS_LBN 2
+MC_CMD_SET_MAC_IN_REJECT_UNCST_LBN 0
+MCC_WRB_SGE_CNT_SHIFT 3
+MC_DISP0R_INIT_LAT_SHIFT 8
+MC_DISP1R_INIT_LAT_SHIFT 12
+MCE_OVERFLOW 0
+MC_HASH_SZ_LOG 9
+MCH_PRD_LEN_SHIFT 16
+MCH_SSP_FR_TYPE_SHIFT 13
+MC_NANOSECOND_BITS 30
+MCPR_IMC_COMMAND_OPERATION_BITSHIFT 28
+MCPR_IMC_COMMAND_TRANSFER_ADDRESS_BITSHIFT 8
+MCS_SEL_IN_FREQ_SHIFT 4
+MC_VECTOR 18
+MD_ARRAY_FIRST_USE 3
+MD_CHANGE_CLEAN 1
+MD_CHANGE_DEVS 0
+MD_CHANGE_PENDING 2
+MD_DISK_ACTIVE 1
+MD_DISK_FAULTY 0
+MD_DISK_REMOVED 3
+MD_DISK_SYNC 2
+MD_DISK_WRITEMOSTLY 9
+MDIO_CLK_SEL_SHIFT 24
+MDIO_DATA_OP_SHIFT 28
+MDIO_DATA_PMD_SHIFT 23
+MDIO_DATA_RA_SHIFT 18
+MDIO_DATA_SHIFT 0
+MDIO_DATA_TA_SHIFT 16
+MDIO_MMD_PHYXS 4
+MDIO_REG_ADDR_SHIFT 16
+MDIO_TX0_TX_DRIVER_PREEMPHASIS_SHIFT 12
+MD_NO_FUA 7
+MdpMinorShift 6
+MD_RECOVERY_CHECK 7
+MD_RECOVERY_DONE 4
+MD_RECOVERY_ERROR 10
+MD_RECOVERY_FROZEN 9
+MD_RECOVERY_INTR 3
+MD_RECOVERY_NEEDED 5
+MD_RECOVERY_RECOVER 2
+MD_RECOVERY_REQUESTED 6
+MD_RECOVERY_RESHAPE 8
+MD_RECOVERY_RUNNING 0
+MD_RECOVERY_SYNC 1
+MD_SB_BITMAP_PRESENT 8
+MD_SB_CLEAN 0
+MEDIA_FLAG_REGISTERED 0
+MEGASAS_FUSION_IN_RESET 0
+MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT 1
+MEI_CL_EVENT_RX 0
+MEMCG_SOCK_ACTIVE 0
+MEMCTL_CMD_SHIFT 13
+MEMCTL_FREQ_SHIFT 8
+MEMORY_SPACE_LOCAL_BUS_WIDTH 0
+MEM_SDRAM_MODE_REG__MEM_MODE_REG__SHIFT 0
+MESH_IFACE_BIT_OFFSET 12
+MESH_WORK_DRIFT_ADJUST 4
+MESH_WORK_GROW_MPATH_TABLE 1
+MESH_WORK_GROW_MPP_TABLE 2
+MESH_WORK_HOUSEKEEPING 0
+MESH_WORK_MBSS_CHANGED 5
+MESH_WORK_ROOT 3
+META_discard 4
+META_forcewrite 5
+META_free 1
+META_io 6
+MI_COM_PHY_ADDR_SHIFT 21
+MI_COM_REG_ADDR_SHIFT 16
+MICRO_SELECT_PREAMPLI_OFFSET 2
+MID_DMA_CHAN_SHIFT 6
+MID_DMA_COUNT_SHIFT 16
+MID_DMA_VCI_SHIFT 6
+MID_RED_SHIFT 25
+MID_SEG_ID_SHIFT 28
+MID_SEG_PR_SHIFT 25
+MID_SEG_RATE_SHIFT 19
+MID_SEG_VCI_SHIFT 4
+MID_VCI_LOCATION_SHIFT 18
+MID_VCI_MODE_SHIFT 30
+MID_VCI_SIZE_SHIFT 15
+MIIpmdShift 7
+MIIregShift 2
+MII_TG3_AUXCTL_MISC_RDSEL_SHIFT 12
+MIN_OCQP_SHIFT 12
+MINORBITS 20
+MIN_PBL_SHIFT 8
+MIN_RQT_SHIFT 10
+MISC_REGISTERS_GPIO_3 3
+MISC_REGISTERS_GPIO_CLR_POS 16
+MISC_REGISTERS_GPIO_FLOAT_POS 24
+MISC_REGISTERS_GPIO_INT_CLR_POS 24
+MISC_REGISTERS_GPIO_INT_SET_POS 16
+MISC_REGISTERS_GPIO_SET_POS 8
+MISC_SPIO_CLR_POS 16
+MISC_SPIO_FLOAT_POS 24
+MISC_SPIO_INT_OLD_SET_POS 16
+MISC_SPIO_SET_POS 8
+MI_STORE_DWORD_INDEX_SHIFT 2
+MIXART_MOTHERBOARD_ELF_INDEX 1
+MIXART_NOTIFY_CARD_OFFSET 12
+MIXART_NOTIFY_PCM_OFFSET 8
+ML_BITS 4
+MLX4_CMPT_SHIFT 24
+MLX4_EVENT_TYPE_PORT_MNG_CHG_EVENT 29
+MLX4_RSS_QPC_FLAG_OFFSET 13
+MLX4_UPD_QP_PATH_MASK_ETH_RX_BLOCK_1P 43
+MLX4_UPD_QP_PATH_MASK_ETH_RX_BLOCK_TAGGED 44
+MLX4_UPD_QP_PATH_MASK_ETH_RX_BLOCK_UNTAGGED 42
+MLX4_UPD_QP_PATH_MASK_ETH_TX_BLOCK_1P 40
+MLX4_UPD_QP_PATH_MASK_ETH_TX_BLOCK_TAGGED 41
+MLX4_UPD_QP_PATH_MASK_ETH_TX_BLOCK_UNTAGGED 39
+MLX4_UPD_QP_PATH_MASK_SCHED_QUEUE 46
+MLX4_UPD_QP_PATH_MASK_VLAN_INDEX 37
+MLX5_CMD_DATA 0
+MLX5_EVENT_TYPE_CMD 10
+MLX5_EVENT_TYPE_PAGE_REQUEST 11
+MLX5_IB_MMAP_CMD_SHIFT 8
+MLX5_IB_SQ_STRIDE 6
+MMF_DUMPABLE 0
+MMF_DUMP_FILTER_SHIFT 2
+MMF_DUMP_SECURELY 1
+MMF_HAS_UPROBES 19
+MMF_RECALC_UPROBES 20
+MMF_VM_MERGEABLE 16
+MMIO_GEN_LOW_SHIFT 9
+MMIO_SPTE_GEN_HIGH_SHIFT 52
+MMIO_SPTE_GEN_LOW_SHIFT 3
+MM_SHIFT 6
+MODEL24_SHIFT 1
+MODE_SHIFT 5
+MPI_NIC_FUNCTION_SHIFT 6
+MPI_RESET_NEEDED 19
+MP_ISA_BUS 0
+MPU3050_PWR_MGM_POS 6
+MPU401_MODE_BIT_INPUT 0
+MPU401_MODE_BIT_OUTPUT 1
+MPU401_MODE_BIT_OUTPUT_TRIGGER 3
+MPX_MODE 3
+MR_COMPLETE 2
+MR_INPROGRESS 1
+MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT 4
+MR_START 0
+MSBD0_X_SHIFT 28
+MSBD0_Y_SHIFT 24
+MSBD1_SHIFT 24
+MSC_RAW 3
+MSC_SCAN 4
+MSI_ADDR_DEST_MODE_SHIFT 2
+MSI_DATA_TRIGGER_SHIFT 15
+MSPRO_BLOCK_PART_SHIFT 3
+MSR_C_LO_VID_SHIFT 8
+MSR_LINK_SHIFT 0
+MSRPM_ALLOC_ORDER 1
+MSSShift 16
+MS_X0_SHIFT 0
+MS_X1_SHIFT 8
+MS_X2_SHIFT 16
+MS_X3_SHIFT 0
+MS_X4_SHIFT 8
+MS_X5_SHIFT 16
+MS_Y0_SHIFT 4
+MS_Y1_SHIFT 12
+MS_Y2_SHIFT 20
+MS_Y3_SHIFT 4
+MS_Y4_SHIFT 12
+MS_Y5_SHIFT 20
+MTIP_ABAR 5
+MTIP_DDF_CLEANUP_BIT 5
+MTIP_DDF_INIT_DONE_BIT 7
+MTIP_DDF_OVER_TEMP_BIT 2
+MTIP_DDF_REBUILD_FAILED_BIT 8
+MTIP_DDF_REMOVE_PENDING_BIT 1
+MTIP_DDF_RESUME_BIT 6
+MTIP_DDF_SEC_LOCK_BIT 0
+MTIP_DDF_WRITE_PROTECT_BIT 3
+MTIP_PF_DM_ACTIVE_BIT 3
+MTIP_PF_EH_ACTIVE_BIT 1
+MTIP_PF_IC_ACTIVE_BIT 0
+MTIP_PF_ISSUE_CMDS_BIT 5
+MTIP_PF_REBUILD_BIT 6
+MTIP_PF_SE_ACTIVE_BIT 2
+MTIP_PF_SVC_THD_ACTIVE_BIT 4
+MTIP_PF_SVC_THD_STOP_BIT 8
+MTIP_TAG_INTERNAL 0
+MT_ST_BLKSIZE_SHIFT 0
+MT_ST_DENSITY_SHIFT 24
+MT_ST_SOFTERR_SHIFT 0
+MTYPE_OFS 4
+MUSB_DEVCTL_VBUS_SHIFT 3
+MUSYCC_CCD_BUFFER_LENGTH 16
+MUSYCC_CCD_BUFFER_LOC 24
+MUSYCC_CCD_MAX_LENGTH 10
+MUSYCC_CCD_PROTO_SHIFT 12
+MVMDIO_SMI_DATA_SHIFT 0
+MVMDIO_SMI_PHY_ADDR_SHIFT 16
+MVMDIO_SMI_PHY_REG_SHIFT 21
+MV_PRIMARY_BAR 0
+MV_U3D_EPXCR_EP_ENABLE_SHIFT 4
+MV_U3D_EPXCR_MAX_BURST_SIZE_SHIFT 12
+MV_U3D_EPXCR_MAX_PACKET_SIZE_SHIFT 16
+MWAIT_SUBSTATE_SIZE 4
+NAK_OUT_PACKETS 4
+NAK_OUT_PACKETS 5
+NAK_OUT_PACKETS_MODE 2
+NAME_HASH_SHIFT 5
+NAPI_STATE_NPSVC 2
+NAPI_STATE_SCHED 0
+NCI_DATA_EXCHANGE_TO 3
+NCI_INIT 0
+NCI_SPI_ACK_SHIFT 6
+NCI_UP 1
+NES_CQP_APBVT_NIC_SHIFT 16
+NES_CQP_OP_LOGICAL_PORT_SHIFT 26
+NES_CQP_OP_TERMLEN_SHIFT 28
+NET2272_PCI_IRQ 0
+NET2272_RESET 0
+NET_CONGESTED 0
+NETDEV_MCAST_ALL_OFF 11
+NETDEV_MCAST_ALL_ON 10
+NETLBL_DOMHSH_BITSIZE 7
+NETQ_STOPPED 3
+NEW_CUR_UUID 17
+NF_ARP_NUMHOOKS 3
+NF_BR_BROUTING 5
+NF_BR_LOCAL_OUT 3
+NF_BR_NUMHOOKS 6
+NF_BR_PRE_ROUTING 0
+NFC_HCI_QUIRK_SHORT_CLEAR 0
+NFC_PROTO_NFC_DEP 5
+NFCWILINK_FW_DOWNLOAD 1
+NF_INET_FORWARD 2
+NF_INET_LOCAL_IN 1
+NF_INET_LOCAL_OUT 3
+NF_INET_NUMHOOKS 5
+NF_INET_POST_ROUTING 4
+NF_INET_PRE_ROUTING 0
+NFS4CLNT_BIND_CONN_TO_SESSION 10
+NFS4CLNT_CHECK_LEASE 1
+NFS4CLNT_DELEGRETURN 5
+NFS4CLNT_LEASE_CONFIRM 7
+NFS4CLNT_LEASE_EXPIRED 2
+NFS4CLNT_PURGE_STATE 9
+NFS4CLNT_RECLAIM_NOGRACE 4
+NFS4CLNT_RECLAIM_REBOOT 3
+NFS4CLNT_SERVER_SCOPE_MISMATCH 8
+NFS4CLNT_SESSION_RESET 6
+NFS4_SESSION_INITING 0
+NFS4_SLOT_TBL_DRAINING 0
+NFS_CONTEXT_BAD 2
+NFS_CONTEXT_ERROR_WRITE 0
+NFS_CONTEXT_RESEND_WRITES 1
+NFS_CS_CHECK_LEASE_TIME 5
+NFS_CS_MIGRATION 2
+NFS_CS_NORESVPORT 0
+NFS_CS_RENEWD 3
+NFS_CS_STOP_RENEW 4
+NFSD4_CLIENT_CB_KILL 1
+NFSD4_CLIENT_CB_UPDATE 0
+NFSD4_CLIENT_CONFIRMED 4
+NFSD4_CLIENT_STABLE 2
+NFS_DELEGATED_STATE 1
+NFS_DELEGATION_NEED_RECLAIM 0
+NFS_DELEGATION_REFERENCED 3
+NFS_DELEGATION_RETURN 1
+NFS_DELEGATION_RETURN_IF_CLOSED 2
+NFS_DELEGATION_RETURNING 4
+NFS_DEVICEID_INVALID 0
+NFS_DEVICEID_UNAVAILABLE 1
+NFS_INO_ADVISE_RDPLUS 0
+NFS_INO_FSCACHE 5
+NFS_INO_STALE 1
+NFS_IOHDR_EOF 1
+NFS_IOHDR_ERROR 0
+NFS_IOHDR_NEED_RESCHED 4
+NFS_IOHDR_REDO 2
+NFS_IO_INPROGRESS 0
+NFS_LAYOUT_BULK_RECALL 2
+NFS_LAYOUT_RETURN 4
+NFS_LAYOUT_ROC 3
+NFS_LOCK_INITIALIZED 0
+NFS_LSEG_ROC 1
+NFS_LSEG_VALID 0
+NFS_OPEN_STATE 2
+NFS_O_RDONLY_STATE 3
+NFS_O_RDWR_STATE 5
+NFS_OWNER_RECLAIM_NOGRACE 1
+NFS_OWNER_RECLAIM_REBOOT 0
+NFS_O_WRONLY_STATE 4
+NFS_STATE_POSIX_LOCKS 8
+NFS_STATE_RECLAIM_NOGRACE 7
+NFS_STATE_RECLAIM_REBOOT 6
+NFS_STATE_RECOVERY_FAILED 9
+NHMEX_M_PMON_CTL_INC_SEL_SHIFT 9
+NHMEX_R_PMON_CTL_EV_SEL_SHIFT 1
+NIG_LATCH_BC_ENABLE_MI_INT 0
+NIG_STATUS_XGXS0_LINK_STATUS_SIZE 18
+NILFS_I_BMAP 7
+NILFS_I_BUSY 3
+NILFS_I_COLLECTED 4
+NILFS_I_DIRTY 1
+NILFS_I_GCINODE 8
+NILFS_I_INODE_DIRTY 6
+NILFS_I_NEW 0
+NILFS_I_QUEUED 2
+NILFS_I_UPDATED 5
+NILFS_SC_DIRTY 0
+NILFS_SC_HAVE_DELTA 4
+NILFS_SC_PRIOR_FLUSH 3
+NILFS_SC_SUPER_ROOT 2
+NILFS_SC_UNCLOSED 1
+NILFS_SEGMENT_USAGE_ACTIVE 0
+NILFS_SEGMENT_USAGE_ERROR 2
+NM_VECTOR 7
+NO_DECELERATION 1
+NO_FILTER 5
+NOHZ_TICK_STOPPED 0
+NOSV 7
+NOT_MASKED_PD_BITS 17
+NPIV_CONFIG_NEEDED 16
+NR_FSCACHE_OBJECT_EVENTS 7
+NR_MOVE_TYPE 2
+NR_PAGEFLAGS 25
+NR_SHAPERS 16
+NTP_SCALE_SHIFT 32
+NUM_MAC_INDEX_DRIVER 4
+NUM_NL80211_IFTYPES 11
+NUM_TSF_IDS 4
+NUM_TSSI_FRAMES 4
+NUM_VCI_BITS 10
+NUM_VPI_BITS 0
+NVDEV_ENGINE_DEVICE 0
+NVDEV_ENGINE_DMAOBJ 18
+NVM_COMB_VER_SHFT 8
+NVME_CC_MPS_SHIFT 7
+NVM_ETRACK_SHIFT 16
+NV_MMIO_BAR 5
+NVREG_ADAPTCTL_PHYSHIFT 24
+NVREG_BKOFFCTRL_GEAR 12
+NVREG_BKOFFCTRL_SELECT 24
+NVREG_MIICTL_ADDRSHIFT 5
+NVREG_RINGSZ_RXSHIFT 16
+NVREG_RINGSZ_TXSHIFT 0
+NV_TX2_TSO_SHIFT 14
+NWD_SHIFT 4
+__NX_DEV_UP 1
+OBJ_REQ_EXISTS 3
+OBJ_REQ_KNOWN 2
+OCFS2_HASH_SHIFT 5
+OCRDMA_ALLOC_LKEY_FMR_SHIFT 1
+OCRDMA_ALLOC_LKEY_LOCAL_WR_SHIFT 5
+OCRDMA_ALLOC_LKEY_PBL_SIZE_SHIFT 16
+OCRDMA_ALLOC_LKEY_REMOTE_ATOMIC_SHIFT 6
+OCRDMA_ALLOC_LKEY_REMOTE_RD_SHIFT 4
+OCRDMA_ALLOC_LKEY_REMOTE_WR_SHIFT 3
+OCRDMA_CREATE_AH_ENTRY_SIZE_SHIFT 23
+OCRDMA_CREATE_AH_NUM_PAGES_SHIFT 19
+OCRDMA_CREATE_AH_PAGE_SIZE_SHIFT 16
+OCRDMA_CREATE_CQ_CNT_SHIFT 27
+OCRDMA_CREATE_CQ_EQID_SHIFT 22
+OCRDMA_CREATE_CQ_PAGE_SIZE_SHIFT 16
+OCRDMA_CREATE_CQ_TYPE_SHIFT 24
+OCRDMA_CREATE_EQ_CNT_SHIFT 26
+OCRDMA_CREATE_MQ_CQ_ID_SHIFT 16
+OCRDMA_CREATE_MQ_RING_SIZE_SHIFT 16
+OCRDMA_CREATE_QP_REQ_DPP_CREDIT_SHIFT 16
+OCRDMA_CREATE_QP_REQ_MAX_IRD_SHIFT 0
+OCRDMA_CREATE_QP_REQ_MAX_ORD_SHIFT 16
+OCRDMA_CREATE_QP_REQ_MAX_RQE_SHIFT 0
+OCRDMA_CREATE_QP_REQ_MAX_SGE_RECV_SHIFT 16
+OCRDMA_CREATE_QP_REQ_MAX_SGE_SEND_SHIFT 16
+OCRDMA_CREATE_QP_REQ_MAX_SGE_WRITE_SHIFT 0
+OCRDMA_CREATE_QP_REQ_MAX_WQE_SHIFT 16
+OCRDMA_CREATE_QP_REQ_NUM_RQ_PAGES_SHIFT 0
+OCRDMA_CREATE_QP_REQ_NUM_WQ_PAGES_SHIFT 16
+OCRDMA_CREATE_QP_REQ_PD_ID_SHIFT 0
+OCRDMA_CREATE_QP_REQ_QPT_SHIFT 29
+OCRDMA_CREATE_QP_REQ_RQ_CQID_SHIFT 0
+OCRDMA_CREATE_QP_REQ_RQE_SIZE_SHIFT 0
+OCRDMA_CREATE_QP_REQ_RQ_PAGE_SIZE_SHIFT 19
+OCRDMA_CREATE_QP_REQ_SQ_PAGE_SIZE_SHIFT 16
+OCRDMA_CREATE_QP_REQ_WQ_CQID_SHIFT 16
+OCRDMA_CREATE_QP_REQ_WQE_SIZE_SHIFT 16
+OCRDMA_CREATE_SRQ_MAX_SGE_RECV_SHIFT 16
+OCRDMA_CREATE_SRQ_NUM_RQ_PAGES_SHIFT 16
+OCRDMA_CREATE_SRQ_PG_SZ_SHIFT 16
+OCRDMA_CREATE_SRQ_RQE_SIZE_SHIFT 0
+OCRDMA_DB_CQ_RING_ID_EXT_MASK_SHIFT 1
+OCRDMA_DESTROY_CQ_QID_SHIFT 0
+OCRDMA_MCH_SUBSYS_SHIFT 8
+OCRDMA_MODIFY_SRQ_LIMIT_SHIFT 16
+OCRDMA_MQE_HDR_EMB_SHIFT 0
+OCRDMA_QP_PARAMS_ACK_TIMEOUT_SHIFT 27
+OCRDMA_QP_PARAMS_HOP_LMT_SHIFT 24
+OCRDMA_QP_PARAMS_MAX_ORD_SHIFT 16
+OCRDMA_QP_PARAMS_PATH_MTU_SHIFT 18
+OCRDMA_QP_PARAMS_RETRY_CNT_SHIFT 24
+OCRDMA_QP_PARAMS_RNR_NAK_TIMER_SHIFT 27
+OCRDMA_QP_PARAMS_RNR_RETRY_CNT_SHIFT 24
+OCRDMA_QP_PARAMS_STATE_SHIFT 5
+OCRDMA_QP_PARAMS_TCLASS_SHIFT 24
+OCRDMA_QP_PARAMS_VLAN_SHIFT 16
+OCRDMA_REG_NSMR_BIND_MEMWIN_SHIFT 24
+OCRDMA_REG_NSMR_CONT_LAST_SHIFT 31
+OCRDMA_REG_NSMR_CONT_NUM_PBL_SHIFT 16
+OCRDMA_REG_NSMR_HPAGE_SIZE_SHIFT 16
+OCRDMA_REG_NSMR_LAST_SHIFT 31
+OCRDMA_REG_NSMR_LOCAL_WR_SHIFT 29
+OCRDMA_REG_NSMR_NUM_PBL_SHIFT 16
+OCRDMA_REG_NSMR_REMOTE_ATOMIC_SHIFT 30
+OCRDMA_REG_NSMR_REMOTE_RD_SHIFT 28
+OCRDMA_REG_NSMR_REMOTE_WR_SHIFT 27
+OCRDMA_WQE_FLAGS_SHIFT 5
+OCRDMA_WQE_OPCODE_SHIFT 0
+OCRDMA_WQE_SIZE_SHIFT 18
+OCRDMA_WQE_TYPE_SHIFT 16
+OFDM_SC_RA_RAM_ECHO_THRES_2K__B 8
+OFDM_SC_RA_RAM_ECHO_THRES_8K__B 0
+OMAP_CTRL_USB_PWRCTL_CLK_CMD_SHIFT 14
+OMAP_CTRL_USB_PWRCTL_CLK_FREQ_SHIFT 22
+ONETOUCH_BUTTON 148
+OO_SHIFT 16
+OP_ANI_RUNNING 32
+OP_BT_PRIORITY_DETECTED 8
+OP_BT_SCAN 16
+OP_ENABLE_BEACON 4
+OP_INVALID 1
+OP_SCANNING 2
+OP_TSF_RESET 64
+OSD_OFFSET_MAX_BITS 28
+OSST_FRAME_SHIFT 6
+OSST_SECTOR_SHIFT 9
+OVS_KEY_ATTR_ARP 13
+OVS_KEY_ATTR_ENCAP 1
+OVS_KEY_ATTR_ETHERNET 4
+OVS_KEY_ATTR_ETHERTYPE 6
+OVS_KEY_ATTR_ICMP 11
+OVS_KEY_ATTR_ICMPV6 12
+OVS_KEY_ATTR_IN_PORT 3
+OVS_KEY_ATTR_IPV4 7
+OVS_KEY_ATTR_IPV6 8
+OVS_KEY_ATTR_ND 14
+OVS_KEY_ATTR_PRIORITY 2
+OVS_KEY_ATTR_SKB_MARK 15
+OVS_KEY_ATTR_TCP 9
+OVS_KEY_ATTR_TUNNEL 16
+OVS_KEY_ATTR_UDP 10
+OVS_KEY_ATTR_VLAN 5
+OXU_REV_SHIFT 16
+OXYGEN_AC97_REG_ADDR_SHIFT 16
+OXYGEN_AC97_REG_CODEC_SHIFT 24
+OXYGEN_A_MONITOR_ROUTE_0_SHIFT 0
+OXYGEN_A_MONITOR_ROUTE_1_SHIFT 2
+OXYGEN_A_MONITOR_ROUTE_2_SHIFT 4
+OXYGEN_A_MONITOR_ROUTE_3_SHIFT 6
+OXYGEN_MULTICH_FORMAT_SHIFT 2
+OXYGEN_PLAY_DAC0_SOURCE_SHIFT 8
+OXYGEN_PLAY_DAC1_SOURCE_SHIFT 10
+OXYGEN_PLAY_DAC2_SOURCE_SHIFT 12
+OXYGEN_PLAY_DAC3_SOURCE_SHIFT 14
+OXYGEN_REC_FORMAT_A_SHIFT 0
+OXYGEN_REC_FORMAT_B_SHIFT 2
+OXYGEN_REC_FORMAT_C_SHIFT 4
+OXYGEN_SPDIF_CATEGORY_SHIFT 4
+OXYGEN_SPDIF_CS_RATE_SHIFT 12
+OXYGEN_SPDIF_FORMAT_SHIFT 0
+OXYGEN_SPDIF_OUT_RATE_SHIFT 24
+OXYGEN_SPI_CODEC_SHIFT 4
+OZ_VERSION_SHIFT 2
+P0_EN_1V0X_LBN 0
+P0_EN_1V2_LBN 1
+P0_EN_2V5_LBN 2
+P0_EN_3V3X_LBN 3
+P0_EN_5V_LBN 4
+P0_X_TRST_LBN 6
+P1_AFE_PWD_LBN 0
+P1_DSP_PWD25_LBN 1
+P1_SPARE_LBN 4
+PACKET_LRA_VALID 3
+PACKET_MERGE_SEGS 4
+PACKET_NWA_VALID 2
+PACKET_WRITABLE 1
+PA_CTRL_APALP 4
+PA_CTRL_APAPRECH 5
+PAGE_ALLOC_COSTLY_ORDER 3
+PAGE_CACHE_SHIFT 12
+PAGE_SHIFT 12
+PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_1_SHIFT 3
+PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_2_SHIFT 5
+PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT 4
+PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT 2
+PANEL_LIGHT_OFF_DELAY_SHIFT 0
+PANEL_LIGHT_ON_DELAY_SHIFT 0
+PANEL_POWER_CYCLE_DELAY_SHIFT 0
+PANEL_POWER_DOWN_DELAY_SHIFT 16
+PANEL_POWER_UP_DELAY_SHIFT 16
+PART_BITS 4
+PARTN_BITS 6
+PASS_ACCEPT_REQ 4
+PASS_ESTAB 5
+PBC_PORT_SEL_LSB 26
+PBC_VL_NUM_LSB 27
+PCAP_ADC_ADA1_SHIFT 4
+PCAP_ADC_ADA2_SHIFT 7
+PCAP_ADC_TS_M_SHIFT 17
+PCAP_IRQ_ADCDONE2 20
+PCAP_REGISTER_ADDRESS_SHIFT 26
+PCCRX_SHIFT 8
+PCCRXTO_SHIFT 16
+PCCTX_SHIFT 8
+PCCTXTO_SHIFT 16
+PCH_BIT_SJW_SHIFT 6
+PCH_BIT_TSEG1_SHIFT 8
+PCH_BIT_TSEG2_SHIFT 12
+PCH_GBE_MIIM_PHY_ADDR_SHIFT 21
+PCH_GBE_MIIM_REG_ADDR_SHIFT 16
+PCH_GBE_PCI_BAR 1
+PCI_BASE2_RANGE 16
+_PCIB_op_pending 1
+PCI_ENABLE 5
+PCI_INTERRUPT_ENABLE 31
+PCI_INTERRUPT_ENABLE 8
+PCI_LTR_SCALE_SHIFT 10
+PCI_MASTER_ABORT_RECEIVED_INTERRUPT_ENABLE 20
+PCI_NUM_RESOURCES 17
+PCI_RETRY_ABORT_INTERRUPT_ENABLE 17
+PCI_TARGET_ABORT_RECEIVED_INTERRUPT_ENABLE 19
+PCM_MULTICH 4
+PCM_SPDIF 3
+PCS_FW_HEARTB_WIDTH 8
+PCS_UC_STATUS_LBN 0
+PCS_UC_STATUS_WIDTH 8
+PCTL_LINK_OFFS 16
+PCXHR_DSP_RESET_GPO_OFFSET 5
+PCXHR_FIRMWARE_DSP_EPRM_INDEX 2
+PCXHR_FIRMWARE_DSP_MAIN_INDEX 4
+PCXHR_FIRMWARE_XLX_COM_INDEX 1
+PCXHR_PIPE_STATE_CAPTURE_OFFSET 12
+PCXHR_SELMIC_PREAMPLI_OFFSET 2
+PD_BITS 4
+PDC_DIMM_BAR 4
+PDC_MMIO_BAR 3
+PDC_MMIO_BAR 5
+PEER_ABORT 12
+PEER_CLOSE 13
+PERSISTENT_GNT_ACTIVE 0
+PERSISTENT_GNT_WAS_ACTIVE 1
+PFIT_HORIZ_SCALE_SHIFT 4
+PFIT_PIPE_SHIFT 29
+PFIT_VERT_SCALE_SHIFT 20
+PF_VECTOR 14
+PG_active 6
+PG_CLEAN 2
+PG_COMMIT_TO_DS 5
+PG_dirty 4
+PG_error 1
+PG_LEVEL_1G 3
+PG_LEVEL_2M 2
+PG_locked 0
+PG_lru 5
+PG_MAPPED 1
+PG_mlocked 21
+PG_private 11
+PG_reclaim 18
+PG_referenced 2
+PG_reserved 10
+PG_swapbacked 19
+PG_uptodate 3
+PG_writeback 13
+PHYAD_SHIFT 8
+PHY_CTX_SHIFT 6
+PHYID1_OUI_SHFT 6
+PHY_TXC1_MODE_SHIFT 3
+PHY_TXC_ANT_SHIFT 6
+PIC_CASCADE_IR 2
+PI_CONS_V_XMT_INDEX 16
+PI_IO_CMP_V_SLOT 4
+PIIX_SIDPR_BAR 5
+PIPE_A 0
+PIPE_B 1
+PIPE_C 2
+PI_RCV_DESCR_V_SEG_LEN 23
+PI_XMT_DESCR_V_SEG_LEN 16
+PKT_CLASSIFICATION_USER_PRIORITY_VALID 0
+PKT_CLASSIFICATION_VLANID_VALID 1
+PKTSShift 11
+PLAYBACK_URB_COMPLETED 7
+PLLCLK_IN_SHIFT 4
+PLLD_LSB_SHIFT 2
+PLLD_MSB_SHIFT 0
+PLLJ_SHIFT 2
+PLL_LOAD_PULSE_PHASE_SHIFT 9
+PLLQ_SHIFT 3
+PLL_REF_SDVO_HDMI_MULTIPLIER_SHIFT 9
+PLL_REGM_F_SHIFT 0
+PLL_REGM_SHIFT 9
+PLL_REGN_SHIFT 1
+PLLR_SHIFT 0
+PLL_SD_SHIFT 9
+PLL_SELFREQDCO_SHIFT 1
+PM8607_IRQ_CC 5
+PM8607_IRQ_ONKEY 0
+PM8607_IRQ_RTC 4
+PMA_PMD_EXT_SSR_LBN 15
+PMA_PMD_FTX_STATIC_LBN 13
+PMA_PMD_LNPGA_POWERDOWN_LBN 8
+PMA_PMD_RXIN_SEL_LBN 6
+PMU_XTALFREQ_REG_MEASURE_SHIFT 31
+PORT_BASED_PRIORITY_SHIFT 3
+PORT_DEVSLP_DETO_OFFSET 2
+PORT_DEVSLP_DITO_OFFSET 15
+PORT_DEVSLP_MDAT_OFFSET 10
+PORT_FBS_DEV_OFFSET 8
+PORT_IRQ_RAW_SHIFT 16
+PPOD_IDX_SHIFT 6
+PPOD_SIZE_SHIFT 6
+PP_REFERENCE_DIVIDER_SHIFT 8
+PPR_STATUS_SHIFT 12
+PRB_MX_ADDR_MOD_SEL_SHIFT 9
+PRISM2_INFO_PENDING_LINKSTATUS 0
+PRISM2_INFO_PENDING_SCANRESULTS 1
+PRIVATE_DTMF_TONE 5
+PRIVATE_ECHO_CANCELLER 0
+PRIVATE_FAX_NONSTANDARD 8
+PRIVATE_FAX_PAPER_FORMATS 6
+PRIVATE_FAX_SUB_SEP_PWD 3
+PRIVATE_PIAFS 29
+PRIVATE_RTP 1
+PRIVATE_T38 2
+PRIVATE_V18 4
+PRIVATE_VOWN 7
+PROFILE_GRPSHIFT 3
+PSS_SHIFT 12
+PSZ_CIF 4
+PSZ_QCIF 2
+PSZ_QSIF 1
+PSZ_SIF 3
+PSZ_SQCIF 0
+PSZ_VGA 5
+PTE_FILE_MAX_BITS 46
+PT_OPT_FLAG_SHIFT 3
+PTP_STNSUR_ADDSUB_SHIFT 31
+PVR2_CVAL_INPUT_COMPOSITE 2
+PVR2_CVAL_INPUT_DTV 1
+PVR2_CVAL_INPUT_RADIO 4
+PVR2_CVAL_INPUT_SVIDEO 3
+PVR2_CVAL_INPUT_TV 0
+PWIDX_ADC 0
+PWIDX_CLFE 2
+PWIDX_FRONT 1
+PWIDX_MIC 4
+PWIDX_SURR 3
+PWMF_REQUESTED 1
+PWM_NCHAN 4
+QDF_CHANGE 1
+QDF_LOCKED 2
+QDF_REFRESH 3
+__QDISC_STATE_DEACTIVATED 1
+QFQ_MAX_WSHIFT 10
+QFQ_MTU_SHIFT 16
+QIB_7220_RcvCtrl_RcvQPMapEnable_LSB 38
+QIB_7220_SendDmaLenGen_Generation_MSB 18
+QIB_7322_SendDmaLenGen_0_Generation_MSB 18
+QIB_AETH_CREDIT_SHIFT 24
+QIB_CTXT_MASTER_UNINIT 4
+QIB_CTXT_WAITING_RCV 2
+QIB_CTXT_WAITING_URG 5
+QIB_EEPROM_WEN_NUM 14
+_QIB_EVENT_DISARM_BUFS_BIT 0
+QIB_R_REWIND_SGE 1
+QIB_R_WRID_VALID 0
+QIF_DQBLKSIZE_BITS 10
+QL_ADAPTER_UP 0
+QL_ADAPTER_UP 7
+QL_ALLMULTI 6
+QL_ALLOC_BUFQS_DONE 11
+QL_ALLOC_REQ_RSP_Q_DONE 10
+QL_ALLOC_SMALL_BUF_DONE 12
+QL_ASIC_RECOVERY 14
+QLC_83XX_IDC_COMP_AEN 3
+QLC_83XX_MBX_READY 2
+QLC_83XX_MODULE_LOADED 1
+QL_CAM_RT_SET 8
+QLC_BC_CFREE 1
+QLC_BC_FLR 2
+QLC_BC_MSG 0
+QLC_BC_VF_FLR 4
+QLC_BC_VF_SOFT_FLR 5
+QLC_BC_VF_STATE 3
+__QLCNIC_AER 5
+__QLCNIC_DEV_UP 1
+__QLCNIC_DIAG_RES_ALLOC 6
+__QLCNIC_FW_ATTACHED 0
+__QLCNIC_RESETTING 2
+__QLCNIC_SRIOV_CAPABLE 11
+__QLCNIC_SRIOV_ENABLE 10
+__QLCNIC_START_FW 4
+QL_DMA64 4
+QL_EEH_FATAL 12
+QL_FRC_COREDUMP 11
+QL_LB_LINK_UP 10
+QL_LINK_MASTER 6
+QL_LINK_OPTICAL 13
+QL_MSI_ENABLED 14
+QL_MSI_ENABLED 2
+QL_MSIX_ENABLED 3
+QLOGIC_IB_HWE_PCIEMEMPARITYERR_SHIFT 0
+QLOGIC_IB_IBCC_LINKCMD_SHIFT 18
+QLOGIC_IB_IBCC_LINKINITCMD_SHIFT 16
+QLOGIC_IB_I_RCVAVAIL_SHIFT 0
+QLOGIC_IB_I_RCVAVAIL_SHIFT 12
+QLOGIC_IB_I_RCVURG_SHIFT 0
+QLOGIC_IB_I_RCVURG_SHIFT 32
+QLOGIC_IB_R_INTRAVAIL_SHIFT 16
+QLOGIC_IB_R_TAILUPD_SHIFT 31
+QLOGIC_IB_SENDPIOAVAIL_BUSY_SHIFT 1
+QL_PORT_CFG 7
+QL_PROMISCUOUS 5
+QL_RESET_ACTIVE 2
+QL_RESET_DONE 1
+QL_RESET_PER_SCSI 4
+QL_RESET_START 3
+QL_SELFTEST 9
+QP_REFERENCED 5
+QSFP_GPIO_PORT2_SHIFT 5
+QS_MMIO_BAR 4
+QUEUE_FLAG_BIDI 7
+QUEUE_FLAG_DISCARD 14
+QUEUE_FLAG_NONROT 12
+QUEUE_PAUSED 1
+QUN 4
+QUOTABLOCK_BITS 10
+R10BIO_Degraded 4
+R10BIO_IsRecover 2
+R10BIO_IsReshape 3
+R10BIO_IsSync 1
+R10BIO_MadeGood 6
+R10BIO_Previous 8
+R10BIO_ReadError 5
+R10BIO_Uptodate 0
+R10BIO_WriteError 7
+R1BIO_BehindIO 3
+R1BIO_Degraded 2
+R1BIO_IsSync 1
+R1BIO_MadeGood 7
+R1BIO_ReadError 4
+R1BIO_Uptodate 0
+R1BIO_WriteError 8
+R300_MC_DISP0R_INIT_LAT_SHIFT 8
+R300_MC_DISP1R_INIT_LAT_SHIFT 12
+R300_MSBD0_X_SHIFT 28
+R300_MSBD0_Y_SHIFT 24
+R300_MSBD1_SHIFT 24
+R300_MS_X0_SHIFT 0
+R300_MS_X1_SHIFT 8
+R300_MS_X2_SHIFT 16
+R300_MS_X3_SHIFT 0
+R300_MS_X4_SHIFT 8
+R300_MS_X5_SHIFT 16
+R300_MS_Y0_SHIFT 4
+R300_MS_Y1_SHIFT 12
+R300_MS_Y2_SHIFT 20
+R300_MS_Y3_SHIFT 4
+R300_MS_Y4_SHIFT 12
+R300_MS_Y5_SHIFT 20
+R592_TPC_EXEC_LEN_SHIFT 16
+R592_TPC_EXEC_TPC_SHIFT 28
+R5_Discard 23
+R5_DOUBLE_LOCKED 2
+R5_Expanded 11
+R5_Insync 4
+R5_LOCKED 1
+R5_MadeGood 18
+R5_MadeGoodRepl 20
+R5_NeedReplace 21
+R5_Overlap 7
+R5_OVERWRITE 3
+R5_ReadError 9
+R5_ReadNoMerge 8
+R5_ReadRepl 19
+R5_ReWrite 10
+R5_SyncIO 16
+R5_UPTODATE 0
+R5_Wantcompute 12
+R5_Wantdrain 14
+R5_Wantfill 13
+R5_WantFUA 15
+R5_Wantread 5
+R5_WantReplace 22
+R5_Wantwrite 6
+R5_WriteError 17
+RADEON_ACTIVE_HILO_LAT_SHIFT 13
+RADEON_BLANK_LEVEL_SHIFT 8
+RADEON_CRT1_CRTC_SHIFT 9
+RADEON_CRT2_CRTC_SHIFT 12
+RADEON_CRTC2_PIX_WIDTH_SHIFT 8
+RADEON_CRTC_H_DISP_SHIFT 16
+RADEON_CRTC_H_SYNC_STRT_CHAR_SHIFT 3
+RADEON_CRTC_H_TOTAL_SHIFT 0
+RADEON_CRTC_V_DISP_SHIFT 16
+RADEON_CRTC_V_SYNC_STRT_SHIFT 0
+RADEON_CRTC_V_TOTAL_SHIFT 0
+RADEON_CY_FILT_BLEND_SHIFT 28
+RADEON_DAC_FORCE_DATA_SHIFT 8
+RADEON_DFP1_CRTC_SHIFT 11
+RADEON_DFP2_CRTC_SHIFT 14
+RADEON_DPM_AUTO_THROTTLE_SRC_EXTERNAL 1
+RADEON_DPM_AUTO_THROTTLE_SRC_THERMAL 0
+RADEON_FIFORAM_FFMACRO_READ_MARGIN_SHIFT 20
+RADEON_GPU_PAGE_SHIFT 12
+RADEON_GRPH_START_REQ_SHIFT 0
+RADEON_GRPH_STOP_REQ_SHIFT 8
+RADEON_H_INC_SHIFT 0
+RADEON_I2C_PRESCALE_SHIFT 16
+RADEON_LCD1_CRTC_SHIFT 8
+RADEON_LVDS_BL_MOD_LEVEL_SHIFT 8
+RADEON_LVDS_PWRSEQ_DELAY1_SHIFT 16
+RADEON_LVDS_PWRSEQ_DELAY2_SHIFT 20
+RADEON_NUM_VERTICES_SHIFT 16
+RADEON_PCIE_LC_LINK_WIDTH_RD_SHIFT 4
+RADEON_PCIE_LC_LINK_WIDTH_SHIFT 0
+RADEON_SET_UP_LEVEL_SHIFT 16
+RADEON_SPLL_FB_DIV_SHIFT 16
+RADEON_SPLL_PVG_SHIFT 11
+RADEON_TV1_CRTC_SHIFT 10
+RADEON_TV_DAC_BGADJ_SHIFT 16
+RADEON_TV_DAC_DACADJ_SHIFT 20
+RADEON_TV_FORCE_DAC_DATA_SHIFT 16
+RADEON_TV_M0HI_SHIFT 18
+RADEON_TV_N0HI_SHIFT 21
+RADEON_TV_N0LO_SHIFT 8
+RADEON_TVPCP_SHIFT 8
+RADEON_TVPDC_SHIFT 14
+RADEON_TV_P_SHIFT 24
+RADEON_TVPVG_SHIFT 11
+RADEON_TV_V_BURST_LEVEL_SHIFT 16
+RADEON_UV_OUTPUT_POST_SCALE_SHIFT 24
+RADEON_UVRAM_READ_MARGIN_SHIFT 16
+RADEON_Y_DEL_W_SIG_SHIFT 26
+RADIO_2055_NBRSSI_VCM_I_SHIFT 0
+RADIO_2055_NBRSSI_VCM_Q_SHIFT 0
+RADIO_2055_WBRSSI_VCM_IQ_SHIFT 2
+RADIO_2056_RSSI_VCM_SHIFT 2
+RAMROD_CONT 6
+RAMROD_DRV_CLR_ONLY 3
+RAMROD_EXEC 5
+RAMROD_RX 1
+RAMROD_TX 0
+RATELIMIT_CALC_SHIFT 10
+RATE_MCS_ANT_POS 14
+RATIO_SCALE_LOG 8
+RB_BUFFERS_DISABLED_BIT 1
+RBD_DEV_FLAG_EXISTS 0
+RBIO_CACHE_READY_BIT 3
+RBIO_RMW_LOCKED_BIT 1
+RBP_IDX_OFFSET 6
+RBR_CFIG_B_BLKSIZE_SHIFT 24
+RBR_CFIG_B_BUFSZ0_SHIFT 0
+RBR_CFIG_B_BUFSZ1_SHIFT 8
+RBR_CFIG_B_BUFSZ2_SHIFT 16
+RBSShift 0
+RC_MODEL_TOTAL_BITS 11
+RC_PID_ARITH_SHIFT 8
+RCR_ENTRY_PKT_BUF_ADDR_SHIFT 6
+RCR_FIFO_OFFSET 13
+RC_SHIFT_BITS 8
+RC_TOP_BITS 24
+RCV_LAZY_FC_SHIFT 24
+RDC_RED_PARA_THRE_SHIFT 4
+RDC_RED_PARA_THRE_SYN_SHIFT 20
+RDC_RED_PARA_WIN_SHIFT 0
+RDC_RED_PARA_WIN_SYN_SHIFT 16
+RDMACTXT_F_FAST_UNREG 1
+RDMACTXT_F_LAST_CTXT 2
+RDMAXPRT_CONN_PENDING 3
+RDMAXPRT_RQ_PENDING 1
+RDMAXPRT_SQ_PENDING 2
+RDS_LL_SEND_FULL 0
+RDS_MSG_ACK_REQUIRED 4
+RDS_MSG_HAS_ACK_SEQ 3
+RDS_MSG_MAPPED 6
+RDS_MSG_ON_CONN 2
+RDS_MSG_ON_SOCK 1
+RDS_MSG_PAGEVEC 7
+RDS_MSG_RETRANSMITTED 5
+RDS_RECONNECT_PENDING 1
+READ_LOC_AMP_ASSOC 1
+READ_LOC_AMP_ASSOC_FINAL 2
+READ_LOC_AMP_INFO 0
+RECOVERY_CLEANUP 8
+RED_LED 1
+RED_LED 2
+REDUCE_REPORTING 3
+REGISTER_FC4_NEEDED 9
+REGISTER_FDMI_NEEDED 12
+reg_ofdm_rst_pos 1
+REISERFS_3_5 0
+REISERFS_3_6 1
+REISERFS_ATTRS 14
+REISERFS_BARRIER_FLUSH 19
+REISERFS_BARRIER_NONE 18
+REISERFS_CONVERT 3
+REISERFS_DATA_LOG 8
+REISERFS_DATA_ORDERED 9
+REISERFS_DATA_WRITEBACK 10
+REISERFS_ERROR_CONTINUE 22
+REISERFS_ERROR_PANIC 20
+REISERFS_ERROR_RO 21
+REISERFS_EXPOSE_PRIVROOT 17
+REISERFS_GRPQUOTA 24
+REISERFS_HASHED_RELOCATION 13
+REISERFS_LARGETAIL 0
+REISERFS_NO_BORDER 11
+REISERFS_NO_UNHASHED_RELOCATION 12
+REISERFS_OLD_FORMAT 2
+REISERFS_OPT_ALLOWEMPTY 31
+REISERFS_POSIXACL 16
+REISERFS_SMALLTAIL 1
+REISERFS_TEST4 28
+REISERFS_UNSUPPORTED_OPT 29
+REISERFS_USRQUOTA 23
+REISERFS_XATTRS_USER 15
+RELEASE_RESOURCES 2
+REL_HWHEEL 6
+RELOGIN_NEEDED 8
+REL_WHEEL 8
+REL_X 0
+REL_Y 1
+REMOTE_WAKEUP_SUPPORT 5
+Replacement 10
+REPLAYONLY 2
+RESET_MARKER_NEEDED 0
+RESIZE_PENDING 16
+RESOLVE_CONFLICTS 1
+RESUME_INTERRUPT 1
+RESUME_INTERRUPT 5
+RESYNC_AFTER_NEG 15
+RETRY_LIMIT_LONG_SHIFT 0
+RETRY_LIMIT_SHORT_SHIFT 8
+RFCOMM_AUTH_ACCEPT 6
+RFCOMM_AUTH_PENDING 5
+RFCOMM_AUTH_REJECT 7
+RFCOMM_DEFER_SETUP 8
+RFCOMM_ENC_DROP 9
+RFCOMM_HANGUP_NOW 2
+RFCOMM_MSC_PENDING 3
+RFCOMM_RELEASE_ONHUP 1
+RFCOMM_REUSE_DLC 0
+RFCOMM_SEC_PENDING 4
+RFCOMM_TIMED_OUT 2
+RFCOMM_TTY_ATTACHED 3
+RFCOMM_TX_THROTTLED 1
+RH_OFS 0
+RISC_RESET_STATUS_SHIFT 20
+RISC_SET_STATUS_SHIFT 16
+ROAM_TBL_PEND 6
+ROOT_PORT_RESET_INTERRUPT 4
+ROOT_PORT_RESET_INTERRUPT 6
+ROOT_PORT_RESET_INTERRUPT_ENABLE 4
+ROOT_PORT_RESET_INTERRUPT_ENABLE 6
+R_OPCODE_LSB 3
+RPCAUTH_CRED_HASHED 2
+RPCAUTH_CRED_NEGATIVE 3
+RPCAUTH_CRED_NEW 0
+RPCAUTH_CRED_UPTODATE 1
+RPC_BC_PA_IN_USE 1
+RPC_TASK_ACTIVE 2
+Rpending 2
+RSCN_UPDATE 7
+RSCONFIG_MAX_DMA_SIZE_SHIFT 24
+RSCONFIG_STREAM_NUM_SHIFT 16
+RS_OFS 16
+RSPEC_BW_SHIFT 8
+RSPEC_STC_SHIFT 20
+RSPEC_STF_SHIFT 11
+RST_OFS 8
+RT5640_DMIC_CLK_SFT 5
+RT5640_I2S_BCLK_MS1_SFT 15
+RT5640_I2S_BCLK_MS2_SFT 11
+RT5640_I2S_PD1_SFT 12
+RT5640_I2S_PD2_SFT 8
+RT5640_PLL_M_BP_SFT 11
+RT5640_PLL_M_SFT 12
+RT5640_PLL_N_SFT 7
+RTC_RBUDR_SHIFT 4
+RTC_UDR_SHIFT 0
+R_TDI_LSB 2
+RT_IDX_IDX_SHIFT 8
+RT_IDX_TYPE_SHIFT 16
+RTL8150_HW_CRC 0
+RTL8150_UNPLUG 2
+RTL8152_SET_RX_MODE 2
+RTL8152_UNPLUG 0
+RTL_FLAG_TASK_ENABLED 0
+RTL_FLAG_TASK_RESET_PENDING 2
+RTL_STATUS_INTERFACE_START 0
+RTSCTS_SH_CTS_MOD_TYPE 24
+RTSCTS_SH_CTS_PMB_TYPE 25
+RTSCTS_SH_CTS_RATE 16
+RTSCTS_SH_RTS_MOD_TYPE 8
+RTSCTS_SH_RTS_PMB_TYPE 9
+RTSCTS_SH_RTS_RATE 0
+RTS_LEVEL_SHIFT_BITS 2
+RXBSIDH_SHIFT 3
+RxBufferLenShift 16
+RxBurstSizeShift 0
+RxComplThreshShift 0
+RXD_FLAGS_SHIFT 0
+RXD_LEN_SHIFT 0
+RX_DMA_CTL_STAT_PKTREAD_SHIFT 0
+RX_DMA_CTL_STAT_PTRREAD_SHIFT 16
+RXD_OPAQUE_INDEX_SHIFT 0
+RxDRNT_shift 1
+RxEarlyIntThreshShift 12
+RX_FLAG_STBC_SHIFT 26
+RX_FLOW_ON_BIT 2
+RxHighPrioThreshShift 8
+RX_LOG_PAGE_VLD_FUNC_SHIFT 2
+RxMinDescrThreshShift 0
+RxMXDMA_shift 20
+RXQ_CTRL_RFD_BURST_NUM_SHIFT 0
+RXQ_CTRL_RFD_PREF_MIN_IPG_SHIFT 16
+RXQ_CTRL_RRD_BURST_THRESH_SHIFT 8
+RXQ_JMBO_LKAH_SHIFT 11
+RXQ_JMBOSZ_TH_SHIFT 0
+RXQ_RFD_BURST_NUM_SHIFT 20
+RXQ_RRD_PAUSE_TH_HI_SHIFT 0
+RXQ_RRD_PAUSE_TH_LO_SHIFT 16
+RXQ_RRD_TIMER_SHIFT 16
+RXQ_RXF_PAUSE_TH_HI_SHIFT 0
+RXQ_RXF_PAUSE_TH_HI_SHIFT 16
+RXQ_RXF_PAUSE_TH_LO_SHIFT 0
+RXQ_RXF_PAUSE_TH_LO_SHIFT 16
+RXRPC_CALL_ABORT 7
+RXRPC_CALL_ACK_FINAL 4
+RXRPC_CALL_CONN_ABORT 8
+RXRPC_CALL_DRAIN_RX_OOS 11
+RXRPC_CALL_LIFE_TIMER 12
+RXRPC_CALL_POST_ACCEPT 15
+RXRPC_CALL_RCVD_ABORT 2
+RXRPC_CALL_RCVD_ACKALL 0
+RXRPC_CALL_RCVD_BUSY 1
+RXRPC_CALL_RCVD_ERROR 3
+RXRPC_CALL_RCVD_LAST 2
+RXRPC_CALL_RESEND 10
+RXRPC_CALL_RUN_RTIMER 3
+RXRPC_CALL_TERMINAL_MSG 1
+RXRPC_CALL_TX_SOFT_ACK 4
+RXRPC_CONN_CHALLENGE 0
+RXRPC_SOCK_EXCLUSIVE_CONN 1
+RX_URB_FAIL 1
+RX_URB_FAIL 3
+__S2IO_STATE_CARD_UP 1
+S5M8767_ENCTRL_SHIFT 6
+SA2400_REG4_FIRDAC_SHIFT 7
+S_ALIVE 6
+SAR_TBD_VCI_SHIFT 4
+SAR_TBD_VPI_SHIFT 20
+SAS_DEV_EH_PENDING 3
+SAS_DEV_FOUND 1
+SAS_DEV_GONE 0
+SAS_HA_ATA_EH_ACTIVE 2
+SAS_HA_DRAINING 1
+SAS_HA_FROZEN 3
+SAS_HA_REGISTERED 0
+SATA_PMP_CTRL_PORT 15
+SAVAGE_BD_BPP_SHIFT 16
+SAVAGE_BD_TILE_SHIFT 24
+SB_M_DIVIDER_SHIFT 24
+SB_N_CB_TUNE_SHIFT 24
+SB_N_DIVIDER_SHIFT 26
+SB_N_VCO_SEL_SHIFT 30
+SBSDIO_FUNC1_SLEEPCSR_KSO_SHIFT 0
+SBSDIO_FUNC1_WCTRL_HTWAIT_SHIFT 1
+SCAN_ABORTED 4
+SCAN_COMPLETED 3
+S_CHANNEL_SWITCH_PENDING 18
+SCHED_SCANNING 12
+SC_OP_ANI_RUN 2
+SC_OP_BEACONS 1
+SC_OP_HW_RESET 4
+SC_OP_INVALID 0
+SC_OP_PRIM_STA_VIF 3
+SC_OP_SCANNING 5
+SC_RA_RAM_BE_OPT_ENA_CP_OPT 1
+SCR_PENDING 21
+SCU_COMPLETION_TL_STATUS_SHIFT 22
+SCU_CONTEXT_COMMAND_LOGICAL_PORT_SHIFT 12
+SCU_CONTEXT_COMMAND_PROTOCOL_ENGINE_GROUP_SHIFT 16
+SCU_EVENT_SPECIFIC_CODE_SHIFT 18
+SCU_RAM_AGC_KI_IF__B 8
+SCU_RAM_AGC_KI_RED_IAGC_RED__B 4
+SCU_RAM_AGC_KI_RED_RAGC_RED__B 2
+SCU_RAM_AGC_KI_RF__B 4
+SD1_DVM_EN 6
+SD1_DVM_SHIFT 5
+SDATA_STATE_OFFCHANNEL 1
+SDATA_STATE_OFFCHANNEL_BEACON_STOPPED 2
+SDATA_STATE_RUNNING 0
+SDCLK_DELAY_SHIFT 10
+SDCLK_DELAY_SHIFT 9
+SDCLK_SEL_SHIFT 8
+SD_CTL_STREAM_TAG_SHIFT 20
+SDEV_EVT_MEDIA_CHANGE 1
+SDF_JOURNAL_CHECKED 0
+SDF_JOURNAL_LIVE 1
+SDF_NOBARRIERS 3
+SDF_NOJOURNALID 6
+SDF_NORECOVERY 4
+SDF_RORECOVERY 7
+SDF_SKIP_DLM_UNLOCK 8
+SDHCI_CLOCK_BASE_SHIFT 8
+SDHCI_DIVIDER_HI_SHIFT 6
+SDHCI_DIVIDER_SHIFT 8
+SDHCI_MAX_CURRENT_180_SHIFT 16
+SDHCI_MAX_CURRENT_300_SHIFT 8
+SDHCI_MAX_CURRENT_330_SHIFT 0
+SDHCI_TIMEOUT_CLK_SHIFT 0
+SDIO_DRIVE_DTSx_SHIFT 4
+SDIO_FUNC_1 1
+SDIO_FUNC_2 2
+SDMA_DESC_COUNT_LSB 16
+SDMA_DESC_GEN_LSB 30
+SDM_OP_GEN_AGG_VECT_IDX_VALID_SHIFT 16
+SDPCM_CHANNEL_SHIFT 8
+SDPCM_DOFFSET_SHIFT 24
+SDVO_MULTIPLIER_SHIFT_HIRES 4
+SDVO_PORT_MULTIPLY_SHIFT 23
+SECTION_NID_SHIFT 2
+SECTOR_BITS 9
+SECTOR_SHIFT 9
+SELF_POWERED_STATUS 0
+SELF_POWERED_USB_DEVICE 6
+SEM_FLASH_SHIFT 8
+SEM_ICB_SHIFT 4
+SEM_MAC_ADDR_SHIFT 6
+SEM_PROBE_SHIFT 10
+SEM_PROC_REG_SHIFT 14
+SEM_RT_IDX_SHIFT 12
+SEM_XGMAC0_SHIFT 0
+SEM_XGMAC1_SHIFT 2
+SEND_PING 2
+SEP_FASTCALL_WRITE_DONE_OFFSET 0
+SEP_LEGACY_MMAP_DONE_OFFSET 1
+SEP_LEGACY_POLL_DONE_OFFSET 3
+SEP_LEGACY_SENDMSG_DONE_OFFSET 2
+SEQNUM_SHIFT 4
+SERDES_CHANS 4
+SERPORT_ACTIVE 2
+SERPORT_DEAD 3
+SET_ADDRESS 13
+SET_ENDPOINT_HALT 8
+SET_NAK_OUT_PACKETS 15
+SET_NAK_OUT_PACKETS_MODE 10
+SET_TEST_MODE 16
+SETUP_PACKET_INTERRUPT 5
+SETUP_PACKET_INTERRUPT 7
+SETUP_PACKET_INTERRUPT_ENABLE 5
+SETUP_PACKET_INTERRUPT_ENABLE 7
+SE_VAP_CNTL__VF_MAX_VTX_NUM__SHIFT 18
+S_EXIT_PENDING 10
+SFQ_ALLOT_SHIFT 3
+S_FW_ERROR 17
+S_GEO_CONFIGURED 9
+SGTL5000_ANA_GND_SHIFT 4
+SGTL5000_BIAS_R_SHIFT 8
+SGTL5000_DAC_SEL_SHIFT 4
+SGTL5000_DAC_VOL_LEFT_SHIFT 0
+SGTL5000_DAC_VOL_RIGHT_SHIFT 8
+SGTL5000_I2S_DLEN_SHIFT 4
+SGTL5000_I2S_SCLKFREQ_SHIFT 8
+SGTL5000_LINE_OUT_CURRENT_SHIFT 8
+SGTL5000_LINE_OUT_GND_SHIFT 0
+SGTL5000_MCLK_FREQ_SHIFT 0
+SGTL5000_PLL_FRAC_DIV_SHIFT 0
+SGTL5000_PLL_INT_DIV_SHIFT 11
+SGTL5000_RATE_MODE_SHIFT 4
+SGTL5000_SYS_FS_SHIFT 2
+SGTL5000_VDDC_MAN_ASSN_SHIFT 6
+SHADOW_REG_SHIFT 20
+SHARED_HW_CFG_LED_MODE_SHIFT 16
+S_HCMD_ACTIVE 0
+SHIFT 11
+SHIFT_2 2
+SHIFT 8
+SHMEM_EEE_ADV_STATUS_SHIFT 20
+SHMEM_EEE_LP_ADV_STATUS_SHIFT 24
+SHMEM_EEE_SUPPORTED_SHIFT 16
+SHORT_PACKET_OUT_DONE_INTERRUPT 6
+SHORT_PACKET_TRANSFERRED_INTERRUPT 4
+SHORT_PACKET_TRANSFERRED_INTERRUPT 5
+SHORT_PACKET_TRANSFERRED_INTERRUPT_ENABLE 5
+SHUTDOWN_MERGE 1
+SI476X_DIGITAL_IO_SAMPLE_SIZE_SHIFT 8
+SI476X_DIGITAL_IO_SLOT_SIZE_SHIFT 11
+SI5351_OUTPUT_CLK_DIV_SHIFT 4
+SIDL_EXIDE_SHIFT 3
+SIDL_SID_SHIFT 5
+SIGNAL_ASENDER 3
+SIL164_CONTROL1_DESKEW_INCR_SHIFT 5
+SIL164_CONTROL2_FILTER_SETTING_SHIFT 1
+SIL164_DUALLINK_SKEW_SHIFT 5
+SIL24_HOST_BAR 0
+SIL24_PORT_BAR 2
+SIL680_MMIO_BAR 5
+SIL_MMIO_BAR 5
+S_INIT 5
+SIO_HI_RA_RAM_PAR_3_CFG_DBL_SCL__B 7
+SIO_PDR_MCLK_CFG_DRIVE__B 3
+SIO_PDR_MD0_CFG_DRIVE__B 3
+SIS_MM_ALIGN_SHIFT 0
+SIS_SCR_PCI_BAR 5
+SKB_DATAREF_SHIFT 16
+SK_F_HW_ERR 8
+SK_F_IPV6 5
+SK_F_OFFLD_COMPLETE 1
+SK_F_PG_OFFLD_COMPLETE 3
+SLF_ERROR 1
+SLF_ERROR 2
+SLF_ESCAPE 1
+SLF_INUSE 0
+SLF_KEEPTEST 3
+SLF_OUTWAIT 4
+SLICE_BITS 4
+SMB_DATA_VERSION_SHIFT 16
+SMBINTF_HWADDR_SHIFT 8
+SMBINTF_HWDATW_SHIFT 16
+SMC_NISLANDS_SPLL_DIV_TABLE_CLKS_SHIFT 20
+SMC_NISLANDS_SPLL_DIV_TABLE_CLKV_SHIFT 0
+SMC_NISLANDS_SPLL_DIV_TABLE_FBDIV_SHIFT 0
+SMC_NISLANDS_SPLL_DIV_TABLE_PDIV_SHIFT 25
+SMC_SISLANDS_SCALE_R 12
+SMC_SISLANDS_SPLL_DIV_TABLE_CLKS_SHIFT 20
+SMC_SISLANDS_SPLL_DIV_TABLE_CLKV_SHIFT 0
+SMC_SISLANDS_SPLL_DIV_TABLE_FBDIV_SHIFT 0
+SMC_SISLANDS_SPLL_DIV_TABLE_PDIV_SHIFT 25
+SMI_DATA_SHIFT 16
+SMP_FLAG_CFM_PENDING 2
+SMP_FLAG_MITM_AUTH 3
+SMP_FLAG_TK_VALID 1
+SMPL_EN_SHIFT 7
+SMPLT_SHIFT 2
+SNDRV_PCM_HW_PARAM_RATE 11
+SNDRV_PCM_HW_PARAM_SAMPLE_BITS 8
+SNDRV_PCM_STREAM_CAPTURE 1
+SNDRV_PCM_STREAM_PLAYBACK 0
+SNDRV_TIMER_EVENT_CONTINUE 4
+SNDRV_TIMER_EVENT_MCONTINUE 14
+SNDRV_TIMER_EVENT_MPAUSE 15
+SNDRV_TIMER_EVENT_MRESUME 18
+SNDRV_TIMER_EVENT_MSTART 12
+SNDRV_TIMER_EVENT_MSTOP 13
+SNDRV_TIMER_EVENT_MSUSPEND 17
+SNDRV_TIMER_EVENT_PAUSE 5
+SNDRV_TIMER_EVENT_RESOLUTION 0
+SNDRV_TIMER_EVENT_RESUME 8
+SNDRV_TIMER_EVENT_START 2
+SNDRV_TIMER_EVENT_STOP 3
+SNDRV_TIMER_EVENT_SUSPEND 7
+SNDRV_TIMER_EVENT_TICK 1
+SOCK_ASYNC_NOSPACE 0
+SOCK_ASYNC_WAITDATA 1
+SOCK_EXTERNALLY_ALLOCATED 5
+SOCK_NOSPACE 2
+SOCK_PASSCRED 3
+SOCK_PASSSEC 4
+SOCK_TIMESTAMPING_RX_SOFTWARE 19
+SOF_DOWN_INTERRUPT 14
+SOF_INTERRUPT 0
+SOF_INTERRUPT 7
+SOFTACK_MSHIFT 15
+SOFTACK_PSHIFT 16
+SPCR_RFIC_FIELD 20
+SPCR_TFIC_FIELD 16
+SPE_HDR_CONN_TYPE_SHIFT 0
+SPE_HDR_FUNCTION_ID_SHIFT 8
+SPI_FLASH_CTRL_CLK_HI_SHIFT 22
+SPI_FLASH_CTRL_CLK_LO_SHIFT 20
+SPI_FLASH_CTRL_CS_HI_SHIFT 16
+SPI_FLASH_CTRL_CS_HOLD_SHIFT 18
+SPI_FLASH_CTRL_CS_SETUP_SHIFT 24
+SPI_FLASH_CTRL_INS_SHIFT 8
+SPI_FRF_OFFSET 4
+SPI_MODE_OFFSET 6
+SPI_REG_SHIFT 9
+SPI_SS_OFF 2
+SPI_SS_ON 1
+SPI_TERMINATE 3
+SPI_TMOD_OFFSET 8
+SPI_XCOMM_SETTINGS_LEN_OFFSET 10
+SPI_XFER 0
+S_PORT 1
+S_POWER_PMI 16
+S_READY 7
+S_RFKILL 3
+S_RXCOALESCESIZE 0
+SSB_CHIPCO_PMU_CTL_ILP_DIV_SHIFT 16
+SSB_CHIPCO_PMU_CTL_XTALFREQ_SHIFT 2
+SSB_FLASH_WCNT_1_SHIFT 8
+SSB_FLASH_WCNT_3_SHIFT 24
+SSB_IMCFGLO_REQTO_SHIFT 4
+SSB_PMU0_PLLCTL1_WILD_FMSK_SHIFT 8
+SSB_PMU0_PLLCTL1_WILD_IMSK_SHIFT 28
+SSB_PMU0_PLLCTL2_WILD_IMSKHI_SHIFT 0
+SSB_PMU1_PLLCTL0_P1DIV_SHIFT 20
+SSB_PMU1_PLLCTL0_P2DIV_SHIFT 24
+SSB_PMU1_PLLCTL2_NDIVINT_SHIFT 20
+SSB_PMU1_PLLCTL2_NDIVMODE_SHIFT 17
+SSB_PMU1_PLLCTL3_NDIVFRAC_SHIFT 0
+SSB_PMU1_PLLCTL5_CLKDRV_SHIFT 8
+SSB_PMURES_4325_CBUCK_BURST 1
+SSB_PMURES_4325_CLDO_CBUCK_BURST 3
+SSB_PMURES_4325_LNLDO2_PU 10
+SSB_PMURES_4328_BB_SWITCHER_PWM 1
+SSB_PMURES_4328_EXT_SWITCHER_PWM 0
+SSB_PMURES_4328_XTAL_EN 16
+SSB_PROG_WCNT_1_SHIFT 8
+SSB_PROG_WCNT_2_SHIFT 16
+SSB_PROG_WCNT_3_SHIFT 24
+S_SCAN_HW 15
+S_SCANNING 13
+SSM2518_CHAN_MAP_LEFT_SLOT_OFFSET 0
+SSM2518_CHAN_MAP_RIGHT_SLOT_OFFSET 4
+S_STATS 12
+STA32X_CONFA_IR_SHIFT 3
+STA32X_CONFA_MCS_SHIFT 0
+STA32X_CONFF_OCFG_SHIFT 0
+STA32X_CxCFG_OM_SHIFT 6
+STA_KEY_FLG_KEYID_POS 8
+STATE_SENT 10
+STATIC_MAC_FID_SHIFT 22
+STATIC_MAC_FWD_PORTS_SHIFT 16
+STAT_RDA 7
+STATS_UPDATE_PEND 8
+STATUS_ALIVE 2
+STATUS_CHANNEL_SWITCH_PENDING 11
+STATUS_CT_KILL 1
+STATUS_DEVICE_ENABLED 1
+STATUS_EXIT_PENDING 5
+STATUS_FW_ERROR 10
+STATUS_FW_ERROR 5
+STATUS_READY 3
+STATUS_RFKILL 4
+STATUS_RF_KILL_HW 0
+STATUS_SCAN_COMPLETE 12
+STATUS_SCAN_HW 9
+STATUS_SCANNING 7
+STATUS_SCAN_ROC_EXPIRED 14
+STATUS_STATISTICS 6
+STATUS_TPOWER_PMI 2
+STB6100_K_PSD2_SHIFT 2
+STB6100_VCO_ODIV_SHIFT 4
+S_TEMPERATURE 8
+STMPE_IRQ_TOUCH_DET 0
+STOP_TX 1
+STREAM_FMT_OFFSET 10
+STREAM_INDEP_HP 1
+STREAM_MULTI_OUT 0
+ST_REG_IN_PROGRESS 2
+ST_REG_PENDING 3
+STRIPE_BIOFILL_RUN 14
+STRIPE_BIT_DELAY 8
+STRIPE_COMPUTE_RUN 15
+STRIPE_DEGRADED 7
+STRIPE_DELAYED 6
+STRIPE_DISCARD 18
+STRIPE_EXPANDING 9
+STRIPE_EXPAND_READY 11
+STRIPE_EXPAND_SOURCE 10
+STRIPE_HANDLE 1
+STRIPE_INSYNC 4
+STRIPE_IO_STARTED 12
+STRIPE_OP_BIODRAIN 3
+STRIPE_OP_BIOFILL 0
+STRIPE_OP_CHECK 5
+STRIPE_OP_COMPUTE_BLK 1
+STRIPE_OP_PREXOR 2
+STRIPE_OP_RECONSTRUCT 4
+STRIPE_SYNCING 3
+STRIPE_SYNC_REQUESTED 2
+ST_TX_WAKEUP 2
+SUM_CHECK_P 0
+SUM_CHECK_Q 1
+SUNI_TPOP_APM_S_SHIFT 2
+SUSPEND_IO 8
+SUSPEND_REQUEST_CHANGE_INTERRUPT 2
+SUSPEND_REQUEST_CHANGE_INTERRUPT 4
+SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE 2
+SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE 4
+SUSPEND_REQUEST_INTERRUPT 3
+S_VLANEXTRACTIONENABLE 12
+SVM_EXITINFOSHIFT_TS_HAS_ERROR_CODE 44
+SVM_EXITINFOSHIFT_TS_REASON_IRET 36
+SVM_EXITINFOSHIFT_TS_REASON_JMP 38
+SVM_IOIO_SIZE_SHIFT 4
+SVM_SELECTOR_AVL_SHIFT 8
+SVM_SELECTOR_DB_SHIFT 10
+SVM_SELECTOR_DPL_SHIFT 5
+SVM_SELECTOR_G_SHIFT 11
+SVM_SELECTOR_L_SHIFT 9
+SVM_SELECTOR_P_SHIFT 7
+SVM_SELECTOR_S_SHIFT 4
+SVM_VM_CR_SVM_DISABLE 4
+SWDPIO__EXT_SHIFT 4
+SW_LID 0
+SW_TABLET_MODE 1
+SYCC_CD_SHIFT 16
+SYM_MEM_SHIFT 4
+SYSFS_NS_TYPE_SHIFT 8
+T3_CTRL_QP_SIZE_LOG2 8
+TABLE_SEL_SHIFT 2
+TA_READY_INPUT_ENABLE 6
+TBSShift 0
+TCAM_ASSOCDATA_OFFSET_SHIFT 2
+TCAM_V4KEY0_CLASS_CODE_SHIFT 3
+TCAM_V4KEY1_L2RDCNUM_SHIFT 59
+TCAM_V4KEY2_PROTO_SHIFT 32
+TCAM_V4KEY2_TOS_SHIFT 40
+TCAM_V4KEY3_SADDR_SHIFT 32
+TC_CBQ_MAXPRIO 8
+TCE_READ_SHIFT 0
+TCE_RPN_SHIFT 12
+TCE_WRITE_SHIFT 1
+TCODE_PHY_PACKET 16
+TCON_LINK_IN_TREE 2
+TCON_LINK_MASTER 0
+TCON_LINK_PENDING 1
+TCP_DELACK_TIMER_DEFERRED 4
+TCP_METRIC_CWND 3
+TCP_METRIC_REORDERING 4
+TCP_METRIC_RTT 0
+TCP_METRIC_RTTVAR 1
+TCP_METRIC_SSTHRESH 2
+TCP_MTU_REDUCED_DEFERRED 5
+TCP_TSQ_DEFERRED 2
+TCP_WRITE_TIMER_DEFERRED 3
+TD_PIDEP_OFFSET 4
+TD_TOKEN_DEVADDR_SHIFT 8
+TEA5777_W_AM_FM_SHIFT 46
+TEA5777_W_AM_LNA_SHIFT 30
+TEA5777_W_AM_MWLW_SHIFT 31
+TEA5777_W_AM_PEAK_SHIFT 25
+TEA5777_W_AM_PLL_SHIFT 34
+TEA5777_W_CHP0_SHIFT 18
+TEA5777_W_FM_FORCEMONO_SHIFT 15
+TEA5777_W_FM_FREF_SHIFT 30
+TEA5777_W_FM_PLL_SHIFT 32
+TEA5777_W_IFCE_SHIFT 29
+TEA5777_W_IFW_SHIFT 28
+TEA5777_W_INTEXT_SHIFT 24
+TEA5777_W_SLEV_SHIFT 3
+TESTMODE 3
+TG3_PHY_MII_ADDR 1
+THREAD_WAKEUP 0
+TILES_IN_X_LSB_SHIFT 30
+TILES_IN_X_MSB_SHIFT 24
+TILES_IN_X_SHIFT 4
+TIMEDOUT 11
+TIMEOUT 0
+TIMEOUT 21
+TIPC_CRITICAL_IMPORTANCE 3
+TIPC_LOW_IMPORTANCE 0
+TLV320AIC23_CLKIN_SHIFT 6
+TMEM_POOL_PAGESIZE_SHIFT 4
+TMEM_VERSION_SHIFT 24
+TMRDIV_SHIFT 0
+TOMOYO_TYPE_EXECUTE 0
+TP_ACPI_HOTKEYSCAN_FNEND 16
+TP_ACPI_HOTKEYSCAN_FNHOME 15
+TPD_BUFLEN_SHIFT 0
+TPD_CC_SEGMENT_EN_SHIFT 3
+TPD_CCSUM_EN_SHIFT 8
+TPD_CCSUM_OFFSET_SHIFT 18
+TPD_CCSUMOFFSET_SHIFT 24
+TPD_CUST_CSUM_EN_SHIFT 3
+TPD_EOP_SHIFT 0
+TPD_EOP_SHIFT 31
+TPD_ETH_TYPE_SHIFT 17
+TPD_ETHTYPE_SHIFT 9
+TPD_HADDR_SHIFT 5
+TPD_HDRFLAG_SHIFT 18
+TPD_INS_VL_TAG_SHIFT 2
+TPD_INS_VTAG_SHIFT 15
+TPD_IP_CSUM_SHIFT 5
+TPD_IPHL_SHIFT 10
+TPD_IPV4_PACKET_SHIFT 16
+TPD_LSO_EN_SHIFT 12
+TPD_LSO_VER_SHIFT 13
+TPD_MSS_SHIFT 18
+TPD_MSS_SHIFT 19
+TPD_PLOADOFFSET_SHIFT 0
+TPD_PLOADOFFSET_SHIFT 16
+TPD_SEGMENT_EN_SHIFT 4
+TPD_TCP_CSUM_SHIFT 6
+TPD_TCPHDRLEN_SHIFT 14
+TPD_TCPHDR_OFFSET_SHIFT 0
+TPD_V4_IPHL_SHIFT 10
+TPD_VLAN_SHIFT 16
+TPD_VLANTAG_SHIFT 16
+TPD_VL_TAGGED_SHIFT 8
+TP_NVRAM_POS_LEVEL_BRIGHTNESS 0
+TPS6105X_REG0_MODE_SHIFT 6
+TPS6105X_REG0_VOLTAGE_SHIFT 4
+TRANSPARENT_HUGEPAGE_FLAG 0
+TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG 1
+TRB_MAX_BUFF_SHIFT 16
+TRUEIDE_MWORD_DMA_TIMING_SHIFT 7
+TRUEIDE_PIO_TIMING_SHIFT 4
+TSIZ_NTD_SHIFT 8
+TSIZ_PKTCNT_SHIFT 19
+TSIZ_SCHINFO_SHIFT 0
+TSIZ_SC_MC_PID_SHIFT 29
+TSIZ_XFERSIZE_SHIFT 0
+TSQ_THROTTLED 0
+TST_SWITCH_PENDING 1
+TST_SWITCH_WAIT 2
+TT1_SHIFT 0
+TT2_SHIFT 4
+TTM_BO_PRIV_FLAG_MOVING 0
+TT_OFFSET 2
+TTY_CLOSING 7
+TTY_DO_WRITE_WAKEUP 5
+TTY_EXCLUSIVE 3
+TTY_HUPPED 18
+TTY_HUPPING 21
+TTY_IO_ERROR 1
+TTY_LDISC 9
+TTY_LDISC_CHANGING 10
+TTY_LDISC_HALTED 22
+TTY_NO_WRITE_SPLIT 17
+TTY_OTHER_CLOSED 2
+TTYP_FLUSHPENDING 2
+TTY_PTY_LOCK 16
+TTY_PUSH 6
+TTY_THROTTLED 0
+TV_BURST_LEVEL_SHIFT 16
+TV_DAC_CNTL_BGADJ__SHIFT 16
+TV_DAC_CNTL_DACADJ__SHIFT 20
+TV_HBLANK_END_SHIFT 16
+TV_HBLANK_START_SHIFT 0
+TV_HBURST_LEN_SHIFT 0
+TV_HSYNC_END_SHIFT 16
+TV_HTOTAL_SHIFT 0
+TV_NBR_END_SHIFT 16
+TVP5150_CROP_SHIFT 2
+TV_SCDDA1_INC_SHIFT 0
+TV_SCDDA2_INC_SHIFT 0
+TV_SCDDA2_SIZE_SHIFT 16
+TV_SCDDA3_INC_SHIFT 0
+TV_SCDDA3_SIZE_SHIFT 16
+TV_VBURST_END_F1_SHIFT 0
+TV_VBURST_END_F2_SHIFT 0
+TV_VBURST_END_F3_SHIFT 0
+TV_VBURST_END_F4_SHIFT 0
+TV_VBURST_START_F1_SHIFT 16
+TV_VBURST_START_F2_SHIFT 16
+TV_VBURST_START_F3_SHIFT 16
+TV_VBURST_START_F4_SHIFT 16
+TV_VEQ_LEN_SHIFT 16
+TV_VEQ_START_F1_SHIFT 8
+TV_VEQ_START_F2_SHIFT 0
+TV_VI_END_F1_SHIFT 8
+TV_VI_END_F2_SHIFT 0
+TV_VSYNC_LEN_SHIFT 16
+TV_VSYNC_START_F1_SHIFT 8
+TV_VSYNC_START_F2_SHIFT 0
+TW_IN_RESET 2
+TWL4030_ROW_SHIFT 4
+TWL6030_CFG_STATE_GRP_SHIFT 5
+TWSIC0_SID_SHIFT 3
+TWSIC1_ADDR_SHIFT 16
+TW_USING_MSI 3
+TXC_AMPDU_SHIFT 9
+TXC_ARXCTL_RXPD0_LBN 12
+TXC_ARXCTL_RXPD1_LBN 13
+TXC_ARXCTL_RXPD2_LBN 14
+TXC_ARXCTL_RXPD3_LBN 15
+TXC_ATXCTL_TXPD0_LBN 12
+TXC_ATXCTL_TXPD1_LBN 13
+TXC_ATXCTL_TXPD2_LBN 14
+TXC_ATXCTL_TXPD3_LBN 15
+TXC_BIST_CTRL_ENAB_LBN 13
+TXC_BIST_CTRL_STOP_LBN 14
+TXC_BIST_CTRL_STRT_LBN 15
+TXC_BIST_CTRL_TYPE_LBN 10
+TXC_GLCMD_L01PD_LBN 5
+TXC_GLCMD_L23PD_LBN 6
+TXC_GLCMD_LMTSWRST_LBN 14
+TXC_MCTL_RXLED_LBN 13
+TXC_MCTL_TXLED_LBN 14
+TX_CMD_SEC_SHIFT 6
+TX_CMD_SEC_WEP_KEY_IDX_POS 6
+TXC_MTDIABLO_CTRL_PMA_LOOP_LBN 10
+TXD_LEN_SHIFT 16
+TxDMABurstSizeShift 8
+TXD_MSS_SHIFT 16
+TxDRNT_shift 0
+TXD_VLAN_TAG_SHIFT 0
+TXFID_SEQ_SHIFT 5
+TXFIFOCMD_FIFOSEL_SHIFT 8
+TXFIFO_FIFOTOP_SHIFT 8
+TxFILLT_shift 8
+TX_FLOW_ON_BIT 1
+TXHDR_IHL_SHIFT 52
+TXHDR_L3START_SHIFT 48
+TXHDR_L4START_SHIFT 40
+TXHDR_L4STUFF_SHIFT 32
+TXHDR_LEN_SHIFT 16
+TXHDR_PAD_SHIFT 0
+TxHiPriFIFOThreshShift 24
+TX_HW_ATTR_OFST_RATE_POLICY 5
+TX_HW_ATTR_OFST_SESSION_COUNTER 2
+TX_JUMBO_TASK_TH_SHIFT 0
+TX_LENGTHS_IPG_CRS_SHIFT 12
+TX_LENGTHS_IPG_SHIFT 8
+TX_LENGTHS_SLOT_TIME_SHIFT 0
+TX_LOG_PAGE_VLD_FUNC_SHIFT 2
+TxMXDMA_shift 20
+TxPadLenShift 16
+TXQ_CMD_SHIFT 29
+TXQ_CTRL 2
+TXQ_CTRL_TPD_BURST_NUM_SHIFT 0
+TXQ_CTRL_TPD_FETCH_TH_SHIFT 8
+TXQ_CTRL_TXF_BURST_NUM_SHIFT 16
+TXQ_ETH 0
+TXQ_OFLD 1
+TXQ_PHY_SHIFT 12
+TXQ_RUNNING 1
+TXQ_SRS_SHIFT 20
+TX_RNG_CFIG_LEN_SHIFT 48
+TX_STATUS_BA_BMAP47_SHIFT 3
+TXSTOPPED 1
+TX_TPD_MIN_IPG_SHIFT 16
+UAC_FORMAT_TYPE_I_ALAW 4
+UAC_FORMAT_TYPE_I_IEEE_FLOAT 3
+UAC_FORMAT_TYPE_I_MULAW 5
+UAC_FORMAT_TYPE_I_PCM 1
+UAC_FORMAT_TYPE_I_PCM8 2
+UAC_FORMAT_TYPE_I_UNDEFINED 0
+UBIFS_BLOCK_SHIFT 12
+UBIFS_LPT_FANOUT_SHIFT 2
+UDC_BITS_PER_BYTE_SHIFT 3
+UDCCONR_AISN_S 19
+UDCCONR_CN_S 25
+UDCCONR_EN_S 15
+UDCCONR_ET_S 13
+UDCCONR_IN_S 22
+UDCCONR_MPS_S 2
+UDC_CSR_NE_ALT_SHIFT 15
+UDC_CSR_NE_CFG_SHIFT 7
+UDC_CSR_NE_DIR_SHIFT 4
+UDC_CSR_NE_INTF_SHIFT 11
+UDC_CSR_NE_MAX_PKT_SHIFT 19
+UDC_CSR_NE_NUM_SHIFT 0
+UDC_CSR_NE_TYPE_SHIFT 5
+UDC_DEVCTL_BRLEN_SHIFT 16
+UDC_DEVCTL_THLEN_SHIFT 24
+UDC_EP0OUT_IX 16
+UDC_EPCTL_ET_SHIFT 4
+UDF_FLAG_BLOCKSIZE_SET 19
+UDF_FLAG_GID_FORGET 13
+UDF_FLAG_GID_IGNORE 14
+UDF_FLAG_GID_SET 16
+UDF_FLAG_LASTBLOCK_SET 18
+UDF_FLAG_NLS_MAP 9
+UDF_FLAG_SESSION_SET 17
+UDF_FLAG_STRICT 5
+UDF_FLAG_UID_FORGET 11
+UDF_FLAG_UID_IGNORE 12
+UDF_FLAG_UID_SET 15
+UDF_FLAG_UNDELETE 6
+UDF_FLAG_UNHIDE 7
+UDF_FLAG_USE_AD_IN_ICB 3
+UDF_FLAG_USE_SHORT_AD 2
+UDF_FLAG_UTF8 10
+UDI_SENDER_ID_SHIFT 8
+UD_VECTOR 6
+ULP_ACCEPT 9
+ULP_F_CALL_PENDING 2
+ULP_REJECT 10
+ultra 2
+ULTRA_DMA_TIMING_SHIFT 10
+UNLOADING 15
+Unmerged 2
+UNPLUG_REMOTE 0
+uPD98401_IM_I_SHIFT 24
+uPD98401_PC_C_SHIFT 16
+uPD98401_RXFP_ALERT_SHIFT 28
+uPD98401_RXFP_BFSZ_SHIFT 24
+uPD98401_RXFP_BTSZ_SHIFT 16
+uPD98401_RXVC_POOL_SHIFT 16
+uPD98401_TXVC_SHP_SHIFT 24
+uPD98401_TXVC_VPI_SHIFT 16
+UPROBE_COPY_INSN 0
+USB_CAPTURE_RUNNING 0
+USB_CDC_ETHERNET_TYPE 15
+USB_CDC_HEADER_TYPE 0
+USB_CDC_UNION_TYPE 6
+USB_DETECT_ENABLE 3
+USB_DEVICE_A_ALT_HNP_SUPPORT 5
+USB_DEVICE_A_HNP_SUPPORT 4
+USB_DEVICE_B_HNP_ENABLE 3
+USB_DEVICE_REMOTE_WAKEUP 1
+USB_DEVICE_SELF_POWERED 0
+USB_DEV_STAT_U1_ENABLED 2
+USB_DEV_STAT_U2_ENABLED 3
+USB_EHCI_LOADED 2
+USB_ENDPOINT_HALT 0
+USB_FULL_SPEED 1
+USB_HIGH_SPEED 2
+USB_IN_ACK_RCVD 18
+USB_IN_ACK_RCVD 3
+USB_IN_NAK_SENT 19
+USB_IN_NAK_SENT 4
+USB_OHCI_LOADED 1
+USB_OUT_ACK_SENT 1
+USB_OUT_ACK_SENT 16
+USB_OUT_NAK_SENT 2
+USB_OUT_PING_NAK_SENT 17
+USB_PLAYBACK_RUNNING 1
+USB_PORT_FEAT_C_CONNECTION 16
+USB_PORT_FEAT_C_RESET 20
+USB_PORT_FEAT_C_SUSPEND 18
+USB_PORT_FEAT_RESET 4
+USB_PORT_FEAT_SUSPEND 2
+USB_ROOT_PORT_WAKEUP_ENABLE 11
+USB_ROOT_PORT_WAKEUP_ENABLE 5
+USB_SOFT_RESET 1
+USB_STALL_SENT 20
+USB_STALL_SENT 5
+USB_UHCI_LOADED 0
+USE_DEGR_WFC_T 2
+USER 4
+USER_CONTROL_RES1_SHIFT 0
+USER_ODIG_CTRL_GPIOS_SHIFT 5
+USER_PMD_TX_CTL_TX_DAC_TXCK_SH 4
+USER_PMD_TX_CTL_TX_DAC_TXD_SH 6
+US_FLIDX_ABORTING 2
+US_FLIDX_DISCONNECTING 3
+US_FLIDX_READ10_WORKED 8
+US_FLIDX_REDO_READ10 7
+US_FLIDX_RESETTING 4
+US_FLIDX_SCAN_PENDING 6
+US_FLIDX_SG_ACTIVE 1
+US_FLIDX_TIMED_OUT 5
+US_FLIDX_URB_ACTIVE 0
+USTORM_ISCSI_ST_CONTEXT_MAX_OUTSTANDING_R2TS_SHIFT 24
+UV2_ACK_UNITS_SHFT 3
+UV2_EXT_SHFT 33
+UV_DESC_PSHIFT 49
+UVH_IPI_INT_APIC_ID_SHFT 16
+UVH_IPI_INT_SEND_SHFT 63
+UVH_IPI_INT_VECTOR_SHFT 0
+UVH_RH_GAM_GRU_OVERLAY_CONFIG_MMR_BASE_SHFT 28
+UVH_RTC1_INT_CONFIG_APIC_ID_SHFT 32
+UVH_RTC1_INT_CONFIG_VECTOR_SHFT 0
+UV_PAYLOADQ_PNODE_SHIFT 49
+UV_SW_ACK_NPENDING 8
+V2_DQBLKSIZE_BITS 10
+V4L2_COLORFX_BW 1
+V4L2_COLORFX_NEGATIVE 3
+V4L2_COLORFX_NONE 0
+V4L2_COLORFX_SEPIA 2
+V4L2_COLORFX_SKETCH 5
+V4L2_FL_REGISTERED 0
+V4L2_FL_USE_FH_PRIO 2
+V4L2_FL_USES_V4L2_FH 1
+V4L2_MPEG_AUDIO_AC3_BITRATE_256K 12
+V4L2_MPEG_AUDIO_AC3_BITRATE_384K 14
+V4L2_MPEG_AUDIO_DEC_PLAYBACK_AUTO 0
+V4L2_MPEG_AUDIO_L2_BITRATE_256K 11
+V4L2_MPEG_AUDIO_L2_BITRATE_384K 13
+V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000 1
+V4L2_MPEG_STREAM_TYPE_MPEG2_TS 1
+V4L2_MPEG_VIDEO_ENCODING_MPEG_2 1
+VALID_BIT 31
+VALUE_HASH_SHIFT 16
+VBUS_INTERRUPT 2
+VBUS_INTERRUPT 7
+VBUS_INTERRUPT_ENABLE 2
+VBUS_INTERRUPT_ENABLE 7
+VBUS_PIN 0
+VBUS_PIN 10
+VCF_IDLE 2
+VCF_RX 1
+VCF_TX 0
+VCPU_EXREG_CPL 20
+VCPU_EXREG_CR3 18
+VCPU_EXREG_PDPTR 17
+VCPU_EXREG_RFLAGS 19
+VCPU_EXREG_SEGMENTS 21
+VCPU_REGS_RIP 16
+VCPU_REGS_RSP 4
+VDD1_VGAIN_SEL_SHIFT 6
+VDD2_VGAIN_SEL_SHIFT 6
+VERT_PANEL_SHIFT 12
+VHOST_F_LOG_ALL 26
+VHOST_NET_F_VIRTIO_NET_HDR 27
+VHOST_VRING_F_LOG 0
+VIA_MM_ALIGN_SHIFT 4
+VIA_REG_AC97_CMD_SHIFT 16
+VIA_REG_AC97_CODEC_ID_SHIFT 30
+VIA_REG_AC97_DATA_SHIFT 0
+VIA_STRFILT_CNT_SHIFT 16
+VIDCFG_PIXFMT_SHIFT 18
+V_INTR_PRIO_SHIFT 16
+VIRTIO_CONSOLE_F_MULTIPORT 1
+VIRTIO_NET_F_MRG_RXBUF 15
+VIRTIO_RING_F_EVENT_IDX 29
+VLAN_PRIO_SHIFT 13
+VLAN_VALID 1
+VMCB_DIRTY_MAX 11
+VMWARE_PORT_CMD_LEGACY_X2APIC 3
+VMWARE_PORT_CMD_VCPU_RESERVED 31
+VMX_BASIC_MEM_TYPE_SHIFT 50
+VMX_BASIC_VMCS_SIZE_SHIFT 32
+VMX_EPT_GAW_EPTP_SHIFT 3
+VMX_EPT_MT_EPTE_SHIFT 3
+VMXNET3_RXD_BTYPE_SHIFT 14
+VMXNET3_STATE_BIT_QUIESCED 1
+VMXNET3_TXD_GEN_SHIFT 14
+V_PARAM_SHIFT 1
+VPD_CAP_VPD_ADDR_SHIFT 16
+VP_DPC_NEEDED 14
+VP_IDX_ACQUIRED 0
+VP_SCR_NEEDED 4
+VSC_MMIO_BAR 0
+__VXGE_STATE_CARD_UP 1
+W1_SLAVE_ACTIVE 0
+WAKEUP_BEHAVIOR_RESTORE_CR4 1
+WAKEUP_BEHAVIOR_RESTORE_MISC_ENABLE 0
+WantReplacement 9
+WBD_ALPHA 6
+WDM_DISCONNECTING 2
+WDM_INT_STALL 5
+WDM_IN_USE 1
+WDM_OVERFLOW 10
+WDM_READ 4
+WDM_RESETTING 9
+WDM_RESPONDING 7
+WDM_SUSPENDING 8
+WDOG_ACTIVE 0
+WDOG_ALLOW_RELEASE 2
+WDOG_NO_WAY_OUT 3
+WDOG_UNREGISTERED 4
+WDT_FLAGS_ORPHAN 2
+WDT_OK_TO_CLOSE 1
+WDTS_EXPECTED 5
+WDTS_KEEPALIVE 2
+WDTS_USE_GP 4
+WFOI_MASK_SHIFT 4
+WH_OFS 20
+wil_status_dontscan 3
+wil_status_fwconnected 2
+wil_status_fwconnecting 1
+wil_status_fwready 0
+wil_status_irqen 5
+wil_status_reset_done 4
+WIMAX_ST_CONNECTED 8
+WIMAX_ST_CONNECTING 7
+WIMAX_ST_DOWN 1
+__WIMAX_ST_QUIESCING 2
+WIMAX_ST_RADIO_OFF 4
+WIMAX_ST_READY 5
+WIMAX_ST_SCANNING 6
+WIMAX_ST_UNINITIALIZED 3
+WL1271_FLAG_DUMMY_PACKET_PENDING 7
+WL1271_FLAG_FW_TX_BUSY 6
+WL1271_FLAG_IN_ELP 3
+WL1271_FLAG_INTENDED_FW_RECOVERY 13
+WL1271_FLAG_IRQ_RUNNING 5
+WL1271_FLAG_PENDING_WORK 9
+WL1271_FLAG_RECOVERY_IN_PROGRESS 11
+WL1271_FLAG_SOFT_GEMINI 10
+WL1271_FLAG_SUSPENDED 8
+WL1271_FLAG_TX_PENDING 2
+WL1271_FLAG_VIF_CHANGE_IN_PROGRESS 12
+WLAN_ENABLED 7
+WLAN_STA_ASSOC 1
+WLAN_STA_AUTH 0
+WLAN_STA_AUTHORIZED 3
+WLVIF_FLAG_AP_PROBE_RESP_SET 10
+WLVIF_FLAG_AP_STARTED 4
+WLVIF_FLAG_CS_PROGRESS 9
+WLVIF_FLAG_IBSS_JOINED 3
+WLVIF_FLAG_INITIALIZED 0
+WLVIF_FLAG_IN_PS 5
+WLVIF_FLAG_IN_USE 11
+WLVIF_FLAG_RX_STREAMING_STARTED 7
+WLVIF_FLAG_STA_ASSOCIATED 1
+WLVIF_FLAG_STA_AUTHORIZED 2
+WM0_PIPE_PLANE_SHIFT 16
+WM0_PIPE_SPRITE_SHIFT 8
+WM2200_AIF1TX_WL_SHIFT 8
+WM2200_FLL_CLK_REF_DIV_SHIFT 4
+WM2200_FLL_OUTDIV_SHIFT 8
+WM2200_IN1_DMIC_SUP_SHIFT 11
+WM2200_IN1_MODE_SHIFT 9
+WM2200_MICB1_LVL_SHIFT 2
+WM2200_SYSCLK_FREQ_SHIFT 8
+WM5100_ACCDET_BIAS_SRC_SHIFT 14
+WM5100_ACCDET_BIAS_STARTTIME_SHIFT 12
+WM5100_ACCDET_RATE_SHIFT 8
+WM5100_ACCDET_SRC_SHIFT 13
+WM5100_AIF1TX_WL_SHIFT 8
+WM5100_FLL1_OUTDIV_SHIFT 8
+WM5100_FLL1_REFCLK_DIV_SHIFT 6
+WM5100_GP1_DIR_SHIFT 15
+WM5100_GP1_FN_SHIFT 0
+WM5100_GP1_LVL_SHIFT 6
+WM5100_HPCOM_SRC_SHIFT 9
+WM5100_IN1_DMIC_SUP_SHIFT 11
+WM5100_IN1_MODE_SHIFT 9
+WM5100_SYSCLK_FREQ_SHIFT 8
+WM831X_CLKOUT_SRC_SHIFT 0
+WM831X_DC1_DVS_SRC_SHIFT 11
+WM831X_DC1_HC_THR_SHIFT 4
+WM831X_DC1_ON_MODE_SHIFT 8
+WM831X_LED_DUR_SHIFT 2
+WM831X_LED_MODE_SHIFT 8
+WM831X_LED_SRC_SHIFT 14
+WM831X_WDOG_PRIMACT_SHIFT 4
+WM831X_WDOG_RST_SRC_SHIFT 13
+WM831X_WDOG_SECACT_SHIFT 8
+WM8350_DC1_ENSLOT_SHIFT 10
+WM8350_DC1_ERRACT_SHIFT 14
+WM8350_DC1_SDSLOT_SHIFT 6
+WM8350_DC2_FBSRC_SHIFT 0
+WM8350_DC2_HIB_MODE_SHIFT 12
+WM8350_DC2_ILIM_SHIFT 6
+WM8350_DC2_MODE_SHIFT 14
+WM8350_DC2_RMP_SHIFT 3
+WM8350_DC5_FBSRC_SHIFT 0
+WM8350_DC5_HIB_MODE_SHIFT 12
+WM8350_DC5_ILIM_SHIFT 6
+WM8350_DC5_MODE_SHIFT 14
+WM8350_DC5_RMP_SHIFT 3
+WM8350_OUT1L_VOL_SHIFT 2
+WM8350_OUT1R_VOL_SHIFT 2
+WM8350_RTC_ALMDAY_SHIFT 8
+WM8350_RTC_ALMMINS_SHIFT 8
+WM8350_RTC_ALMMTH_SHIFT 8
+WM8350_RTC_DAY_SHIFT 8
+WM8350_RTC_MINS_SHIFT 8
+WM8350_RTC_MTH_SHIFT 8
+WM8350_RTC_YHUNDREDS_SHIFT 8
+WM8400_AINLMUX_PWR 1
+WM8400_AINRMUX_PWR 3
+WM8400_FLL_REF_FREQ_SHIFT 12
+WM8400_INMIXL_PWR 0
+WM8400_INMIXR_PWR 2
+WM8737_SR_SHIFT 1
+WM8903_CLK_SYS_MODE_SHIFT 8
+WM8903_CLK_SYS_RATE_SHIFT 10
+WM8903_DEEMPH_SHIFT 1
+WM8903_GP1_FN_SHIFT 8
+WM8903_GP1_LVL_SHIFT 4
+WM8903_GP2_LVL_SHIFT 4
+WM8903_ISEL_SHIFT 2
+WM8903_VMID_SOFT_SHIFT 3
+WM8904_CLK_SYS_RATE_SHIFT 10
+WM8904_DCS_TRIG_STARTUP_0_SHIFT 4
+WM8904_DEEMPH_SHIFT 1
+WM8904_FLL_CLK_REF_DIV_SHIFT 3
+WM8904_FLL_FRATIO_SHIFT 0
+WM8904_FLL_N_SHIFT 5
+WM8904_FLL_OUTDIV_SHIFT 8
+WM8904_ISEL_SHIFT 2
+WM8904_SAMPLE_RATE_SHIFT 0
+WM8904_VMID_RES_SHIFT 1
+WM8955_DEEMPH_SHIFT 1
+WM8955_N_SHIFT 5
+WM8955_SR_SHIFT 1
+WM8955_VMIDSEL_SHIFT 7
+WM8955_VREF_SHIFT 6
+WM8955_VSEL_SHIFT 6
+WM8958_DSP2CLK_SRC_SHIFT 12
+WM8958_MBC_SEL_SHIFT 4
+WM8958_MICD_BIAS_STARTTIME_SHIFT 12
+WM8958_MICD_RATE_SHIFT 8
+WM8961_CLK_SYS_RATE_SHIFT 1
+WM8961_VMIDSEL_SHIFT 7
+WM8961_WL_SHIFT 2
+WM8962_BEEP_RATE_SHIFT 1
+WM8962_CLKOUT2_SEL_SHIFT 5
+WM8962_CLKOUT3_SEL_SHIFT 3
+WM8962_FLL_OUTDIV_SHIFT 3
+WM8962_FLL_REFCLK_SRC_SHIFT 5
+WM8962_GP2_FN_SHIFT 0
+WM8962_GP2_LVL_SHIFT 6
+WM8962_SYSCLK_RATE_SHIFT 1
+WM8962_SYSCLK_SRC_SHIFT 9
+WM8983_BCLKDIV_SHIFT 2
+WM8983_BCP_SHIFT 8
+WM8983_EQ3DMODE_SHIFT 8
+WM8983_FMT_SHIFT 3
+WM8983_LRCP_SHIFT 7
+WM8983_MCLKDIV_SHIFT 5
+WM8983_MS_SHIFT 0
+WM8983_PLL_PRESCALE_SHIFT 4
+WM8983_SOFTMUTE_SHIFT 6
+WM8983_SR_SHIFT 1
+WM8983_VMIDSEL_SHIFT 0
+WM8983_WL_SHIFT 5
+WM8985_BCLKDIV_SHIFT 2
+WM8985_BCP_SHIFT 8
+WM8985_EQ3DMODE_SHIFT 8
+WM8985_FMT_SHIFT 3
+WM8985_LRP_SHIFT 7
+WM8985_MCLKDIV_SHIFT 5
+WM8985_MS_SHIFT 0
+WM8985_PLL_PRESCALE_SHIFT 4
+WM8985_SOFTMUTE_SHIFT 6
+WM8985_SR_SHIFT 1
+WM8985_VMIDSEL_SHIFT 0
+WM8985_WL_SHIFT 5
+WM8990_AINLMUX_PWR_BIT 1
+WM8990_AINRMUX_PWR_BIT 3
+WM8990_INMIXL_PWR_BIT 0
+WM8990_INMIXR_PWR_BIT 2
+WM8991_AINLMUX_PWR_BIT 1
+WM8991_AINRMUX_PWR_BIT 3
+WM8991_INMIXL_PWR_BIT 0
+WM8991_INMIXR_PWR_BIT 2
+WM8993_BCLK_DIV_SHIFT 1
+WM8993_CLK_SYS_RATE_SHIFT 1
+WM8993_DCS_DAC_WR_VAL_1_SHIFT 8
+WM8993_DCS_SERIES_NO_01_SHIFT 5
+WM8993_FLL_CLK_REF_DIV_SHIFT 3
+WM8993_FLL_FRATIO_SHIFT 0
+WM8993_FLL_N_SHIFT 5
+WM8993_FLL_OUTDIV_SHIFT 8
+WM8993_JD_SCTHR_SHIFT 6
+WM8993_JD_THR_SHIFT 4
+WM8993_MICB2_LVL_SHIFT 1
+WM8993_SAMPLE_RATE_SHIFT 7
+WM8994_AIF1_BCLK_DIV_SHIFT 4
+WM8994_AIF1DAC1_3D_GAIN_SHIFT 9
+WM8994_AIF1DAC2_3D_GAIN_SHIFT 9
+WM8994_AIF1_SR_SHIFT 4
+WM8994_AIF2DAC_3D_GAIN_SHIFT 9
+WM8994_CP_DYN_SRC_SEL_SHIFT 8
+WM8994_FLL1_FRATIO_SHIFT 0
+WM8994_FLL1_FRC_NCO_SHIFT 6
+WM8994_FLL1_N_SHIFT 5
+WM8994_FLL1_OUTDIV_SHIFT 8
+WM8994_FLL1_REFCLK_DIV_SHIFT 3
+WM8994_VMID_RAMP_SHIFT 5
+WM8995_AIF1_BCLK_DIV_SHIFT 4
+WM8995_AIF1DAC1_MUTE_SHIFT 9
+WM8995_AIF1_FMT_SHIFT 3
+WM8995_AIF1_SR_SHIFT 4
+WM8995_AIF1_WL_SHIFT 5
+WM8995_CP_DYN_SRC_SEL_SHIFT 8
+WM8995_FLL1_FRATIO_SHIFT 0
+WM8995_FLL1_N_SHIFT 5
+WM8995_FLL1_OUTDIV_SHIFT 8
+WM8995_FLL1_REFCLK_DIV_SHIFT 3
+WM8996_AIF1RX_CHAN0_SLOTS_SHIFT 6
+WM8996_AIF1RX_CHAN1_SLOTS_SHIFT 6
+WM8996_AIF1RX_CHAN2_SLOTS_SHIFT 6
+WM8996_AIF1RX_CHAN3_SLOTS_SHIFT 6
+WM8996_AIF1RX_CHAN4_SLOTS_SHIFT 6
+WM8996_AIF1RX_CHAN5_SLOTS_SHIFT 6
+WM8996_AIF1TX_CHAN0_SLOTS_SHIFT 6
+WM8996_AIF1TX_CHAN1_SLOTS_SHIFT 6
+WM8996_AIF1TX_CHAN2_SLOTS_SHIFT 6
+WM8996_AIF1TX_CHAN3_SLOTS_SHIFT 6
+WM8996_AIF1TX_CHAN4_SLOTS_SHIFT 6
+WM8996_AIF1TX_CHAN5_SLOTS_SHIFT 6
+WM8996_AIF1TX_WL_SHIFT 8
+WM8996_AIF2RX_CHAN0_SLOTS_SHIFT 6
+WM8996_AIF2RX_CHAN1_SLOTS_SHIFT 6
+WM8996_AIF2TX_CHAN0_SLOTS_SHIFT 6
+WM8996_DCS_TRIG_STARTUP_0_SHIFT 4
+WM8996_FLL_LFSR_SEL_SHIFT 1
+WM8996_FLL_N_SHIFT 5
+WM8996_FLL_OUTDIV_SHIFT 8
+WM8996_FLL_REFCLK_DIV_SHIFT 3
+WM8996_FLL_REF_FREQ_SHIFT 2
+WM8996_GP1_DIR_SHIFT 15
+WM8996_GP1_FN_SHIFT 0
+WM8996_GP1_LVL_SHIFT 6
+WM8996_INL_MODE_SHIFT 2
+WM8996_MICD_BIAS_STARTTIME_SHIFT 12
+WM8996_MICD_RATE_SHIFT 8
+WM8996_SYSCLK_SRC_SHIFT 3
+WM9081_AIFDAC_TDM_MODE_SHIFT 2
+WM9081_CLK_SYS_RATE_SHIFT 4
+WM9081_FLL_CLK_REF_DIV_SHIFT 3
+WM9081_FLL_FRATIO_SHIFT 0
+WM9081_FLL_N_SHIFT 5
+WM9081_FLL_OUTDIV_SHIFT 8
+WM9081_SAMPLE_RATE_SHIFT 0
+WM9090_VMID_RES_SHIFT 1
+WMI_CTRL_EP_FULL 2
+WMI_DATA_HDR_DATA_TYPE_SHIFT 6
+WMI_DATA_HDR_MSG_TYPE_SHIFT 0
+WMI_ENABLED 0
+WMI_RC_RX_STBC_FLAG_S 6
+WMI_READY 1
+WMM_AC_BK 1
+WMM_ENABLED 2
+WMM_NUM_AC 4
+WM_SW_DAC 0
+WORK_DONE_BIT 1
+WORK_ENABLE 3
+WORK_HIGH_PRIO_BIT 3
+WORK_LINK_DOWN 2
+WORK_LINK_UP 1
+WORK_OFFQ_POOL_SHIFT 6
+WORK_SET_MULTICAST_LIST 4
+WORK_STRUCT_COLOR_BITS 4
+WORK_STRUCT_COLOR_SHIFT 5
+Wpending 8
+WriteErrorSeen 6
+WriteMostly 3
+WRITE_REMOTE_AMP_ASSOC 3
+WS_OFS 28
+WSPI_CMD_BYTE_LENGTH_OFFSET 17
+WST_OFS 22
+WTSR_EN_SHIFT 6
+WTSRT_SHIFT 0
+X25_ACCPT_APPRV_FLAG 2
+X25_Q_BIT_FLAG 0
+XEN_MCE_OVERFLOW 0
+_XEN_PCIB_active 2
+_XEN_PCIB_AERHANDLER 1
+_XEN_PCIF_active 0
+XFS_BLF_SHIFT 7
+XFS_EFI_RECOVERED 1
+XFS_ILOCK_SHIFT 24
+XFS_IOLOCK_SHIFT 16
+XFTS_CHANNEL_SHIFT 8
+XFTS_FBRRTS_FT_SHIFT 4
+XFTS_RTS_FT_SHIFT 2
+XGMAC_FLOW_CTRL_PT_SHIFT 16
+XMAC_IPG_IPG_MII_GMII_SHIFT 8
+XMAC_IPG_IPG_XGMII_SHIFT 0
+XMAC_MIN_RX_MIN_PKT_SIZE_SHFT 20
+XMAC_MIN_TX_MIN_PKT_SIZE_SHFT 0
+XMIT_BUF_ONE_READY 6
+XMIT_BUF_TWO_READY 7
+XMIT_SENDING_READY 8
+XMIT_WAITING 8
+XMIT_WAKEUP 0
+XMIT_WAKEUP 2
+XPRT_CLOSE_WAIT 3
+XPRT_CLOSING 6
+XPRT_CONGESTED 9
+XPRT_CONNECTION_ABORT 7
+XPRT_CONNECTION_CLOSE 8
+XPT_BUSY 0
+XPT_CACHE_AUTH 12
+XPT_CHNGBUF 7
+XPT_CLOSE 2
+XPT_CONN 1
+XPT_DATA 3
+XPT_DEFERRED 8
+XPT_DETACHED 10
+XPT_LISTENER 11
+XPT_TEMP 4
+XSTORM_COMMON_CONTEXT_SECTION_PBF_PORT_SHIFT 1
+XSTORM_COMMON_CONTEXT_SECTION_PHYSQ_INITIALIZED_SHIFT 0
+XT_DSCP_SHIFT 2
+XY_BUF_OFFSET 4
+ZCACHE_DSTMEM_ORDER 1
+ZD_DEVICE_RUNNING 0
+ZR36057_FHAP_NAX 16
+ZR36057_FHAP_PAX 0
+ZR36057_FVAP_NAY 16
+ZR36057_FVAP_PAY 0
+ZR36057_HSP_HsyncStart 16
+ZR36057_HSP_LineTot 0
+ZR36057_JCGI_JPEGuestID 4
+ZR36057_JCGI_JPEGuestReg 0
+ZR36057_VDCR_MinPix 24
+ZR36057_VDCR_VidWinHt 12
+ZR36057_VDCR_VidWinWid 0
+ZR36057_VFEHCR_HEnd 0
+ZR36057_VFEHCR_HStart 10
+ZR36057_VFESPFR_DispMode 6
+ZR36057_VFESPFR_HFilter 21
+ZR36057_VFESPFR_HorDcm 14
+ZR36057_VFESPFR_VerDcm 8
+ZR36057_VFEVCR_VEnd 0
+ZR36057_VFEVCR_VStart 10
+ZR36057_VSP_FrmTot 0
+ZR36057_VSP_VsyncSize 16
+ZR36057_VSSFGR_DispStride 16
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.bit_shifters.remove b/usr/src/tools/smatch/src/smatch_data/kernel.bit_shifters.remove
new file mode 100644
index 0000000000..ec7ae50fba
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.bit_shifters.remove
@@ -0,0 +1,9 @@
+// tvaudio.c deliberately reuses these in a non conventional way
+V4L2_TUNER_MODE_MONO 0
+V4L2_TUNER_MODE_STEREO 1
+V4L2_TUNER_MODE_LANG2 2
+V4L2_TUNER_MODE_SAP 2
+V4L2_TUNER_MODE_LANG1 3
+V4L2_TUNER_MODE_LANG1_LANG2 4
+
+MBX_INTERRUPT 1
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.check_string_condition.ignore b/usr/src/tools/smatch/src/smatch_data/kernel.check_string_condition.ignore
new file mode 100644
index 0000000000..19db8f357a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.check_string_condition.ignore
@@ -0,0 +1 @@
+TRACE_EVENT
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.clears_argument b/usr/src/tools/smatch/src/smatch_data/kernel.clears_argument
new file mode 100644
index 0000000000..b4a8033b24
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.clears_argument
@@ -0,0 +1,9 @@
+copy_from_user 0
+__copy_from_user 0
+copy_user_generic 0
+loop_get_status 1
+loop_info64_to_old 1
+ib_copy_qp_attr_to_user 0
+tcp_get_info 1
+snd_rawmidi_info_select 1
+t3e3_if_config 3
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.common_functions b/usr/src/tools/smatch/src/smatch_data/kernel.common_functions
new file mode 100644
index 0000000000..6002e02001
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.common_functions
@@ -0,0 +1,75 @@
+printk
+memcpy
+dev_err
+kfree
+writel
+memset
+lockdep_rcu_suspicious
+variable_test_bit
+mutex_unlock
+spin_unlock_irqrestore
+nv_wr32
+dev_printk
+no_printk
+spin_unlock
+warn_slowpath_null
+_raw_spin_unlock_irqrestore
+spinlock_check
+mutex_lock_nested
+outb
+r100_mm_wreg
+snprintf
+sprintf
+readl
+usb_control_msg
+kmalloc
+warn_slowpath_fmt
+dev_set_drvdata
+constant_test_bit
+current_thread_info
+__udelay
+i2c_transfer
+__snd_printk
+__fswab32
+_raw_spin_unlock
+seq_printf
+get_current
+__kmalloc
+cit_write_reg
+spin_lock
+__list_add
+trace_define_field
+set_bit
+_raw_spin_lock_irqsave
+debugfs_create_file
+list_empty
+list_add_tail
+dev_warn
+netdev_priv
+_raw_spin_lock
+dev_get_drvdata
+atomic_read
+nv_mthd
+INIT_LIST_HEAD
+mod_phy_reg
+_dev_info
+clear_bit
+__fswab16
+spin_unlock_irq
+iowrite32
+__raw_spin_lock_init
+debug_lockdep_rcu_enabled
+stv090x_write_reg
+kzalloc
+i2c_master_send
+nv_rd32
+IS_ERR
+b43_phy_write
+lock_is_held
+task_pid_nr
+spin_unlock_bh
+__wake_up
+drm_ut_debug_printk
+reg_w
+writeb
+__create_pipe
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.dev_queue_xmit b/usr/src/tools/smatch/src/smatch_data/kernel.dev_queue_xmit
new file mode 100644
index 0000000000..ed7890e126
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.dev_queue_xmit
@@ -0,0 +1,42 @@
+br_dev_queue_push_xmit 0
+neigh_compat_output 0
+fcoe_fip_send 1
+eql_slave_xmit 0
+irlap_queue_xmit 1
+can_send 0
+snap_request 1
+llc_sap_action_send_xid_c 1
+llc_sap_action_send_ui 1
+x25_transmit_link 0
+pEII_request 1
+br_nf_dev_queue_xmit 0
+pppoe_xmit 1
+lapbeth_data_transmit 1
+irlap_send_i_frame 1
+aarp_send_ddp 1
+x25_send_iframe 1
+ipddp_xmit 0
+pipe_skb_send 1
+ax25_queue_xmit 0
+llc_station_send_pdu 0
+macvlan_start_xmit 0
+dsa_xmit 0
+pn_skb_send 1
+pspoll_send_buffered 2
+dev_queue_xmit 0
+irlap_send_ui_frame 1
+p8022_request 1
+hostap_mgmt_start_xmit 0
+edsa_xmit 0
+nes_nic_cm_xmit 0
+__pppoe_xmit 1
+pvc_xmit 0
+p8023_request 1
+macvlan_queue_xmit 0
+llc_build_and_send_ui_pkt 1
+x25_send_frame 0
+bpq_xmit 0
+pppoe_rcv_core 1
+pn_send 0
+llc_sap_action_send_test_c 1
+phonet_rcv 0
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.dma_funcs b/usr/src/tools/smatch/src/smatch_data/kernel.dma_funcs
new file mode 100644
index 0000000000..62e2aad87f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.dma_funcs
@@ -0,0 +1,35 @@
+// list of DMA function and buffer parameters.
+// generated by `gen_dma_funcs.sh`
+alauda_get_redu_data 2
+alauda_read_block 4
+alauda_read_block_raw 4
+alauda_write_block 2
+brcmf_usb_dl_send_bulk 1
+datafab_bulk_read 1
+datafab_bulk_write 1
+ene_get_card_type 2
+ene_send_scsi_cmd 2
+fill_isoc_urb 3
+ft1000_control 6
+jumpshot_bulk_read 1
+jumpshot_bulk_write 1
+ms_lib_read_extrablock 4
+ms_read_copyblock 5
+ms_read_readpage 3
+mts_int_submit_urb 2
+rts51x_bulk_transfer_buf 2
+rts51x_bulk_transport 4
+rts51x_bulk_transport_special 4
+rts51x_transfer_data 2
+rts51x_transfer_data_rcc 2
+sddr55_bulk_transport 2
+sisusb_bulkin_msg 2
+sisusb_bulkout_msg 3
+usbat_bulk_read 1
+usbat_bulk_write 1
+__usb_control_msg 6
+usb_control_msg 6
+usb_fill_bulk_urb 3
+usb_stor_bulk_transfer_buf 2
+usb_stor_bulk_transfer_sg 2
+vub300_usb_bulk_msg 2
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.expects_err_ptr b/usr/src/tools/smatch/src/smatch_data/kernel.expects_err_ptr
new file mode 100644
index 0000000000..353169eeb9
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.expects_err_ptr
@@ -0,0 +1,67 @@
+// list of functions which expect an ERR_PTR.
+// generated by `gen_expects_err_ptr.sh`
+bnx2fc_flogi_resp 1
+bnx2fc_logo_resp 1
+cfg80211_unlock_rdev 0
+cifs_get_tlink 0
+cifs_put_tlink 0
+class_destroy 0
+clusterip_seq_stop 1
+device_create_vargs 0
+d_obtain_alias 0
+do_readlink 2
+d_splice_alias 0
+fc_disc_gpn_ft_resp 1
+fc_disc_gpn_id_resp 1
+fc_els_resp_type 0
+fc_exch_rrq_resp 1
+fc_fcp_rec_resp 1
+fc_fcp_recv 1
+fc_fcp_srr_resp 1
+fc_lport_bsg_resp 1
+fc_lport_flogi_resp 1
+fc_lport_logo_resp 1
+fc_lport_ms_resp 1
+fc_lport_ns_resp 1
+fc_lport_scr_resp 1
+fcoe_flogi_resp 1
+fcoe_logo_resp 1
+fc_rport_adisc_resp 1
+fc_rport_error 1
+fc_rport_flogi_resp 1
+fc_rport_logo_resp 1
+fc_rport_plogi_resp 1
+fc_rport_prli_resp 1
+fc_rport_rtv_resp 1
+fc_tm_done 1
+free_link 0
+ft_recv_seq 1
+ieee80211_wep_decrypt_data 0
+ieee80211_wep_encrypt_data 0
+is_bad 0
+is_error_page 0
+kmemleak_alloc 0
+kmemleak_alloc_percpu 0
+kmemleak_free 0
+kmemleak_free_part 0
+kmemleak_free_percpu 0
+kmemleak_ignore 0
+kmemleak_no_scan 0
+kmemleak_not_leak 0
+kmemleak_scan_area 0
+kmemleak_seq_stop 1
+nfs3_cache_acls 1
+nfs3_cache_acls 2
+nfs_follow_remote_path 0
+ntfs_runlists_merge 0
+ntfs_runlists_merge 1
+osduld_put_device 0
+PTR_RET 0
+quota_quotaon 4
+regulator_put 0
+securityfs_remove 0
+tty_read 0
+__vfs_follow_link 1
+vfs_readlink 3
+wait_on_page_read 0
+xs_error 0
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.frees_argument b/usr/src/tools/smatch/src/smatch_data/kernel.frees_argument
new file mode 100644
index 0000000000..309f96b7e2
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.frees_argument
@@ -0,0 +1,518 @@
+// list of functions and the argument they free.
+// generated by `gen_frees_list.sh`
+__aarp_expire 0
+acpi_bus_hot_remove_device 0
+acpi_ds_delete_walk_state 0
+acpi_ev_delete_gpe_xrupt 0
+acpi_os_delete_lock 0
+acpi_ut_delete_internal_object_list 0
+ad714x_remove 0
+adu_delete 0
+adxl34x_remove 0
+ahc_alloc 1
+ahc_dma_tag_destroy 1
+ahc_free 0
+ahd_dma_tag_destroy 1
+ahd_free 0
+amixer_mgr_destroy 0
+ap_free_sta 1
+argv_free 0
+ast_connector_destroy 0
+ast_crtc_destroy 0
+ast_encoder_destroy 0
+ast_i2c_destroy 0
+ast_ttm_backend_destroy 0
+asus_cleanup_pci_hotplug 0
+ata_sas_port_destroy 0
+ath10k_htc_destroy 0
+ath10k_htt_detach 0
+ath6kl_wmi_shutdown 0
+ath9k_htc_hw_free 0
+ath_gen_timer_free 1
+ath_mci_del_profile 2
+atm_mpoa_delete_qos 0
+atom_destroy 0
+au0828_usb_release 0
+audit_free_rule 0
+autofs4_free_ino 0
+__ax25_put_route 0
+b1_free_card 0
+b43_destroy_pioqueue_rx 0
+balloon_devinfo_free 0
+balloon_mapping_free 0
+bar_release 2
+batadv_hash_destroy 0
+bcm_remove_op 0
+bio_free_map_data 0
+bl_free_lseg 0
+blkg_free 0
+blk_trace_free 0
+block2mtd_free_device 0
+bnx2fc_hba_destroy 0
+bnx2x_exe_queue_free_elem 1
+brcmf_free_vif 1
+brcms_c_ampdu_detach 0
+brcms_c_antsel_detach 0
+brcms_c_bsscfg_mfree 0
+brcms_c_channel_mgr_detach 0
+brcms_ucode_free_buf 0
+bsg_destroy_job 0
+btrfs_free_block_rsv 1
+btrfsic_block_free 0
+btrfsic_block_link_free 0
+btrfsic_dev_state_free 0
+btrfsic_stack_frame_free 0
+c2_dealloc_ucontext 0
+cache_destroy_net 0
+call_usermodehelper_freeinfo 0
+cat_destroy 0
+cat_destroy 1
+cciss_free_sg_chain_blocks 0
+cdc_ncm_free 0
+ceph_auth_destroy 0
+ceph_mdsmap_destroy 0
+ceph_put_page_vector 0
+ceph_release_page_vector 0
+cffrml_free 0
+cfg80211_dev_free 0
+channel_detector_exit 1
+cipso_v4_doi_free 0
+cirrus_connector_destroy 0
+cirrus_ttm_backend_destroy 0
+class_compat_unregister 0
+class_create_release 0
+class_osdblk_release 0
+class_pktcdvd_release 0
+clkdev_drop 0
+close_bwqcam 0
+close_cqcam 0
+cls_destroy 0
+cls_destroy 1
+cm109_usb_cleanup 0
+cma3000_exit 0
+cm_create_port_fs 0
+cm_free_work 0
+common_destroy 0
+common_destroy 1
+complete_agent_reset_write_no_wait 4
+cond_destroy_bool 0
+cond_destroy_bool 1
+context_free 0
+crush_destroy_bucket_list 0
+crush_destroy_bucket_straw 0
+crush_destroy_bucket_tree 0
+crush_destroy_bucket_uniform 0
+crystalhd_delete_dioq 1
+CsrWifiNmeApPfree 0
+CsrWifiRouterCtrlPfree 0
+CsrWifiRouterPfree 0
+CsrWifiRouterTransportSerialiseAndSend 1
+CsrWifiSmePfree 0
+ct_atc_destroy 0
+ct_mixer_destroy 0
+ct_timer_free 0
+cuse_gendev_release 0
+cxio_hal_destroy_resource 0
+cyttsp_remove 0
+dapm_free_path 0
+db9_remove 0
+dca_free_domain 0
+delete_adapter 0
+delete_attr_set 0
+delete_port 0
+destroy_8023_client 0
+destroy_av 1
+destroy_cache_args 0
+destroy_EII_client 0
+destroy_header_iter 0
+destroy_htc_txctrl_packet 0
+destroy_log_context 0
+destroy_mount_options 0
+destroy_trace_option_files 0
+devinfo_seq_stop 1
+diolan_u2c_free 0
+dlm_free_lvb 0
+dlm_free_pagevec 0
+dl_seq_next 1
+dma_buf_detach 1
+dma_unpin_iovec_pages 0
+dm_bio_prison_destroy 0
+dm_block_manager_destroy 0
+dm_deferred_set_destroy 0
+dm_free_md_mempools 0
+dmi_entry_free 0
+dm_io_client_destroy 0
+doc_release_device 0
+do_sync_work 0
+do_thaw_all 0
+drbd_free_bc 0
+drr_destroy_class 1
+dummy_free 0
+dvb_unregister_device 0
+dynamic_kobj_release 0
+_edac_mc_free 0
+eeepc_cleanup_pci_hotplug 0
+efivarfs_destroy 0
+erase_callback 0
+eventfd_free_ctx 0
+ext4_remove_li_request 0
+extcon_dev_release 0
+fb_destroy_modedb 0
+fcoe_sysfs_fcf_del 0
+fib_free_table 0
+filenametr_destroy 0
+filenametr_destroy 1
+flexcop_device_kfree 0
+flow_destroy_filter 1
+flush_entry_free 0
+__fmc_sdb_free 0
+force_clean_group 0
+__fprog_destroy 0
+framebuffer_release 0
+free_buffer_page 0
+free_buf_info 1
+free_cmd 0
+free_cmd_box 1
+free_conn 0
+free_context 0
+free_cpumask_var 0
+free_dca_provider 0
+free_device_state 0
+free_dev_ioctl 0
+free_event_entry 0
+free_fake_cpuc 0
+free_flex_gd 0
+free_fw_cache_entry 0
+free_hba 0
+free_i7core_dev 0
+free_imon_context 0
+free_ipath 0
+free_irq_cfg 1
+free_link_state 0
+free_local_pdev 0
+free_log_tree 1
+free_map_info 0
+free_msg 0
+free_ncci 1
+free_param_target 0
+free_partition 0
+free_partitions 0
+free_pasid_state 0
+free_pgpath 0
+free_pipe_info 0
+free_pl 0
+free_plci 1
+free_sbridge_dev 0
+free_sched_domains 0
+free_sched_group 0
+free_symbol_cache 0
+free_sysfs_super_info 0
+free_trace_uprobe 0
+free_trial_cpuset 0
+free_tty_struct 0
+free_usb_address 1
+free_watch_adapter 0
+__free_xattr 0
+fsnotify_final_destroy_group 0
+fs_path_free 0
+ftl_erase_callback 0
+ftrace_free_entry 0
+fuse_file_free 0
+fuse_free_conn 0
+fwnet_pd_delete 0
+fwnet_receive_packet 1
+garp_attr_destroy 1
+gcov_iter_free 0
+gc_remove 0
+gen_pool_destroy 0
+gf128mul_free_4k 0
+gf128mul_free_64k 0
+gntdev_free_map 0
+gred_destroy_vq 0
+groups_free 0
+gsm_free_mux 0
+gss_do_free_ctx 0
+gss_free_cred 0
+hashtab_destroy 0
+hfs_bnode_free 0
+hfsplus_bnode_free 0
+hid_free_report 0
+hidinput_cleanup_hidinput 1
+hsi_free_msg 0
+hso_free_shared_int 0
+htb_destroy_class 1
+i2c_tiny_usb_free 0
+i2o_block_device_free 0
+i2o_exec_wait_free 0
+i915_error_object_free 0
+ib_dealloc_device 0
+ibft_kobj_release 0
+ibmpex_bmc_delete 0
+idmouse_delete 0
+ieee80211_key_free_common 0
+if_spi_h2c 1
+iio_buffer_remove_and_free_scan_dev_attr 1
+iio_channel_release_all_cb 0
+iio_dealloc_pollfunc 0
+iio_device_remove_and_free_read_attr 1
+intel_crt_destroy 0
+intel_dvo_destroy 0
+intel_hdmi_destroy 0
+intel_set_config_free 0
+intel_tv_destroy 0
+ioeventfd_release 0
+iommu_domain_free 0
+iowarrior_delete 0
+ip6mr_free_table 0
+ipack_bus_unregister 0
+ipath_user_sdma_queue_destroy 0
+ipmr_free_table 0
+__ipoctal_remove 0
+ip_options_get_finish 2
+ip_vs_app_inc_destroy 0
+ip_vs_dest_dst_free 0
+ip_vs_service_free 0
+ip_vs_sync_buff_release 0
+ipwireless_network_free 0
+__ircomm_close 0
+__ircomm_tty_cleanup 0
+__irda_task_delete 0
+__iriap_close 0
+__irias_delete_attrib 0
+__irias_delete_object 0
+irias_delete_value 0
+__irlap_close 0
+__irlmp_close_lsap 0
+isdn_v110_close 0
+iwch_free_fastreg_pbl 0
+iwl_trans_pcie_free 0
+jffs2_free_full_dirent 0
+kbd_disconnect 0
+kvm_arch_free_vm 0
+lapb_free_cb 0
+libipw_txb_free 0
+loop_remove 0
+lpfc_els_free_bpl 1
+lpfc_els_hbq_free 1
+lpfc_free_ct_rsp 1
+lpfc_hba_free 0
+lpfc_sli4_rb_free 1
+mac_destroy 0
+mac_hid_emumouse_disconnect 0
+mce_device_release 0
+mdiobus_free 0
+md_unplug 0
+mei_io_cb_free 0
+mempool_kfree 0
+__mesh_table_free 0
+mga_connector_destroy 0
+mgag200_i2c_destroy 0
+mgag200_ttm_backend_destroy 0
+minstrel_free 0
+mlx4_en_filter_free 0
+mmc_free_ext_csd 0
+mmc_test_free_mem 0
+move_node 2
+mpi_free_limb_space 0
+mpt_adapter_dispose 0
+mptsas_port_delete 1
+mrp_attr_destroy 1
+mthca_free_mailbox 1
+mv88e1xxx_destroy 0
+mv88x201x_destroy 0
+mwifiex_unregister 0
+my3126_destroy 0
+netlink_consume_callback 0
+netlink_destroy_callback 0
+nfc_llc_free 0
+nfc_llcp_free_sdp_tlv 0
+nfc_mei_phy_free 0
+nfs3_free_createdata 0
+nfs41_free_stateid_release 0
+nfs4_delegreturn_release 0
+nfs4_free_open_state 0
+nfs4_free_pages 0
+nfs4_release_lockowner_release 0
+nfs4_remove_reclaim_record 0
+nfs_free_createdata 0
+nfs_free_unlinkdata 0
+n_hdlc_release 0
+nouveau_abi16_ntfy_fini 1
+nouveau_gem_object_del 0
+nouveau_object_destroy 0
+nv50_dac_destroy 0
+nv50_pior_destroy 0
+nv50_sor_destroy 0
+nv_poweroff_work 0
+ocfs2_free_refcount_tree 0
+_osd_request_free 0
+osst_release_request 0
+ovs_vport_free 0
+oz_isoc_stream_free 0
+p9_idpool_destroy 0
+padata_free_pd 0
+pci_mmconfig_remove 0
+pcxhr_chip_free 0
+pcxhr_free 0
+perm_destroy 0
+perm_destroy 1
+pkt_free_packet_data 0
+pm3393_destroy 0
+pmu_dev_release 0
+pnp_free_resource 0
+portman_free 0
+pps_device_destruct 0
+psb_intel_i2c_destroy 0
+psb_mmu_driver_takedown 0
+psb_mmu_free_pt 0
+pstore_ftrace_seq_stop 1
+pt1_free_adapter 0
+put_nfs_open_dir_context 0
+pvr2_hdw_destroy 0
+pvr2_sysfs_release 0
+pvr2_v4l2_destroy_no_lock 0
+qib_free_fast_reg_page_list 0
+qib_user_sdma_queue_destroy 0
+qlcnic_sriov_cleanup_transaction 0
+qlt_release 0
+qp_host_free_queue 0
+queue_delete 0
+quickstart_button_del 0
+qxl_ring_free 0
+r10bio_pool_free 0
+r1bio_pool_free 0
+r8712_free_cmd_obj 0
+r8712_getbbrfreg_cmdrsp_callback 1
+r8712_readtssi_cmdrsp_callback 1
+radeon_connector_destroy 0
+radeon_dp_connector_destroy 0
+radeon_i2c_destroy 0
+radeon_vm_bo_rmv 1
+range_tr_destroy 0
+range_tr_destroy 1
+rate_control_pid_free_sta 2
+__rds_put_mr_final 0
+realloc_argv 1
+recent_entry_remove 1
+redrat3_delete 0
+regmap_del_irq_chip 1
+regmap_field_free 0
+regmap_mmio_free_context 0
+release_memory_resource 0
+__remove_pg_pool 1
+__remove_xattr 1
+rem_res_tree 0
+rfkill_disconnect 0
+rio_release_outb_dbell 1
+role_destroy 0
+role_destroy 1
+rose_remove_node 0
+rose_remove_route 0
+rpc_destroy_pipe_data 0
+rpc_free_iostats 0
+rtd_release 0
+saa7164_buffer_dealloc_user 0
+sbp_free_request 0
+sbp_management_agent_unregister 0
+sbp_target_agent_unregister 0
+sb_register_oss 0
+sb_unload 0
+selinux_release_secctx 0
+selinux_tun_dev_free_security 0
+sens_destroy 0
+sens_destroy 1
+slhc_free 0
+smsdvb_unregister_client 0
+smtc_free_fb_info 0
+snd_ak4113_free 0
+snd_ak4114_free 0
+snd_ak4117_free 0
+snd_ca0106_free 0
+snd_card_do_free 0
+snd_cs5530_free 0
+snd_cs5535audio_free 0
+snd_emu10k1_free 0
+snd_hda_bus_free 0
+snd_hwdep_free 0
+snd_i2c_device_free 0
+snd_lx6464es_free 0
+snd_midi_channel_free_set 0
+snd_mixart_chip_free 0
+snd_mixart_free 0
+snd_mts64_free 0
+snd_opl3_free 0
+snd_pcm_oss_release_file 0
+snd_pcm_plugin_free 0
+snd_sbdsp_free 0
+snd_seq_device_free 0
+snd_uart16550_free 0
+snd_usb_audio_free 0
+snd_usb_mixer_free 0
+__snd_util_mem_free 1
+snd_util_memhdr_free 0
+snd_vx222_free 0
+solo_enc_free 0
+_sp2d_free 0
+squashfs_cache_delete 0
+src_mgr_destroy 0
+st_release_request 0
+stub_device_free 0
+sum_mgr_destroy 0
+system_root_device_release 0
+t1_espi_destroy 0
+t1_tp_destroy 0
+target_fabric_configfs_free 0
+__team_option_inst_del 0
+tgfx_remove 0
+tipc_free_entry 0
+tomoyo_memory_free 0
+tower_delete 0
+tpci200_release_device 0
+ttm_transfered_destroy 0
+tty_audit_buf_free 0
+type_destroy 0
+type_destroy 1
+udl_connector_destroy 0
+udl_crtc_destroy 0
+udl_enc_destroy 0
+unifi_free_card 0
+_unload_intf_hdl 0
+unregister_from_lirc 0
+unx_free_cred 0
+usb_cleanup 0
+usb_free_descriptors 0
+usbhsh_ureq_free 1
+usblp_cleanup 0
+usb_pcwd_delete 0
+user_destroy 0
+user_destroy 1
+v4l2_m2m_release 0
+vb2_dma_contig_cleanup_ctx 0
+vb2_put_vma 0
+vcs_poll_data_free 0
+vfio_group_unlock_and_free 0
+via_aux_free 0
+vic_provinfo_free 0
+video_device_release 0
+vmci_handle_arr_destroy 0
+vme_dma_free_attribute 0
+vme_dma_list_free 0
+vme_lm_free 0
+vme_slave_free 0
+vmw_sou_destroy 0
+__vxge_hw_channel_free 0
+w1_slave_detach 0
+wl1271_rx_filter_free 0
+wlc_phy_shim_detach 0
+w_resync_finished 0
+xencons_free 0
+xen_pcibk_config_field_free 0
+xfrm_policy_destroy 0
+xhci_free_container_ctx 1
+xhci_segment_free 1
+xt_unregister_table 0
+xz_dec_lzma2_end 0
+zbud_destroy_pool 0
+zoran_vdev_release 0
+zram_meta_free 0
+zs_destroy_pool 0
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.frees_argument.remove b/usr/src/tools/smatch/src/smatch_data/kernel.frees_argument.remove
new file mode 100644
index 0000000000..7d1ac1f1d0
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.frees_argument.remove
@@ -0,0 +1,7 @@
+free_cell 0
+free_scq 0
+free_scq 1
+setup_card 0
+krealloc 0
+free_urbs 0
+free_area 0
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.gfp_flags b/usr/src/tools/smatch/src/smatch_data/kernel.gfp_flags
new file mode 100644
index 0000000000..86b59edaaa
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.gfp_flags
@@ -0,0 +1,230 @@
+// list of GFP flag parameters.
+// generated by `gen_gfp_flags.sh`
+aa_alloc_file_context 0
+aa_alloc_task_context 0
+aligned_kmalloc 1
+alloc_buffer 1
+alloc_bulk_urbs_generic 5
+alloc_cmd_box 1
+alloc_cpu_rmap 1
+alloc_ep 1
+alloc_new_range 2
+__alloc_objio_seg 1
+alloc_pl 0
+alloc_send_rmpp_list 1
+alloc_ts_config 1
+alloc_workqueue_attrs 0
+apparmor_cred_alloc_blank 1
+apparmor_cred_prepare 2
+array_zalloc 2
+asd_alloc_edbs 1
+asd_alloc_escbs 1
+ath_rate_alloc_sta 2
+b44_alloc_consistent 1
+bch_bio_split 2
+bio_alloc 0
+bio_alloc_bioset 0
+bio_alloc_drbd 0
+bio_alloc_map_data 2
+bio_alloc_mddev 0
+bio_chain_clone 1
+bio_clone 1
+bio_clone_bioset 1
+bio_clone_kmalloc 1
+bio_clone_mddev 1
+bio_clone_range 3
+bio_integrity_alloc 1
+bio_integrity_clone 2
+bio_kmalloc 0
+bio_kmalloc 1
+__bio_map_kern 3
+bio_map_kern 3
+bl_alloc_layout_hdr 1
+bl_alloc_lseg 2
+blk_rq_prep_clone 3
+bm_init 2
+bnx2_alloc_rx_data 3
+br_netpoll_enable 1
+btrfs_bio_alloc 3
+btrfs_bio_clone 1
+btrfs_dio_bio_alloc 2
+btrfs_io_bio_alloc 0
+call_usermodehelper_setup 3
+carl9170_usb_alloc_rx_urb 1
+cas_page_alloc 1
+ceph_alloc_page_vector 1
+ceph_buffer_new 1
+ceph_create_snap_context 1
+cfg80211_inform_bss 9
+compressed_bio_alloc 2
+core_tmr_alloc_req 3
+create_endpoint_and_queue_bulk 7
+create_endpoint_and_queue_control 5
+create_endpoint_and_queue_int 7
+cxgbi_alloc_big_mem 1
+_dev_list_add 3
+devm_kzalloc 1
+devres_open_group 2
+drm_mm_get_block_generic 4
+drm_mm_get_block_range_generic 6
+drm_mm_kmalloc 1
+dummy_urb_enqueue 2
+dwc2_hcd_qh_create 2
+dwc2_hcd_qtd_add 3
+dwc2_hcd_urb_alloc 2
+dwc2_hcd_urb_enqueue 3
+dwc3_gadget_ep_alloc_request 1
+ehci_mem_init 1
+ep_alloc_request 1
+ext4_kvmalloc 1
+ext4_kvzalloc 1
+__fa_get_part 2
+fb_alloc_cmap_gfp 3
+filelayout_alloc_layout_hdr 1
+filelayout_alloc_lseg 2
+flex_array_alloc 2
+flush_entry_alloc 0
+fotg210_ep_alloc_request 1
+fsm_init 2
+__fuse_request_alloc 1
+get_1284_register 3
+get_swap_bio 0
+goku_alloc_request 1
+gss_import_sec_context 5
+gss_import_sec_context_kerberos 4
+heap_init 2
+hsi_alloc_controller 1
+hsi_alloc_msg 1
+ib_sa_guid_info_rec_query 7
+ib_sa_mcmember_rec_query 7
+ib_sa_path_rec_get 6
+ib_sa_service_rec_query 7
+ioat2_alloc_ring 2
+ioat_dma_alloc_descriptor 1
+iso_sched_alloc 1
+iso_stream_alloc 0
+itd_urb_transaction 3
+kcalloc 2
+kcryptd_io_read 1
+kdb_strdup 1
+__kmalloc 1
+kmalloc 1
+kmalloc_array 2
+kmp_init 2
+kstruprdup 1
+kzalloc 1
+libipw_alloc_txb 3
+m66592_alloc_request 1
+mca_bucket_alloc 2
+mempool_kmalloc 0
+minstrel_alloc_sta 2
+minstrel_ht_alloc_sta 2
+mpage_alloc 3
+mthca_alloc_mailbox 1
+mv_alloc_request 1
+mv_u3d_alloc_request 1
+net2272_alloc_request 1
+net2280_alloc_request 1
+netlbl_secattr_alloc 0
+netlbl_secattr_cache_alloc 0
+netlbl_secattr_catmap_alloc 0
+netlbl_secattr_catmap_setbit 2
+netlbl_secattr_catmap_setrng 3
+new_task_smack 2
+new_writequeue_entry 1
+nfs4_alloc_pages 1
+nfs4_alloc_state_owner 2
+nfs4_find_or_create_slot 3
+nfs4_label_alloc 1
+nfs4_new_slot 3
+nfs4_pnfs_remotestr 1
+nfs_alloc_seqid 1
+objio_alloc_lseg 4
+objlayout_alloc_layout_hdr 1
+_osd_request_alloc 0
+osd_start_request 1
+oz_build_endpoints_for_interface 3
+oz_ep_alloc 0
+pch_udc_alloc_request 1
+pool_alloc_page 1
+posix_acl_alloc 1
+posix_acl_from_mode 1
+pscsi_get_bio 0
+pxa_ep_alloc_request 1
+qla2x00_alloc_fcport 1
+qset_add_urb 3
+qset_add_urb_sg 3
+qset_fill_page_list 2
+qset_new_std 3
+r10bio_pool_alloc 0
+r10buf_pool_alloc 0
+r1bio_pool_alloc 0
+r1buf_pool_alloc 0
+r8a66597_alloc_request 1
+rate_control_pid_alloc_sta 2
+rcu_string_strdup 1
+rds_ib_conn_alloc 1
+rds_iw_conn_alloc 1
+rds_loop_conn_alloc 1
+rds_message_alloc 1
+request_firmware_nowait 4
+resize_iovec 1
+rfcomm_dlc_alloc 0
+rpipe_get_idle 3
+rtl_rate_alloc_sta 2
+rx_alloc_submit 1
+sctp_add_bind_addr 3
+sctp_association_new 3
+sctp_auth_asoc_set_secret 3
+sctp_auth_create_key 1
+sctp_auth_shkey_create 1
+sctp_bind_addr_copy 4
+sctp_bind_addr_dup 2
+sctp_bind_addrs_to_raw 2
+sctp_copy_one_addr 4
+sctp_datamsg_new 0
+sctp_endpoint_new 1
+sctp_make_init_ack 2
+sctp_transport_new 2
+sctp_tsnmap_init 3
+sdebug_device_create 1
+sdev_evt_alloc 1
+sdev_evt_send_simple 2
+security_context_to_sid_core 4
+security_context_to_sid_default 4
+selinux_cred_alloc_blank 1
+selinux_sk_alloc_security 2
+set_1284_register 3
+sg_kmalloc 1
+sierra_setup_urb 5
+sitd_urb_transaction 3
+smack_cred_alloc_blank 1
+smack_cred_prepare 2
+srp_alloc_iu 2
+sta_info_alloc 2
+submit_async_request 5
+target_submit_tmr 6
+team_port_enable_netpoll 2
+ubi_zalloc_vid_hdr 1
+udc_alloc_request 1
+ulist_alloc 0
+update_display_visual 1
+usb_alloc_urb 1
+usbhsg_ep_alloc_request 1
+usbhsh_data_stage_packet_push 3
+usbhsh_endpoint_attach 2
+usbhsh_queue_push 2
+usbhsh_status_stage_packet_push 3
+usbhsh_ureq_alloc 2
+vic_provinfo_alloc 0
+xfrm_policy_alloc 1
+xhci_alloc_command 3
+xhci_alloc_container_ctx 2
+xhci_alloc_segments_for_ring 6
+xhci_alloc_tt_info 4
+xhci_ring_alloc 4
+xhci_ring_expansion 3
+xhci_segment_alloc 2
+xpc_kmalloc_cacheline_aligned 1
+xpc_kzalloc_cacheline_aligned 1
+zbud_create_pool 0
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.ignore_macro_indenting b/usr/src/tools/smatch/src/smatch_data/kernel.ignore_macro_indenting
new file mode 100644
index 0000000000..8ffeb01be0
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.ignore_macro_indenting
@@ -0,0 +1,6 @@
+while_each_pid_thread
+while_each_pid_task
+LOCKDEP_STATE
+get_user_catch
+put_user_catch
+tcp_skb_tsorted_restore
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.ignore_memcpy_struct_overflows b/usr/src/tools/smatch/src/smatch_data/kernel.ignore_memcpy_struct_overflows
new file mode 100644
index 0000000000..9cf7578a2a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.ignore_memcpy_struct_overflows
@@ -0,0 +1,3 @@
+/* list for struct types to ignore */
+lpfc_fdmi_attr_entry
+be_cmd_req_hdr
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.ignore_side_effects b/usr/src/tools/smatch/src/smatch_data/kernel.ignore_side_effects
new file mode 100644
index 0000000000..e94fa1e605
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.ignore_side_effects
@@ -0,0 +1,67 @@
+/*
+ * Manually created.
+ *
+ * Most of these have intentional side effects.
+ * Some of them like put_user() and friends, have side effects when __CHECKER__
+ * is defined but not in the compiled kernel.
+ */
+ADD_STA_STATS
+ARCH_DLINFO
+AWDATA
+ENCODE
+ENCODE_DATA
+ENCODE_STR
+get_child
+get_child_rcu
+get_unaligned
+get_user
+__get_user
+__get_user_nocheck
+hybrid_tuner_request_state
+iterate_bvec
+iterate_all_kinds
+lookup
+lookup_rightempty
+MAKE_RAW_BYTE
+MAKE_RAW_BYTE_56K
+mdelay
+MsgHead
+MUL64
+NEW_AUX_ENT
+nh_vmac_nhbytes
+ntohl
+OUT_RING_REG
+poly_step
+PUT_BYTE
+put_short
+put_user
+__put_user
+__put_user_nocheck
+R128_WAIT_UNTIL_PAGE_FLIPPED
+R600_CLEAR_AGE
+R600_DISPATCH_AGE
+R600_FRAME_AGE
+RADEON_CLEAR_AGE
+RADEON_DISPATCH_AGE
+RADEON_FLUSH_CACHE
+RADEON_FRAME_AGE
+RADEON_PURGE_CACHE
+RADEON_PURGE_ZCACHE
+RADEON_WAIT_UNTIL_2D_IDLE
+RADEON_WAIT_UNTIL_3D_IDLE
+RADEON_WAIT_UNTIL_IDLE
+RCU_INIT_POINTER
+READ64
+rtnl_dereference
+send_bits
+send_code
+SOCK_ADDR_LOAD_NESTED_FIELD
+SOCK_ADDR_LOAD_NESTED_FIELD_SIZE_OFF
+SOCK_ADDR_LOAD_OR_STORE_NESTED_FIELD_SIZE_OFF
+SOCK_ADDR_LOAD_OR_STORE_NESTED_FIELD
+SOCK_OPS_GET_TCP32
+unsafe_get_user
+unsafe_put_user
+VIA_OUT_RING_QW
+WRITE64
+Z
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.ignore_uninitialized_param b/usr/src/tools/smatch/src/smatch_data/kernel.ignore_uninitialized_param
new file mode 100644
index 0000000000..f76216cfff
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.ignore_uninitialized_param
@@ -0,0 +1,104 @@
+regmap_read 2
+regmap_fields_read 2
+visorchannel_read 2
+dmam_alloc_coherent 2
+diva_pci_alloc_consistent 2
+read_mos_reg 3
+adp5520_read 2
+gameport_cooked_read 2
+max3100_sr 1
+sata_scr_read 2
+svia_scr_read 2
+lp8788_read_byte 2
+qla83xx_rd_reg 2
+cciss_read_capacity 2
+cciss_read_capacity 3
+rio_mport_read_config_32 4
+acpi_read 0
+axi_clkgen_mmcm_read 2
+intel_msic_irq_read 2
+pci_user_read_config_word 2
+ec_read 1
+sony_call_snc_handle 2
+pci_user_read_config_word 2
+read_reg_fp 2
+vid_blk_read_word 2
+mc417_memory_read 2
+stv06xx_read_sensor 2
+lm90_read_reg 2
+read_mii_word 3
+read_eprom_word 2
+generic_ocp_read 2
+lan78xx_read_reg 2
+com20020_copy_from_card 3
+wl3501_get_from_wla 2
+ipw_get_ordinal 2
+generic_ocp_read 3
+et131x_mii_read 2
+ql_mii_read_reg 2
+atl1c_read_phy_dbg 2
+atl2_read_phy_reg 2
+atl1_read_phy_reg 2
+pch_gbe_hal_read_phy_reg 2
+t1_tpi_read 2
+rio_local_read_config_32 2
+acpi_smbus_read 4
+pci_read_config_dword 2
+viafb_i2c_readbyte 3
+bap_read 1
+of_get_property 2
+of_property_read_u32 2
+of_property_read_u8 2
+of_property_read_u16 2
+of_property_read_u32_index 3
+intel_gvt_hypervisor_read_gpa 2
+cs5536_read 1
+__amd64_read_pci_cfg_dword 2
+e1e_rphy 2
+imx_phy_reg_read 0
+chipio_read 0
+had_read_register 1
+qcaspi_read_register 2
+mv88e6xxx_g2_read 2
+b53_read8 3
+b53_read16 3
+b53_read32 3
+b53_read48 3
+b53_read64 3
+dvbtqam_get_acc_pkt_err 1
+ch7xxx_readb 2
+ivch_read 2
+tvp7002_read 2
+rtsx_pci_read_register 2
+rtsx_usb_ep0_read_register 2
+__t1_tpi_read 2
+smsc95xx_read_reg 2
+pci_user_read_config_dword 2
+da903x_read 2
+rio_read_config_8 2
+rio_read_config_16 2
+rio_read_config_32 2
+__ad7280_read32 1
+rtsx_read_cfg_dw 3
+lola_read_param 3
+soc_dapm_read 2
+read_nic_byte 2
+amd_smn_read 2
+meson_ao_cec_read 2
+pci_read_config_byte 2
+pci_read_config_word 2
+i40e_read_nvm_word 2
+stk_camera_read_reg 2
+cnl_get_buf_trans_edp 1
+cnl_get_buf_trans_dp 1
+intel_ddi_get_buf_trans_edp 1
+intel_ddi_get_buf_trans_dp 1
+cnl_get_buf_trans_hdmi 1
+iosf_mbi_read 3
+lola_codec_read 5
+chipio_read 2
+pcxhr_write_io_num_reg_cont 3
+read_current_timer 0
+pwrap_read 2
+dibusb_read_eeprom_byte 2
+of_fdt_unflatten_tree 2
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.ignored_macros b/usr/src/tools/smatch/src/smatch_data/kernel.ignored_macros
new file mode 100644
index 0000000000..768fc631a9
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.ignored_macros
@@ -0,0 +1,21 @@
+/*
+ * These macros are actively misleading to smatch so 
+ * it's best to ignore them.
+ */
+WARN_ON
+B43legacy_WARN_ON
+B43_WARN_ON
+/* ASSERT can be worthwhile or bogus. */
+HPI_DEBUG_ASSERT
+snd_BUG_ON
+WARN_ON_ONCE
+ubi_assert
+bfa_assert
+ZD_ASSERT
+ubifs_assert
+AR_DEBUG_ASSERT
+RT_ASSERT
+SKD_ASSERT
+SNIC_BUG_ON
+LASSERT
+AA_BUG
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.implicit_dependencies.no_structs b/usr/src/tools/smatch/src/smatch_data/kernel.implicit_dependencies.no_structs
new file mode 100644
index 0000000000..70f0cb63bd
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.implicit_dependencies.no_structs
@@ -0,0 +1,610 @@
+C_SYSC_setsockopt read_list: [(struct proto_ops)->compat_setsockopt, ]
+C_SYSC_getsockopt read_list: [(struct proto_ops)->compat_getsockopt, ]
+SYSC_sendto read_list: [(struct file)->f_flags, ]
+SYSC_recvfrom read_list: [(struct file)->f_flags, ]
+SYSC_recvmmsg read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct msghdr)->msg_flags, ]
+SYSC_bpf read_list: [(struct mm_segment_t)->seg, (struct bpf_map)->key_size, (struct bpf_map)->map_type, (union bpf_attr)->flags, (union bpf_attr)->prog_flags, (union bpf_attr)->insn_cnt, (union bpf_attr)->kern_version, (struct bpf_prog)->insns, (union bpf_attr)->bpf_fd, (struct bpf_verifier_ops)->test_run, (struct file)->private_data, ]
+SYSC_rt_sigtimedwait read_list: [(struct task_struct)->timer_slack_ns, (struct mm_segment_t)->seg, (struct siginfo)->si_code, (struct siginfo)->si_signo, ]
+C_SYSC_rt_sigtimedwait read_list: [(struct task_struct)->timer_slack_ns, ]
+SYSC_kill read_list: [(union anonymous)->__c, ]
+SYSC_rt_sigqueueinfo read_list: [(struct siginfo)->si_code, ]
+C_SYSC_rt_sigqueueinfo read_list: [(struct siginfo)->si_code, ]
+SYSC_rt_tgsigqueueinfo read_list: [(struct siginfo)->si_code, ]
+C_SYSC_rt_tgsigqueueinfo read_list: [(struct siginfo)->si_code, ]
+SYSC_rt_sigaction read_list: [(union anonymous)->__c, (union anonymous)->__c, ]
+C_SYSC_rt_sigaction read_list: [(union anonymous)->__c, (union anonymous)->__c, ]
+C_SYSC_sigaction read_list: [(struct mm_segment_t)->seg, (union anonymous)->__c, (union anonymous)->__c, ]
+SYSC_signal read_list: [(union anonymous)->__c, (union anonymous)->__c, ]
+SYSC_delete_module read_list: [(union anonymous)->__c, (struct module)->state, (struct module)->init, (struct module)->exit, ]
+SYSC_init_module read_list: [(struct load_info)->len, (struct module)->name, (struct module)->args, (struct load_info)->num_debug, (struct module)->num_kp, (struct module_layout)->base, (struct module_layout)->size, ]
+SYSC_finit_module read_list: [(struct module)->name, (struct module)->args, (struct load_info)->num_debug, (struct module)->num_kp, (struct module_layout)->base, (struct module_layout)->size, ]
+SYSC_ptrace read_list: [(struct task_struct)->ptrace, (struct task_struct)->flags, (struct task_struct)->exit_state, (struct task_struct)->state, ]
+C_SYSC_ptrace read_list: [(struct task_struct)->ptrace, (struct task_struct)->flags, (struct task_struct)->exit_state, (struct task_struct)->state, ]
+SYSC_unshare read_list: [(struct fs_struct)->users, (union anonymous)->__c, ]
+C_SYSC_sigprocmask read_list: [(struct sigset_t)->sig, ]
+C_SYSC_sched_getaffinity read_list: [(struct cpumask)->bits, ]
+C_SYSC_migrate_pages read_list: [(struct mm_segment_t)->seg, (struct nodemask_t)->bits, ]
+SYSC_perf_event_open read_list: [(struct mm_segment_t)->seg, (struct perf_event_attr)->__reserved_1, (struct perf_event_attr)->sample_type, (struct perf_event_attr)->read_format, (struct perf_event_attr)->exclude_kernel, (struct perf_event_attr)->exclude_user, (struct perf_event_attr)->exclude_hv, (struct perf_event_attr)->sample_regs_user, (struct perf_event_attr)->sample_stack_user, (struct perf_event_attr)->sample_stack_user, (struct perf_event_attr)->sample_regs_intr, (struct perf_event_attr)->namespaces, (struct perf_event_attr)->freq, (struct perf_event_attr)->sample_freq, (struct perf_event_attr)->sample_period, (struct perf_event_attr)->sample_max_stack, (struct perf_event_attr)->inherit, (struct hw_perf_event)->sample_period, (struct pmu)->nr_addr_filters, (struct perf_event)->addr_filters_offs, (struct perf_event)->destroy, (struct pmu)->capabilities, (struct perf_event_attr)->use_clockid, (struct pmu)->task_ctx_nr, (struct perf_event)->event_caps, (struct perf_event)->group_caps, (struct perf_event)->attach_state, (struct pmu)->task_ctx_size, (struct perf_event_context)->task_ctx_data, (struct task_struct)->flags, (union anonymous)->__c, (union anonymous)->__c, (struct perf_event)->clock, (struct perf_event)->cpu, (struct perf_event_attr)->exclusive, (struct perf_event_attr)->pinned, (union anonymous)->__c, (struct perf_event)->read_size, (struct perf_event)->header_size, (struct perf_event)->id_header_size, (struct perf_cpu_context)->online, (struct perf_event_attr)->disabled, (union anonymous)->__c, (union anonymous)->__c, (struct perf_event)->nr_siblings, (struct fd)->flags, ]
+SYSC_futex read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct timespec)->tv_nsec, ]
+SYSC_setpriority read_list: [(union anonymous)->__c, ]
+SYSC_getpriority read_list: [(union anonymous)->__c, ]
+SYSC_setpgid read_list: [(struct task_struct)->exit_signal, (struct task_struct)->flags, (struct signal_struct)->leader, ]
+sys_setsid read_list: [(struct signal_struct)->leader, ]
+SYSC_newuname read_list: [(struct task_struct)->personality, (struct new_utsname)->release, (struct new_utsname)->machine, ]
+SYSC_uname read_list: [(struct task_struct)->personality, (struct old_utsname)->release, (struct old_utsname)->machine, ]
+SYSC_olduname read_list: [(struct mm_segment_t)->seg, (struct oldold_utsname)->machine, (struct task_struct)->personality, (struct oldold_utsname)->release, ]
+SYSC_gethostname read_list: [(struct new_utsname)->nodename, ]
+C_SYSC_setrlimit read_list: [(struct compat_rlimit)->rlim_cur, (struct compat_rlimit)->rlim_max, ]
+C_SYSC_getrlimit read_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+SYSC_old_getrlimit read_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+C_SYSC_old_getrlimit read_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+SYSC_prlimit64 read_list: [(struct rlimit64)->rlim_cur, (struct rlimit64)->rlim_max, (union anonymous)->__c, (struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+SYSC_setrlimit read_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+SYSC_getrusage read_list: [(struct signal_struct)->maxrss, ]
+C_SYSC_getrusage read_list: [(struct signal_struct)->maxrss, ]
+SYSC_prctl read_list: [(struct mm_struct)->flags, (struct task_struct)->timer_slack_ns, (struct task_struct)->flags, (struct task_struct)->personality, ]
+SYSC_sysinfo read_list: [(struct timespec)->tv_nsec, (struct sysinfo)->loads, (struct sysinfo)->totalram, (struct sysinfo)->totalswap, ]
+C_SYSC_sysinfo read_list: [(struct timespec)->tv_nsec, (struct sysinfo)->loads, (struct sysinfo)->totalram, (struct sysinfo)->totalswap, (struct sysinfo)->mem_unit, (struct mm_segment_t)->seg, ]
+SYSC_setns read_list: [(struct proc_ns_operations)->type, ]
+SYSC_timer_create read_list: [(struct k_clock)->timer_create, ]
+C_SYSC_timer_create read_list: [(struct k_clock)->timer_create, ]
+SYSC_timer_gettime read_list: [(struct k_clock)->timer_get, ]
+C_SYSC_timer_gettime read_list: [(struct k_clock)->timer_get, ]
+SYSC_timer_settime read_list: [(struct k_clock)->timer_set, ]
+C_SYSC_timer_settime read_list: [(struct k_clock)->timer_set, ]
+SYSC_timer_delete read_list: [(struct k_clock)->timer_del, ]
+SYSC_clock_settime read_list: [(struct k_clock)->clock_set, ]
+SYSC_clock_adjtime read_list: [(struct k_clock)->clock_adj, ]
+C_SYSC_clock_settime read_list: [(struct k_clock)->clock_set, ]
+C_SYSC_clock_adjtime read_list: [(struct k_clock)->clock_adj, ]
+SYSC_clock_nanosleep read_list: [(struct k_clock)->nsleep, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_clock_nanosleep read_list: [(struct k_clock)->nsleep, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_getitimer read_list: [(struct signal_struct)->it_real_incr, ]
+C_SYSC_getitimer read_list: [(struct signal_struct)->it_real_incr, ]
+SYSC_alarm read_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, ]
+SYSC_setitimer read_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct signal_struct)->it_real_incr, ]
+C_SYSC_setitimer read_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct signal_struct)->it_real_incr, ]
+SYSC_nanosleep read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_nanosleep read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_settimeofday read_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct timezone)->tz_minuteswest, ]
+C_SYSC_settimeofday read_list: [(struct timezone)->tz_minuteswest, ]
+SYSC_syslog read_list: [(struct mm_segment_t)->seg, ]
+C_SYSC_futex read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct timespec)->tv_nsec, ]
+SYSC_sysctl read_list: [(struct __sysctl_args)->oldval, (struct __sysctl_args)->oldlenp, ]
+C_SYSC_sysctl read_list: [(struct compat_sysctl_args)->oldval, (struct compat_sysctl_args)->oldlenp, ]
+SYSC_membarrier read_list: [(struct cpumask)->bits, ]
+SYSC_sched_setattr read_list: [(struct mm_segment_t)->seg, (struct sched_attr)->sched_policy, ]
+SYSC_sched_getscheduler read_list: [(struct task_struct)->sched_reset_on_fork, ]
+SYSC_sched_getparam read_list: [(struct task_struct)->policy, ]
+SYSC_sched_getattr read_list: [(struct task_struct)->sched_reset_on_fork, (struct task_struct)->policy, (struct mm_segment_t)->seg, (struct sched_attr)->size, ]
+SYSC_sched_setaffinity read_list: [(struct task_struct)->flags, (union anonymous)->__c, (struct root_domain)->span, ]
+SYSC_sched_rr_get_interval read_list: [(struct rq_flags)->flags, (struct sched_class)->get_rr_interval, ]
+SYSC_acct read_list: [(struct file)->f_mode, ]
+SYSC_getgroups16 read_list: [(struct group_info)->ngroups, ]
+SYSC_setgroups16 read_list: [(struct group_info)->ngroups, ]
+SYSC_mremap read_list: [(struct task_struct)->personality, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct vm_area_struct)->vm_pgoff, (struct mm_struct)->map_count, (struct vm_operations_struct)->mremap, ]
+SYSC_brk read_list: [(struct mm_struct)->start_brk, (struct mm_struct)->end_data, (struct mm_struct)->start_data, (struct mm_struct)->brk, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_start, (struct mm_struct)->def_flags, ]
+SYSC_remap_file_pages read_list: [(struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, ]
+SYSC_munlock read_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, ]
+SYSC_mlockall read_list: [(struct mm_struct)->total_vm, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct task_struct)->personality, ]
+sys_munlockall read_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, ]
+SYSC_move_pages read_list: [(struct nodemask_t)->bits, ]
+SYSC_readahead read_list: [(struct file)->f_mode, (struct fd)->flags, ]
+SYSC_swapoff read_list: [(struct swap_info_struct)->flags, (struct swap_info_struct)->pages, (struct swap_info_struct)->prio, (struct page)->private, (struct swp_entry_t)->val, (struct swap_info_struct)->swap_map, (struct swap_info_struct)->inuse_pages, ]
+SYSC_swapon read_list: [(struct swap_info_struct)->flags, (union anonymous)->__c, (struct inode)->i_flags, (struct address_space_operations)->readpage, (struct cpumask)->bits, (struct swap_info_struct)->type, ]
+SYSC_mprotect read_list: [(struct task_struct)->personality, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_end, ]
+SYSC_pkey_mprotect read_list: [(struct task_struct)->personality, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_end, ]
+SYSC_pkey_alloc read_list: [(struct cpuinfo_x86)->x86_capability, (struct mm_context_t)->pkey_allocation_map, ]
+SYSC_mincore read_list: [(struct mm_segment_t)->seg, (struct vm_area_struct)->vm_start, ]
+SYSC_mbind read_list: [(struct nodemask_t)->bits, ]
+SYSC_set_mempolicy read_list: [(struct nodemask_t)->bits, (struct mempolicy)->mode, ]
+SYSC_migrate_pages read_list: [(struct nodemask_t)->bits, (struct nodemask_t)->bits, ]
+SYSC_get_mempolicy read_list: [(struct vm_operations_struct)->get_policy, (struct mempolicy)->mode, (struct task_struct)->il_prev, (struct nodemask_t)->bits, ]
+C_SYSC_mbind read_list: [(struct nodemask_t)->bits, ]
+SYSC_msync read_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_flags, ]
+SYSC_fadvise64_64 read_list: [(struct inode)->i_flags, (struct fd)->flags, ]
+SYSC_madvise read_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, ]
+sys_rt_sigreturn read_list: [(struct mm_segment_t)->seg, (struct thread_struct)->uaccess_err, ]
+SYSC_set_thread_area read_list: [(struct thread_struct)->fsindex, (struct thread_struct)->gsindex, ]
+sys_modify_ldt read_list: [(struct user_desc)->entry_number, (struct user_desc)->contents, (struct user_desc)->seg_not_present, (struct user_desc)->base_addr, (struct user_desc)->limit, (struct user_desc)->read_exec_only, (struct user_desc)->seg_32bit, (struct user_desc)->limit_in_pages, (struct user_desc)->useable, ]
+sys_ioperm read_list: [(struct thread_struct)->io_bitmap_ptr, ]
+SYSC_keyctl read_list: [(struct key)->description, (struct key_type)->name, (struct key)->perm, (struct key_type)->read, (struct key_user)->qnkeys, (struct key_user)->qnbytes, (struct key)->quotalen, (struct task_struct)->pid, (union anonymous)->__c, (struct key)->serial, ]
+SYSC_msgctl read_list: [(struct msqid64_ds)->msg_qbytes, (struct ipc_namespace)->msg_ctlmnb, ]
+SYSC_msgsnd read_list: [(struct ipc_namespace)->msg_ctlmax, ]
+SYSC_msgrcv read_list: [(struct msg_msg)->m_ts, (union anonymous)->__c, ]
+SYSC_mq_open read_list: [(struct filename)->name, ]
+SYSC_mq_timedsend read_list: [(struct file)->f_mode, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct mq_attr)->mq_maxmsg, (struct file)->f_flags, ]
+SYSC_mq_timedreceive read_list: [(struct file)->f_mode, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct file)->f_flags, (struct msg_msg)->m_ts, ]
+SYSC_mq_notify read_list: [(struct sigevent)->sigev_notify, (struct sigevent)->sigev_signo, (struct sk_buff)->data, (union sigval)->sival_ptr, ]
+SYSC_mq_getsetattr read_list: [(struct mq_attr)->mq_flags, ]
+C_SYSC_mq_open read_list: [(struct filename)->name, ]
+C_SYSC_mq_timedsend read_list: [(struct file)->f_mode, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct mq_attr)->mq_maxmsg, (struct file)->f_flags, ]
+C_SYSC_mq_timedreceive read_list: [(struct file)->f_mode, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct file)->f_flags, (struct msg_msg)->m_ts, ]
+C_SYSC_mq_notify read_list: [(struct sigevent)->sigev_notify, (struct sigevent)->sigev_signo, (struct sk_buff)->data, (union sigval)->sival_ptr, ]
+C_SYSC_mq_getsetattr read_list: [(struct mq_attr)->mq_flags, ]
+C_SYSC_msgctl read_list: [(struct mm_segment_t)->seg, ]
+C_SYSC_shmctl read_list: [(struct mm_segment_t)->seg, (struct shminfo64)->shmmax, ]
+SYSC_semctl read_list: [(struct sem_array)->sem_nsems, ]
+SYSC_semtimedop read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct sembuf)->sem_num, (struct sembuf)->sem_flg, (struct sembuf)->sem_op, (struct sem_array)->sem_nsems, (struct sem_array)->use_global_lock, (union anonymous)->__c, (struct kern_ipc_perm)->deleted, (struct sem_undo)->semid, (struct sem_queue)->dupsop, (struct sem_array)->complex_count, (struct sem_queue)->nsops, ]
+SYSC_shmctl read_list: [(struct kern_ipc_perm)->deleted, (struct kern_ipc_perm)->mode, ]
+SYSC_shmdt read_list: [(struct vm_area_struct)->vm_pgoff, ]
+SYSC_quotactl read_list: [(struct filename)->name, (struct super_block)->s_quota_types, (struct quotactl_ops)->quota_sync, (struct super_block)->s_flags, ]
+SYSC_vmsplice read_list: [(struct file)->f_mode, (struct splice_desc)->total_len, (struct fd)->flags, ]
+SYSC_splice read_list: [(struct file)->f_mode, (struct file)->f_flags, (struct fd)->flags, ]
+SYSC_tee read_list: [(struct file)->f_mode, (struct fd)->flags, ]
+SYSC_io_setup read_list: [(struct kioctx)->req_batch, (struct kioctx)->max_reqs, (struct kioctx)->mmap_size, (struct kioctx)->mmap_base, (union anonymous)->__c, ]
+C_SYSC_io_setup read_list: [(struct kioctx)->req_batch, (struct kioctx)->max_reqs, (struct kioctx)->mmap_size, (struct kioctx)->mmap_base, (union anonymous)->__c, ]
+SYSC_io_destroy read_list: [(union anonymous)->__c, (struct kioctx_table)->nr, (struct kioctx)->user_id, (union anonymous)->__c, (struct kioctx)->max_reqs, (struct kioctx)->mmap_size, (struct kioctx)->mmap_base, ]
+SYSC_io_submit read_list: [(struct mm_segment_t)->seg, ]
+C_SYSC_io_submit read_list: [(struct mm_segment_t)->seg, ]
+SYSC_io_cancel read_list: [(union anonymous)->__c, (struct kioctx_table)->nr, (struct kioctx)->user_id, ]
+SYSC_io_getevents read_list: [(union anonymous)->__c, (struct kioctx_table)->nr, (struct kioctx)->user_id, (struct task_struct)->timer_slack_ns, ]
+SYSC_name_to_handle_at read_list: [(struct export_operations)->fh_to_dentry, (struct file_handle)->handle_bytes, ]
+SYSC_ioctl read_list: [(struct fd)->flags, ]
+SYSC_sysfs read_list: [(struct file_system_type)->name, (struct filename)->name, ]
+SYSC_signalfd4 read_list: [(struct fd)->flags, ]
+SYSC_stat read_list: [(struct task_struct)->comm, (struct kstat)->dev, (struct __old_kernel_stat)->st_ino, (struct kstat)->ino, (struct __old_kernel_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->rdev, ]
+SYSC_lstat read_list: [(struct task_struct)->comm, (struct kstat)->dev, (struct __old_kernel_stat)->st_ino, (struct kstat)->ino, (struct __old_kernel_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->rdev, ]
+SYSC_fstat read_list: [(struct task_struct)->comm, (struct kstat)->dev, (struct __old_kernel_stat)->st_ino, (struct kstat)->ino, (struct __old_kernel_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->rdev, ]
+SYSC_newstat read_list: [(struct kstat)->dev, (struct stat)->st_ino, (struct kstat)->ino, (struct stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->rdev, ]
+SYSC_newlstat read_list: [(struct kstat)->dev, (struct stat)->st_ino, (struct kstat)->ino, (struct stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->rdev, ]
+SYSC_newfstatat read_list: [(struct kstat)->dev, (struct stat)->st_ino, (struct kstat)->ino, (struct stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->rdev, ]
+SYSC_newfstat read_list: [(struct kstat)->dev, (struct stat)->st_ino, (struct kstat)->ino, (struct stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->rdev, ]
+SYSC_readlinkat read_list: [(struct inode_operations)->readlink, ]
+C_SYSC_newstat read_list: [(struct kstat)->dev, (struct kstat)->rdev, (struct compat_stat)->st_ino, (struct kstat)->ino, (struct compat_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->size, ]
+C_SYSC_newlstat read_list: [(struct kstat)->dev, (struct kstat)->rdev, (struct compat_stat)->st_ino, (struct kstat)->ino, (struct compat_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->size, ]
+C_SYSC_newfstatat read_list: [(struct kstat)->dev, (struct kstat)->rdev, (struct compat_stat)->st_ino, (struct kstat)->ino, (struct compat_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->size, ]
+C_SYSC_newfstat read_list: [(struct kstat)->dev, (struct kstat)->rdev, (struct compat_stat)->st_ino, (struct kstat)->ino, (struct compat_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->size, ]
+SYSC_old_readdir read_list: [(struct readdir_callback)->result, (struct fd)->flags, ]
+SYSC_getdents read_list: [(struct mm_segment_t)->seg, (struct fd)->flags, ]
+SYSC_getdents64 read_list: [(struct mm_segment_t)->seg, (struct fd)->flags, ]
+C_SYSC_old_readdir read_list: [(struct compat_readdir_callback)->result, (struct fd)->flags, ]
+C_SYSC_getdents read_list: [(struct mm_segment_t)->seg, (struct fd)->flags, ]
+SYSC_dup3 read_list: [(union anonymous)->__c, (struct fdtable)->max_fds, (struct files_struct)->resize_in_progress, (union anonymous)->__c, (union anonymous)->__c, (union anonymous)->__c, ]
+SYSC_fsetxattr read_list: [(struct fd)->flags, ]
+SYSC_fgetxattr read_list: [(struct fd)->flags, ]
+SYSC_flistxattr read_list: [(struct fd)->flags, ]
+SYSC_fremovexattr read_list: [(struct fd)->flags, ]
+SYSC_uselib read_list: [(struct vfsmount)->mnt_flags, (struct super_block)->s_iflags, (struct linux_binfmt)->load_shlib, ]
+SYSC_umount read_list: [(struct vfsmount)->mnt_flags, (struct super_operations)->umount_begin, (struct super_block)->s_flags, (struct task_struct)->flags, ]
+SYSC_mount read_list: [(struct task_struct)->personality, ]
+SYSC_pivot_root read_list: [(struct vfsmount)->mnt_flags, ]
+C_SYSC_mount read_list: [(struct ncp_mount_data)->mounted_vol, (struct compat_ncp_mount_data)->mounted_vol, (struct compat_nfs4_mount_data_v1)->auth_flavours, (struct compat_nfs4_mount_data_v1)->host_addr, ]
+SYSC_lseek read_list: [(struct fd)->flags, ]
+SYSC_llseek read_list: [(struct fd)->flags, ]
+SYSC_read read_list: [(struct fd)->flags, ]
+SYSC_write read_list: [(struct fd)->flags, ]
+SYSC_pread64 read_list: [(struct file)->f_mode, (struct fd)->flags, ]
+SYSC_pwrite64 read_list: [(struct file)->f_mode, (struct fd)->flags, ]
+SYSC_preadv read_list: [(struct file)->f_mode, ]
+SYSC_preadv2 read_list: [(struct file)->f_mode, ]
+SYSC_pwritev read_list: [(struct file)->f_mode, ]
+SYSC_pwritev2 read_list: [(struct file)->f_mode, ]
+C_SYSC_preadv64 read_list: [(struct file)->f_mode, ]
+C_SYSC_preadv read_list: [(struct file)->f_mode, ]
+C_SYSC_preadv64v2 read_list: [(struct file)->f_mode, ]
+C_SYSC_preadv2 read_list: [(struct file)->f_mode, ]
+C_SYSC_pwritev64 read_list: [(struct file)->f_mode, ]
+C_SYSC_pwritev read_list: [(struct file)->f_mode, ]
+C_SYSC_pwritev64v2 read_list: [(struct file)->f_mode, ]
+C_SYSC_pwritev2 read_list: [(struct file)->f_mode, ]
+SYSC_sendfile read_list: [(struct file)->f_mode, ]
+SYSC_sendfile64 read_list: [(struct file)->f_mode, ]
+C_SYSC_sendfile read_list: [(struct file)->f_mode, ]
+C_SYSC_sendfile64 read_list: [(struct file)->f_mode, ]
+SYSC_copy_file_range read_list: [(struct fd)->flags, ]
+SYSC_timerfd_create read_list: [(struct timerfd_ctx)->clockid, ]
+SYSC_timerfd_settime read_list: [(struct timerfd_ctx)->expired, (struct timerfd_ctx)->tintv, (struct timerfd_ctx)->tintv, ]
+SYSC_timerfd_gettime read_list: [(struct timerfd_ctx)->expired, (struct timerfd_ctx)->tintv, (struct timerfd_ctx)->tintv, ]
+C_SYSC_timerfd_settime read_list: [(struct timerfd_ctx)->expired, (struct timerfd_ctx)->tintv, (struct timerfd_ctx)->tintv, ]
+C_SYSC_timerfd_gettime read_list: [(struct timerfd_ctx)->expired, (struct timerfd_ctx)->tintv, (struct timerfd_ctx)->tintv, ]
+SYSC_select read_list: [(union anonymous)->__c, (struct fd_set_bits)->in, (struct fd_set_bits)->out, (struct fd_set_bits)->ex, (struct fd_set_bits)->res_in, (struct fd_set_bits)->res_out, (struct fd_set_bits)->res_ex, (struct task_struct)->personality, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_pselect6 read_list: [(struct mm_segment_t)->seg, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_poll read_list: [(struct poll_list)->entries, (struct poll_list)->len, ]
+SYSC_ppoll read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct poll_list)->entries, (struct poll_list)->len, (struct task_struct)->personality, ]
+C_SYSC_select read_list: [(union anonymous)->__c, (struct fd_set_bits)->in, (struct fd_set_bits)->out, (struct fd_set_bits)->ex, (struct fd_set_bits)->res_in, (struct fd_set_bits)->res_out, (struct fd_set_bits)->res_ex, (struct task_struct)->personality, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_pselect6 read_list: [(struct mm_segment_t)->seg, (struct compat_timespec)->tv_sec, (struct compat_timespec)->tv_nsec, ]
+C_SYSC_ppoll read_list: [(struct compat_timespec)->tv_sec, (struct compat_timespec)->tv_nsec, (struct poll_list)->entries, (struct poll_list)->len, (struct task_struct)->personality, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_syncfs read_list: [(struct fd)->flags, ]
+SYSC_sync_file_range read_list: [(struct fd)->flags, ]
+SYSC_ftruncate read_list: [(struct file)->f_flags, (struct file)->f_mode, (struct inode)->i_flags, ]
+C_SYSC_ftruncate read_list: [(struct file)->f_flags, (struct file)->f_mode, (struct inode)->i_flags, ]
+SYSC_fallocate read_list: [(struct fd)->flags, ]
+SYSC_fchdir read_list: [(struct fd)->flags, ]
+SYSC_fchmod read_list: [(struct fd)->flags, ]
+SYSC_fchown read_list: [(struct fd)->flags, ]
+SYSC_utimensat read_list: [(struct timespec)->tv_nsec, ]
+SYSC_futimesat read_list: [(struct timeval)->tv_usec, (struct timespec)->tv_nsec, ]
+C_SYSC_utime read_list: [(struct timespec)->tv_nsec, ]
+C_SYSC_utimensat read_list: [(struct timespec)->tv_nsec, ]
+C_SYSC_futimesat read_list: [(struct timespec)->tv_nsec, ]
+SYSC_flock read_list: [(struct file)->f_mode, (struct file_operations)->flock, (struct super_block)->s_flags, (struct fd)->flags, ]
+SYSC_epoll_ctl read_list: [(struct file_operations)->poll, (struct epoll_event)->events, (union anonymous)->__c, (union anonymous)->__c, (struct epitem)->nwait, (struct fd)->flags, ]
+SYSC_epoll_wait read_list: [(struct mm_segment_t)->seg, (struct fd)->flags, ]
+C_SYSC_statfs read_list: [(struct kstatfs)->f_files, (struct kstatfs)->f_ffree, ]
+C_SYSC_fstatfs read_list: [(struct kstatfs)->f_files, (struct kstatfs)->f_ffree, ]
+C_SYSC_statfs64 read_list: [(struct kstatfs)->f_files, (struct kstatfs)->f_ffree, ]
+C_SYSC_fstatfs64 read_list: [(struct kstatfs)->f_files, (struct kstatfs)->f_ffree, ]
+SYSC_fcntl read_list: [(struct file)->f_mode, (struct fd)->flags, ]
+C_SYSC_fcntl64 read_list: [(struct file)->f_mode, (struct flock)->l_start, (struct flock)->l_len, (struct fd)->flags, ]
+SYSC_mknodat read_list: [(struct super_block)->s_flags, ]
+SYSC_mkdirat read_list: [(struct super_block)->s_flags, ]
+SYSC_symlinkat read_list: [(struct filename)->refcnt, (struct filename)->name, (struct filename)->iname, (struct filename)->name, ]
+SYSC_renameat2 read_list: [(struct filename)->refcnt, (struct filename)->name, (struct filename)->iname, (struct filename)->name, ]
+C_SYSC_ioctl read_list: [(struct file_operations)->compat_ioctl, (struct file_operations)->unlocked_ioctl, (struct fd)->flags, ]
+SYSC_inotify_add_watch read_list: [(struct fd)->flags, ]
+SYSC_inotify_rm_watch read_list: [(struct fd)->flags, ]
+sys_dmi_modalias_show read_list: [(struct mafield)->prefix, (struct mafield)->field, ]
+sys_copyarea read_list: [(struct fb_info)->state, (struct fb_ops)->fb_sync, ]
+sys_fillrect read_list: [(struct fb_info)->state, (struct fb_fix_screeninfo)->visual, (struct fb_ops)->fb_sync, ]
+sys_imageblit read_list: [(struct fb_info)->state, (struct fb_ops)->fb_sync, (struct fb_image)->depth, (struct fb_fix_screeninfo)->visual, ]
+sys_set_trip_temp read_list: [(struct pkg_device)->tj_max, (struct pkg_device)->cpu, ]
+SYSC_getrandom read_list: [(struct task_struct)->comm, ]
+SYSC_ioprio_set write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid)->level, (struct hlist_node)->pprev, (struct user_struct)->mq_bytes, (struct user_struct)->locked_shm, (struct user_struct)->unix_inflight, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, ]
+SYSC_ioprio_get write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid)->level, (struct hlist_node)->pprev, (struct user_struct)->mq_bytes, (struct user_struct)->locked_shm, (struct user_struct)->unix_inflight, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, ]
+C_SYSC_setsockopt write_list: [(struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+C_SYSC_getsockopt write_list: [(struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+SYSC_socket write_list: [(struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_socketpair write_list: [(struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_bind write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, (struct __kernel_sockaddr_storage)->ss_family, ]
+SYSC_listen write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+SYSC_accept4 write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, (struct proto_ops)->family, (struct proto_ops)->release, (struct proto_ops)->bind, (struct proto_ops)->connect, (struct proto_ops)->socketpair, (struct proto_ops)->accept, (struct proto_ops)->getname, (struct proto_ops)->poll, (struct proto_ops)->ioctl, (struct proto_ops)->compat_ioctl, (struct proto_ops)->listen, (struct proto_ops)->shutdown, (struct proto_ops)->setsockopt, (struct proto_ops)->getsockopt, (struct proto_ops)->compat_setsockopt, (struct proto_ops)->compat_getsockopt, (struct proto_ops)->sendmsg, (struct proto_ops)->recvmsg, (struct proto_ops)->mmap, (struct proto_ops)->sendpage, (struct proto_ops)->splice_read, (struct proto_ops)->set_peek_off, (struct proto_ops)->peek_len, (struct proto_ops)->read_sock, (struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_connect write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, (struct __kernel_sockaddr_storage)->ss_family, ]
+SYSC_getsockname write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+SYSC_getpeername write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+SYSC_sendto write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, (struct msghdr)->msg_name, (struct msghdr)->msg_control, (struct msghdr)->msg_controllen, (struct msghdr)->msg_namelen, (struct __kernel_sockaddr_storage)->ss_family, (struct msghdr)->msg_flags, ]
+SYSC_recvfrom write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, (struct msghdr)->msg_control, (struct msghdr)->msg_controllen, (struct msghdr)->msg_name, (struct msghdr)->msg_namelen, (struct msghdr)->msg_flags, ]
+SYSC_setsockopt write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+SYSC_getsockopt write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+SYSC_shutdown write_list: [(struct fd)->flags, (struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+SYSC_sendmsg write_list: [(struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+SYSC_sendmmsg write_list: [(struct socket)->state, (struct socket)->type, (struct socket)->flags, (struct used_address)->name_len, (struct user_msghdr)->msg_name, (struct user_msghdr)->msg_namelen, (struct user_msghdr)->msg_iovlen, (struct user_msghdr)->msg_control, (struct user_msghdr)->msg_controllen, (struct user_msghdr)->msg_flags, (struct mmsghdr)->msg_len, (struct compat_msghdr)->msg_name, (struct compat_msghdr)->msg_namelen, (struct compat_msghdr)->msg_iov, (struct compat_msghdr)->msg_iovlen, (struct compat_msghdr)->msg_control, (struct compat_msghdr)->msg_controllen, (struct compat_msghdr)->msg_flags, (struct compat_mmsghdr)->msg_len, ]
+SYSC_recvmsg write_list: [(struct socket)->state, (struct socket)->type, (struct socket)->flags, ]
+SYSC_recvmmsg write_list: [(struct socket)->state, (struct socket)->type, (struct socket)->flags, (struct user_msghdr)->msg_name, (struct user_msghdr)->msg_namelen, (struct user_msghdr)->msg_iovlen, (struct user_msghdr)->msg_control, (struct user_msghdr)->msg_controllen, (struct user_msghdr)->msg_flags, (struct mmsghdr)->msg_len, (struct compat_msghdr)->msg_name, (struct compat_msghdr)->msg_namelen, (struct compat_msghdr)->msg_iov, (struct compat_msghdr)->msg_iovlen, (struct compat_msghdr)->msg_control, (struct compat_msghdr)->msg_controllen, (struct compat_msghdr)->msg_flags, (struct compat_mmsghdr)->msg_len, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct sock)->sk_err, ]
+SYSC_bpf write_list: [(union bpf_attr)->map_type, (union bpf_attr)->key_size, (union bpf_attr)->value_size, (union bpf_attr)->max_entries, (union bpf_attr)->map_flags, (union bpf_attr)->inner_map_fd, (union bpf_attr)->map_fd, (union bpf_attr)->key, (union bpf_attr)->value, (union bpf_attr)->next_key, (union bpf_attr)->flags, (union bpf_attr)->prog_type, (union bpf_attr)->insn_cnt, (union bpf_attr)->insns, (union bpf_attr)->license, (union bpf_attr)->log_level, (union bpf_attr)->log_size, (union bpf_attr)->log_buf, (union bpf_attr)->kern_version, (union bpf_attr)->prog_flags, (union bpf_attr)->pathname, (union bpf_attr)->bpf_fd, (union bpf_attr)->target_fd, (union bpf_attr)->attach_bpf_fd, (union bpf_attr)->attach_type, (union bpf_attr)->attach_flags, (union bpf_attr)->start_id, (union bpf_attr)->prog_id, (union bpf_attr)->map_id, (union bpf_attr)->next_id, (struct atomic_t)->counter, (struct bpf_map)->map_type, (struct bpf_map)->key_size, (struct bpf_map)->value_size, (struct bpf_map)->max_entries, (struct bpf_map)->map_flags, (struct bpf_map)->pages, (struct bpf_map)->id, (struct atomic64_t)->counter, (struct work_struct)->func, (struct lockdep_map)->name, (struct fd)->flags, (struct bpf_prog)->pages, (struct bpf_prog)->jited, (struct bpf_prog)->locked, (struct bpf_prog)->gpl_compatible, (struct bpf_prog)->cb_access, (struct bpf_prog)->dst_needed, (struct bpf_prog)->type, (struct bpf_prog)->len, (struct bpf_prog)->jited_len, (struct bpf_prog)->bpf_func, ]
+sys_restart_syscall write_list: [(struct restart_block)->fn, ]
+SYSC_rt_sigprocmask write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_rt_sigtimedwait write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct siginfo)->si_signo, (struct siginfo)->si_errno, (struct siginfo)->si_code, (union sigval)->sival_int, (union sigval)->sival_ptr, ]
+C_SYSC_rt_sigtimedwait write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_kill write_list: [(struct siginfo)->si_signo, (struct siginfo)->si_errno, (struct siginfo)->si_code, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_tgkill write_list: [(struct siginfo)->si_signo, (struct siginfo)->si_errno, (struct siginfo)->si_code, (union anonymous)->_pad, (union sigval)->sival_int, (union sigval)->sival_ptr, ]
+SYSC_tkill write_list: [(struct siginfo)->si_signo, (struct siginfo)->si_errno, (struct siginfo)->si_code, (union anonymous)->_pad, (union sigval)->sival_int, (union sigval)->sival_ptr, ]
+SYSC_rt_sigqueueinfo write_list: [(struct siginfo)->si_signo, (struct siginfo)->si_errno, (struct siginfo)->si_code, (union sigval)->sival_int, (union sigval)->sival_ptr, ]
+C_SYSC_rt_sigqueueinfo write_list: [(struct siginfo)->si_signo, (struct siginfo)->si_errno, (struct siginfo)->si_code, (union anonymous)->_pad, (union sigval)->sival_int, (union sigval)->sival_ptr, ]
+SYSC_rt_tgsigqueueinfo write_list: [(struct siginfo)->si_signo, (struct siginfo)->si_errno, (struct siginfo)->si_code, (union sigval)->sival_int, (union sigval)->sival_ptr, ]
+C_SYSC_rt_tgsigqueueinfo write_list: [(struct siginfo)->si_signo, (struct siginfo)->si_errno, (struct siginfo)->si_code, (union anonymous)->_pad, (union sigval)->sival_int, (union sigval)->sival_ptr, ]
+SYSC_sigaltstack write_list: [(struct sigaltstack)->ss_sp, (struct sigaltstack)->ss_flags, (struct sigaltstack)->ss_size, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+C_SYSC_sigaltstack write_list: [(struct compat_sigaltstack)->ss_sp, (struct compat_sigaltstack)->ss_flags, (struct compat_sigaltstack)->ss_size, (struct sigaltstack)->ss_sp, (struct sigaltstack)->ss_flags, (struct sigaltstack)->ss_size, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_rt_sigaction write_list: [(struct sigaction)->sa_handler, (struct sigaction)->sa_flags, (struct sigaction)->sa_restorer, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+C_SYSC_rt_sigaction write_list: [(struct sigaction)->sa_handler, (struct sigaction)->sa_restorer, (struct sigaction)->sa_flags, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct sigaction)->sa_flags, ]
+C_SYSC_sigaction write_list: [(struct sigaction)->sa_flags, (struct sigaction)->sa_handler, (struct sigaction)->sa_restorer, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct sigaction)->sa_flags, ]
+SYSC_signal write_list: [(struct sigaction)->sa_handler, (struct sigaction)->sa_flags, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct sigaction)->sa_restorer, ]
+sys_pause write_list: [(struct task_struct)->task_state_change, (struct task_struct)->state, ]
+SYSC_rt_sigsuspend write_list: [(struct task_struct)->task_state_change, (struct task_struct)->state, ]
+SYSC_sigsuspend write_list: [(struct task_struct)->task_state_change, (struct task_struct)->state, ]
+SYSC_delete_module write_list: [(struct module)->state, (struct kobject)->name, (struct atomic_t)->counter, (struct kobject)->state_initialized, (struct kobject)->state_in_sysfs, (struct kobject)->state_add_uevent_sent, (struct kobject)->state_remove_uevent_sent, (struct kobject)->uevent_suppress, (struct module)->version, (struct module)->srcversion, (struct module)->crcs, (struct module)->num_syms, (struct atomic64_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mutex)->magic, (struct module)->num_kp, (struct module)->num_gpl_syms, (struct module)->gpl_crcs, (struct module)->async_probe_requested, (struct module)->gpl_future_crcs, (struct module)->num_gpl_future_syms, (struct module)->num_exentries, (struct module)->init, (struct module_layout)->base, (struct module_layout)->size, (struct module_layout)->text_size, (struct module_layout)->ro_size, (struct module_layout)->ro_after_init_size, (struct module)->taints, (struct module)->num_bugs, (struct mod_kallsyms)->num_symtab, (struct mod_kallsyms)->strtab, (struct module)->args, (struct module)->percpu, (struct module)->percpu_size, (struct module)->num_tracepoints, (struct module)->tracepoints_ptrs, (struct module)->num_jump_entries, (struct module)->num_trace_bprintk_fmt, (struct module)->trace_bprintk_fmt_start, (struct module)->trace_events, (struct module)->num_trace_events, (struct module)->trace_evals, (struct module)->num_trace_evals, (struct module)->exit, (struct module)->ctors, (struct module)->num_ctors, ]
+SYSC_init_module write_list: [(struct load_info)->name, (struct load_info)->len, (struct load_info)->secstrings, (struct load_info)->strtab, (struct load_info)->symoffs, (struct load_info)->stroffs, (struct load_info)->num_debug, (struct load_info)->sig_ok, (struct load_info)->mod_kallsyms_init_off, (struct elf64_hdr)->e_type, (struct elf64_hdr)->e_machine, (struct elf64_hdr)->e_version, (struct elf64_hdr)->e_entry, (struct elf64_hdr)->e_phoff, (struct elf64_hdr)->e_shoff, (struct elf64_hdr)->e_flags, (struct elf64_hdr)->e_ehsize, (struct elf64_hdr)->e_phentsize, (struct elf64_hdr)->e_phnum, (struct elf64_hdr)->e_shentsize, (struct elf64_hdr)->e_shnum, (struct elf64_hdr)->e_shstrndx, (struct module)->state, (struct kobject)->name, (struct atomic_t)->counter, (struct kobject)->state_initialized, (struct kobject)->state_in_sysfs, (struct kobject)->state_add_uevent_sent, (struct kobject)->state_remove_uevent_sent, (struct kobject)->uevent_suppress, (struct module)->version, (struct module)->srcversion, (struct module)->crcs, (struct module)->num_syms, (struct atomic64_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mutex)->magic, (struct module)->num_kp, (struct module)->num_gpl_syms, (struct module)->gpl_crcs, (struct module)->async_probe_requested, (struct module)->gpl_future_crcs, (struct module)->num_gpl_future_syms, (struct module)->num_exentries, (struct module)->init, (struct module_layout)->base, (struct module_layout)->size, (struct module_layout)->text_size, (struct module_layout)->ro_size, (struct module_layout)->ro_after_init_size, (struct module)->taints, (struct module)->num_bugs, (struct mod_kallsyms)->num_symtab, (struct mod_kallsyms)->strtab, (struct module)->args, (struct module)->percpu, (struct module)->percpu_size, (struct module)->num_tracepoints, (struct module)->tracepoints_ptrs, (struct module)->num_jump_entries, (struct module)->num_trace_bprintk_fmt, (struct module)->trace_bprintk_fmt_start, (struct module)->trace_events, (struct module)->num_trace_events, (struct module)->trace_evals, (struct module)->num_trace_evals, (struct module)->exit, (struct module)->ctors, (struct module)->num_ctors, ]
+SYSC_finit_module write_list: [(struct load_info)->name, (struct load_info)->len, (struct load_info)->secstrings, (struct load_info)->strtab, (struct load_info)->symoffs, (struct load_info)->stroffs, (struct load_info)->num_debug, (struct load_info)->sig_ok, (struct load_info)->mod_kallsyms_init_off, (struct elf64_hdr)->e_type, (struct elf64_hdr)->e_machine, (struct elf64_hdr)->e_version, (struct elf64_hdr)->e_entry, (struct elf64_hdr)->e_phoff, (struct elf64_hdr)->e_shoff, (struct elf64_hdr)->e_flags, (struct elf64_hdr)->e_ehsize, (struct elf64_hdr)->e_phentsize, (struct elf64_hdr)->e_phnum, (struct elf64_hdr)->e_shentsize, (struct elf64_hdr)->e_shnum, (struct elf64_hdr)->e_shstrndx, (struct module)->state, (struct kobject)->name, (struct atomic_t)->counter, (struct kobject)->state_initialized, (struct kobject)->state_in_sysfs, (struct kobject)->state_add_uevent_sent, (struct kobject)->state_remove_uevent_sent, (struct kobject)->uevent_suppress, (struct module)->version, (struct module)->srcversion, (struct module)->crcs, (struct module)->num_syms, (struct atomic64_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mutex)->magic, (struct module)->num_kp, (struct module)->num_gpl_syms, (struct module)->gpl_crcs, (struct module)->async_probe_requested, (struct module)->gpl_future_crcs, (struct module)->num_gpl_future_syms, (struct module)->num_exentries, (struct module)->init, (struct module_layout)->base, (struct module_layout)->size, (struct module_layout)->text_size, (struct module_layout)->ro_size, (struct module_layout)->ro_after_init_size, (struct module)->taints, (struct module)->num_bugs, (struct mod_kallsyms)->num_symtab, (struct mod_kallsyms)->strtab, (struct module)->args, (struct module)->percpu, (struct module)->percpu_size, (struct module)->num_tracepoints, (struct module)->tracepoints_ptrs, (struct module)->num_jump_entries, (struct module)->num_trace_bprintk_fmt, (struct module)->trace_bprintk_fmt_start, (struct module)->trace_events, (struct module)->num_trace_events, (struct module)->trace_evals, (struct module)->num_trace_evals, (struct module)->exit, (struct module)->ctors, (struct module)->num_ctors, ]
+SYSC_kexec_load write_list: [(struct kimage)->preserve_context, (struct kimage)->head, (struct kimage)->entry, (struct kimage)->last_entry, (struct kimage)->start, (struct kimage)->vmcoreinfo_data_copy, (struct kimage)->nr_segments, (struct kimage)->control_page, (struct kimage)->type, (struct kimage)->file_mode, (struct kimage_arch)->backup_src_start, (struct kimage_arch)->backup_src_sz, (struct kimage_arch)->backup_load_addr, (struct kimage_arch)->elf_headers, (struct kimage_arch)->elf_headers_sz, (struct kimage_arch)->elf_load_addr, ]
+C_SYSC_kexec_load write_list: [(struct kexec_segment)->buf, (struct kexec_segment)->kbuf, (struct kexec_segment)->bufsz, (struct kexec_segment)->mem, (struct kexec_segment)->memsz, (struct compat_kexec_segment)->buf, (struct compat_kexec_segment)->bufsz, (struct compat_kexec_segment)->mem, (struct compat_kexec_segment)->memsz, ]
+SYSC_getgroups write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, (struct uid_gid_map)->nr_extents, (struct user_namespace)->level, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, ]
+SYSC_setgroups write_list: [(struct uid_gid_map)->nr_extents, (struct atomic_t)->counter, (struct user_namespace)->level, (struct kuid_t)->val, (struct kgid_t)->val, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, (struct callback_head)->func, (struct group_info)->ngroups, ]
+SYSC_ptrace write_list: [(struct task_struct)->ptrace, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+C_SYSC_ptrace write_list: [(struct task_struct)->ptrace, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_reboot write_list: [(struct atomic_t)->counter, (struct callback_head)->func, (struct pid_namespace)->last_pid, (struct pid_namespace)->nr_hashed, (struct pid_namespace)->level, (struct atomic64_t)->counter, (struct work_struct)->func, (struct lockdep_map)->name, (struct kgid_t)->val, (struct pid_namespace)->hide_pid, (struct pid_namespace)->reboot, (struct ns_common)->inum, ]
+SYSC_set_tid_address write_list: [(struct task_struct)->clear_child_tid, ]
+sys_fork write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid)->level, (struct completion)->done, ]
+sys_vfork write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid)->level, (struct completion)->done, ]
+SYSC_clone write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid)->level, (struct completion)->done, ]
+SYSC_unshare write_list: [(struct fs_struct)->users, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct seqcount)->sequence, (struct fs_struct)->umask, (struct fs_struct)->in_exec, (struct files_struct)->resize_in_progress, (struct fdtable)->max_fds, (struct fdtable)->fd, (struct fdtable)->close_on_exec, (struct fdtable)->open_fds, (struct fdtable)->full_fds_bits, (struct callback_head)->func, (struct files_struct)->next_fd, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, ]
+C_SYSC_sched_rr_get_interval write_list: [(struct mm_segment_t)->seg, ]
+SYSC_perf_event_open write_list: [(struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct atomic64_t)->counter, (struct mutex)->magic, (struct perf_event_context)->nr_events, (struct perf_event_context)->nr_active, (struct perf_event_context)->is_active, (struct perf_event_context)->nr_stat, (struct perf_event_context)->nr_freq, (struct perf_event_context)->rotate_disable, (struct perf_event_context)->time, (struct perf_event_context)->timestamp, (struct perf_event_context)->parent_gen, (struct perf_event_context)->generation, (struct perf_event_context)->pin_count, (struct perf_event_context)->task_ctx_data, (struct callback_head)->func, (struct fd)->flags, (struct perf_event_attr)->type, (struct perf_event_attr)->size, (struct perf_event_attr)->config, (struct perf_event_attr)->sample_period, (struct perf_event_attr)->sample_freq, (struct perf_event_attr)->sample_type, (struct perf_event_attr)->read_format, (struct perf_event_attr)->disabled, (struct perf_event_attr)->inherit, (struct perf_event_attr)->pinned, (struct perf_event_attr)->exclusive, (struct perf_event_attr)->exclude_user, (struct perf_event_attr)->exclude_kernel, (struct perf_event_attr)->exclude_hv, (struct perf_event_attr)->exclude_idle, (struct perf_event_attr)->mmap, (struct perf_event_attr)->comm, (struct perf_event_attr)->freq, (struct perf_event_attr)->inherit_stat, (struct perf_event_attr)->enable_on_exec, (struct perf_event_attr)->task, (struct perf_event_attr)->watermark, (struct perf_event_attr)->precise_ip, (struct perf_event_attr)->mmap_data, (struct perf_event_attr)->sample_id_all, (struct perf_event_attr)->exclude_host, (struct perf_event_attr)->exclude_guest, (struct perf_event_attr)->exclude_callchain_kernel, (struct perf_event_attr)->exclude_callchain_user, (struct perf_event_attr)->mmap2, (struct perf_event_attr)->comm_exec, (struct perf_event_attr)->use_clockid, (struct perf_event_attr)->context_switch, (struct perf_event_attr)->write_backward, (struct perf_event_attr)->namespaces, (struct perf_event_attr)->__reserved_1, (struct perf_event_attr)->wakeup_events, (struct perf_event_attr)->wakeup_watermark, (struct perf_event_attr)->bp_type, (struct perf_event_attr)->bp_addr, (struct perf_event_attr)->config1, (struct perf_event_attr)->bp_len, (struct perf_event_attr)->config2, (struct perf_event_attr)->branch_sample_type, (struct perf_event_attr)->sample_regs_user, (struct perf_event_attr)->sample_stack_user, (struct perf_event_attr)->clockid, (struct perf_event_attr)->sample_regs_intr, (struct perf_event_attr)->aux_watermark, (struct perf_event_attr)->sample_max_stack, (struct perf_event_attr)->__reserved_2, (struct hlist_node)->pprev, (struct perf_event)->nr_siblings, (struct perf_event)->event_caps, (struct perf_event)->group_caps, (struct perf_event)->pmu_private, (struct perf_event)->state, (struct perf_event)->attach_state, (struct perf_event)->total_time_enabled, (struct perf_event)->total_time_running, (struct perf_event)->tstamp_enabled, (struct perf_event)->tstamp_running, (struct perf_event)->tstamp_stopped, (struct perf_event)->shadow_ctx_time, (struct perf_event)->header_size, (struct perf_event)->id_header_size, (struct perf_event)->read_size, (struct hw_perf_event)->config, (struct hw_perf_event)->last_tag, (struct hw_perf_event)->config_base, (struct hw_perf_event)->event_base, (struct hw_perf_event)->event_base_rdpmc, (struct hw_perf_event)->idx, (struct hw_perf_event)->last_cpu, (struct hw_perf_event)->flags, (struct hw_perf_event_extra)->config, (struct hw_perf_event_extra)->reg, (struct hw_perf_event_extra)->alloc, (struct hw_perf_event_extra)->idx, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct hw_perf_event)->cqm_state, (struct hw_perf_event)->cqm_rmid, (struct hw_perf_event)->is_group_event, (struct hw_perf_event)->itrace_started, (struct hw_perf_event)->pwr_acc, (struct hw_perf_event)->ptsc, (struct arch_hw_breakpoint)->address, (struct arch_hw_breakpoint)->mask, (struct arch_hw_breakpoint)->len, (struct arch_hw_breakpoint)->type, (struct hw_perf_event)->iommu_bank, (struct hw_perf_event)->iommu_cntr, (struct hw_perf_event)->padding, (struct hw_perf_event)->conf, (struct hw_perf_event)->conf1, (struct hw_perf_event)->addr_filters, (struct hw_perf_event)->addr_filters_gen, (struct hw_perf_event)->state, (struct hw_perf_event)->sample_period, (struct hw_perf_event)->last_period, (struct hw_perf_event)->interrupts_seq, (struct hw_perf_event)->interrupts, (struct hw_perf_event)->freq_time_stamp, (struct hw_perf_event)->freq_count_stamp, (struct perf_event)->oncpu, (struct perf_event)->cpu, (struct perf_event)->rcu_batches, (struct perf_event)->rcu_pending, (struct perf_event)->pending_wakeup, (struct perf_event)->pending_kill, (struct perf_event)->pending_disable, (struct irq_work)->flags, (struct irq_work)->func, (struct perf_addr_filters_head)->nr_file_filters, (struct perf_event)->addr_filters_offs, (struct perf_event)->addr_filters_gen, (struct perf_event)->destroy, (struct perf_event)->id, (struct perf_event)->clock, (struct perf_event)->overflow_handler, (struct perf_event)->overflow_handler_context, (struct perf_event)->orig_overflow_handler, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid_namespace)->last_pid, (struct pid_namespace)->nr_hashed, (struct pid_namespace)->level, (struct work_struct)->func, (struct kgid_t)->val, (struct pid_namespace)->hide_pid, (struct pid_namespace)->reboot, (struct ns_common)->inum, (struct bpf_prog)->pages, (struct bpf_prog)->jited, (struct bpf_prog)->locked, (struct bpf_prog)->gpl_compatible, (struct bpf_prog)->cb_access, (struct bpf_prog)->dst_needed, (struct bpf_prog)->type, (struct bpf_prog)->len, (struct bpf_prog)->jited_len, (struct bpf_prog)->bpf_func, (struct pmu)->attr_groups, (struct pmu)->name, (struct pmu)->type, (struct pmu)->capabilities, (struct pmu)->pmu_disable_count, (struct pmu)->task_ctx_nr, (struct pmu)->hrtimer_interval_ms, (struct pmu)->nr_addr_filters, (struct pmu)->pmu_enable, (struct pmu)->pmu_disable, (struct pmu)->event_init, (struct pmu)->event_mapped, (struct pmu)->event_unmapped, (struct pmu)->add, (struct pmu)->del, (struct pmu)->start, (struct pmu)->stop, (struct pmu)->read, (struct pmu)->start_txn, (struct pmu)->commit_txn, (struct pmu)->cancel_txn, (struct pmu)->event_idx, (struct pmu)->sched_task, (struct pmu)->task_ctx_size, (struct pmu)->count, (struct pmu)->setup_aux, (struct pmu)->free_aux, (struct pmu)->addr_filters_validate, (struct pmu)->addr_filters_sync, (struct pmu)->filter_match, (struct perf_cpu_context)->active_oncpu, (struct perf_cpu_context)->exclusive, (struct perf_cpu_context)->hrtimer_interval, (struct perf_cpu_context)->hrtimer_active, (struct perf_cpu_context)->sched_cb_usage, (struct perf_cpu_context)->online, (struct ring_buffer)->nr_pages, (struct ring_buffer)->overwrite, (struct ring_buffer)->paused, (struct ring_buffer)->watermark, (struct ring_buffer)->aux_watermark, (struct ring_buffer)->mmap_locked, (struct ring_buffer)->aux_pgoff, (struct ring_buffer)->aux_nr_pages, (struct ring_buffer)->aux_overwrite, (struct ring_buffer)->aux_mmap_locked, (struct ring_buffer)->free_aux, (struct ring_buffer)->aux_pages, (struct ring_buffer)->aux_priv, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_exit_group write_list: [(struct atomic_t)->counter, (struct signal_struct)->nr_threads, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct signal_struct)->group_exit_code, (struct signal_struct)->notify_count, (struct signal_struct)->group_stop_count, (struct signal_struct)->flags, (struct signal_struct)->is_child_subreaper, (struct signal_struct)->has_child_subreaper, (struct signal_struct)->posix_timer_id, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct signal_struct)->it_real_incr, (struct atomic64_t)->counter, (struct thread_group_cputimer)->running, (struct thread_group_cputimer)->checking_timer, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct signal_struct)->leader, (struct seqcount)->sequence, (struct signal_struct)->utime, (struct signal_struct)->stime, (struct signal_struct)->cutime, (struct signal_struct)->cstime, (struct signal_struct)->gtime, (struct signal_struct)->cgtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct signal_struct)->nvcsw, (struct signal_struct)->nivcsw, (struct signal_struct)->cnvcsw, (struct signal_struct)->cnivcsw, (struct signal_struct)->min_flt, (struct signal_struct)->maj_flt, (struct signal_struct)->cmin_flt, (struct signal_struct)->cmaj_flt, (struct signal_struct)->inblock, (struct signal_struct)->oublock, (struct signal_struct)->cinblock, (struct signal_struct)->coublock, (struct signal_struct)->maxrss, (struct signal_struct)->cmaxrss, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct signal_struct)->sum_sched_runtime, (struct pacct_struct)->ac_flag, (struct pacct_struct)->ac_exitcode, (struct pacct_struct)->ac_mem, (struct pacct_struct)->ac_utime, (struct pacct_struct)->ac_stime, (struct pacct_struct)->ac_minflt, (struct pacct_struct)->ac_majflt, (struct signal_struct)->audit_tty, (struct signal_struct)->oom_flag_origin, (struct signal_struct)->oom_score_adj, (struct signal_struct)->oom_score_adj_min, (struct mutex)->magic, ]
+SYSC_waitid write_list: [(struct waitid_info)->status, (struct waitid_info)->pid, (struct waitid_info)->uid, (struct waitid_info)->cause, (struct atomic_t)->counter, (struct pid)->level, (struct callback_head)->func, (struct wait_opts)->wo_type, (struct wait_opts)->wo_flags, (struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct rusage)->ru_maxrss, (struct rusage)->ru_ixrss, (struct rusage)->ru_idrss, (struct rusage)->ru_isrss, (struct rusage)->ru_minflt, (struct rusage)->ru_majflt, (struct rusage)->ru_nswap, (struct rusage)->ru_inblock, (struct rusage)->ru_oublock, (struct rusage)->ru_msgsnd, (struct rusage)->ru_msgrcv, (struct rusage)->ru_nsignals, (struct rusage)->ru_nvcsw, (struct rusage)->ru_nivcsw, ]
+SYSC_wait4 write_list: [(struct atomic_t)->counter, (struct pid)->level, (struct callback_head)->func, (struct wait_opts)->wo_type, (struct wait_opts)->wo_flags, (struct wait_opts)->wo_stat, (struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct rusage)->ru_maxrss, (struct rusage)->ru_ixrss, (struct rusage)->ru_idrss, (struct rusage)->ru_isrss, (struct rusage)->ru_minflt, (struct rusage)->ru_majflt, (struct rusage)->ru_nswap, (struct rusage)->ru_inblock, (struct rusage)->ru_oublock, (struct rusage)->ru_msgsnd, (struct rusage)->ru_msgrcv, (struct rusage)->ru_nsignals, (struct rusage)->ru_nvcsw, (struct rusage)->ru_nivcsw, ]
+C_SYSC_wait4 write_list: [(struct atomic_t)->counter, (struct pid)->level, (struct callback_head)->func, (struct wait_opts)->wo_type, (struct wait_opts)->wo_flags, (struct wait_opts)->wo_stat, (struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct rusage)->ru_maxrss, (struct rusage)->ru_ixrss, (struct rusage)->ru_idrss, (struct rusage)->ru_isrss, (struct rusage)->ru_minflt, (struct rusage)->ru_majflt, (struct rusage)->ru_nswap, (struct rusage)->ru_inblock, (struct rusage)->ru_oublock, (struct rusage)->ru_msgsnd, (struct rusage)->ru_msgrcv, (struct rusage)->ru_nsignals, (struct rusage)->ru_nvcsw, (struct rusage)->ru_nivcsw, ]
+C_SYSC_waitid write_list: [(struct waitid_info)->status, (struct waitid_info)->pid, (struct waitid_info)->uid, (struct waitid_info)->cause, (struct atomic_t)->counter, (struct pid)->level, (struct callback_head)->func, (struct wait_opts)->wo_type, (struct wait_opts)->wo_flags, (struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct rusage)->ru_maxrss, (struct rusage)->ru_ixrss, (struct rusage)->ru_idrss, (struct rusage)->ru_isrss, (struct rusage)->ru_minflt, (struct rusage)->ru_majflt, (struct rusage)->ru_nswap, (struct rusage)->ru_inblock, (struct rusage)->ru_oublock, (struct rusage)->ru_msgsnd, (struct rusage)->ru_msgrcv, (struct rusage)->ru_nsignals, (struct rusage)->ru_nvcsw, (struct rusage)->ru_nivcsw, ]
+SYSC_set_robust_list write_list: [(struct robust_list_head)->futex_offset, ]
+SYSC_get_robust_list write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct robust_list_head)->futex_offset, ]
+SYSC_futex write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_setpriority write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid)->level, (struct hlist_node)->pprev, (struct user_struct)->mq_bytes, (struct user_struct)->locked_shm, (struct user_struct)->unix_inflight, ]
+SYSC_getpriority write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid)->level, (struct hlist_node)->pprev, (struct user_struct)->mq_bytes, (struct user_struct)->locked_shm, (struct user_struct)->unix_inflight, ]
+SYSC_setregid write_list: [(struct uid_gid_map)->nr_extents, (struct atomic_t)->counter, (struct user_namespace)->level, (struct kuid_t)->val, (struct kgid_t)->val, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, (struct callback_head)->func, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, ]
+SYSC_setgid write_list: [(struct uid_gid_map)->nr_extents, (struct atomic_t)->counter, (struct user_namespace)->level, (struct kuid_t)->val, (struct kgid_t)->val, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, (struct callback_head)->func, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, ]
+SYSC_setreuid write_list: [(struct uid_gid_map)->nr_extents, (struct atomic_t)->counter, (struct user_namespace)->level, (struct kuid_t)->val, (struct kgid_t)->val, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, (struct callback_head)->func, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct user_struct)->mq_bytes, (struct user_struct)->locked_shm, (struct user_struct)->unix_inflight, (struct hlist_node)->pprev, (struct task_struct)->flags, ]
+SYSC_setuid write_list: [(struct uid_gid_map)->nr_extents, (struct atomic_t)->counter, (struct user_namespace)->level, (struct kuid_t)->val, (struct kgid_t)->val, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, (struct callback_head)->func, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct user_struct)->mq_bytes, (struct user_struct)->locked_shm, (struct user_struct)->unix_inflight, (struct hlist_node)->pprev, (struct task_struct)->flags, ]
+SYSC_setresuid write_list: [(struct uid_gid_map)->nr_extents, (struct atomic_t)->counter, (struct user_namespace)->level, (struct kuid_t)->val, (struct kgid_t)->val, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, (struct callback_head)->func, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct user_struct)->mq_bytes, (struct user_struct)->locked_shm, (struct user_struct)->unix_inflight, (struct hlist_node)->pprev, (struct task_struct)->flags, ]
+SYSC_getresuid write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, ]
+SYSC_setresgid write_list: [(struct uid_gid_map)->nr_extents, (struct atomic_t)->counter, (struct user_namespace)->level, (struct kuid_t)->val, (struct kgid_t)->val, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, (struct callback_head)->func, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, ]
+SYSC_getresgid write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, ]
+SYSC_setfsuid write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, ]
+SYSC_setfsgid write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, ]
+sys_getppid write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_times write_list: [(struct tms)->tms_utime, (struct tms)->tms_stime, (struct tms)->tms_cutime, (struct tms)->tms_cstime, ]
+C_SYSC_times write_list: [(struct tms)->tms_utime, (struct tms)->tms_stime, (struct tms)->tms_cutime, (struct tms)->tms_cstime, (struct compat_tms)->tms_utime, (struct compat_tms)->tms_stime, (struct compat_tms)->tms_cutime, (struct compat_tms)->tms_cstime, ]
+SYSC_setpgid write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid)->level, ]
+SYSC_getpgid write_list: [(struct atomic_t)->counter, (struct pid)->level, (struct callback_head)->func, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_getsid write_list: [(struct atomic_t)->counter, (struct pid)->level, (struct callback_head)->func, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+sys_setsid write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct pid)->level, (struct signal_struct)->leader, ]
+C_SYSC_setrlimit write_list: [(struct compat_rlimit)->rlim_cur, (struct compat_rlimit)->rlim_max, (struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+C_SYSC_getrlimit write_list: [(struct compat_rlimit)->rlim_cur, (struct compat_rlimit)->rlim_max, ]
+SYSC_old_getrlimit write_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+C_SYSC_old_getrlimit write_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+SYSC_prlimit64 write_list: [(struct rlimit64)->rlim_cur, (struct rlimit64)->rlim_max, (struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, ]
+SYSC_setrlimit write_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+SYSC_getrusage write_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct rusage)->ru_maxrss, (struct rusage)->ru_ixrss, (struct rusage)->ru_idrss, (struct rusage)->ru_isrss, (struct rusage)->ru_minflt, (struct rusage)->ru_majflt, (struct rusage)->ru_nswap, (struct rusage)->ru_inblock, (struct rusage)->ru_oublock, (struct rusage)->ru_msgsnd, (struct rusage)->ru_msgrcv, (struct rusage)->ru_nsignals, (struct rusage)->ru_nvcsw, (struct rusage)->ru_nivcsw, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct mm_struct)->map_count, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, ]
+C_SYSC_getrusage write_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct rusage)->ru_maxrss, (struct rusage)->ru_ixrss, (struct rusage)->ru_idrss, (struct rusage)->ru_isrss, (struct rusage)->ru_minflt, (struct rusage)->ru_majflt, (struct rusage)->ru_nswap, (struct rusage)->ru_inblock, (struct rusage)->ru_oublock, (struct rusage)->ru_msgsnd, (struct rusage)->ru_msgrcv, (struct rusage)->ru_nsignals, (struct rusage)->ru_nvcsw, (struct rusage)->ru_nivcsw, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct mm_struct)->map_count, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, ]
+SYSC_prctl write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct mm_struct)->map_count, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, (struct prctl_mm_map)->start_code, (struct prctl_mm_map)->end_code, (struct prctl_mm_map)->start_data, (struct prctl_mm_map)->end_data, (struct prctl_mm_map)->start_brk, (struct prctl_mm_map)->brk, (struct prctl_mm_map)->start_stack, (struct prctl_mm_map)->arg_start, (struct prctl_mm_map)->arg_end, (struct prctl_mm_map)->env_start, (struct prctl_mm_map)->env_end, (struct prctl_mm_map)->auxv, (struct prctl_mm_map)->auxv_size, (struct prctl_mm_map)->exe_fd, ]
+SYSC_sysinfo write_list: [(struct sysinfo)->uptime, (struct sysinfo)->totalram, (struct sysinfo)->freeram, (struct sysinfo)->sharedram, (struct sysinfo)->bufferram, (struct sysinfo)->totalswap, (struct sysinfo)->freeswap, (struct sysinfo)->procs, (struct sysinfo)->pad, (struct sysinfo)->totalhigh, (struct sysinfo)->freehigh, (struct sysinfo)->mem_unit, ]
+C_SYSC_sysinfo write_list: [(struct sysinfo)->uptime, (struct sysinfo)->totalram, (struct sysinfo)->freeram, (struct sysinfo)->sharedram, (struct sysinfo)->bufferram, (struct sysinfo)->totalswap, (struct sysinfo)->freeswap, (struct sysinfo)->procs, (struct sysinfo)->pad, (struct sysinfo)->totalhigh, (struct sysinfo)->freehigh, (struct sysinfo)->mem_unit, ]
+SYSC_setns write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct ns_common)->inum, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct pid_namespace)->last_pid, (struct pid_namespace)->nr_hashed, (struct pid_namespace)->level, (struct work_struct)->func, (struct kgid_t)->val, (struct pid_namespace)->hide_pid, (struct pid_namespace)->reboot, (struct radix_tree_root)->gfp_mask, (struct idr)->idr_next, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, (struct net)->dev_base_seq, (struct net)->ifindex, (struct net)->dev_unreg_count, (struct netns_core)->sysctl_somaxconn, (struct netns_unix)->sysctl_max_dgram_qlen, (struct netns_ipv4)->fib_has_custom_rules, (struct netns_ipv4)->fib_offload_disabled, (struct netns_ipv4)->icmp_sk, (struct netns_ipv4)->tcp_sk, (struct percpu_counter)->count, (struct percpu_counter)->counters, (struct netns_frags)->timeout, (struct netns_frags)->high_thresh, (struct netns_frags)->low_thresh, (struct netns_frags)->max_dist, (struct netns_ipv4)->sysctl_icmp_echo_ignore_all, (struct netns_ipv4)->sysctl_icmp_echo_ignore_broadcasts, (struct netns_ipv4)->sysctl_icmp_ignore_bogus_error_responses, (struct netns_ipv4)->sysctl_icmp_ratelimit, (struct netns_ipv4)->sysctl_icmp_ratemask, (struct netns_ipv4)->sysctl_icmp_errors_use_inbound_ifaddr, (struct local_ports)->warned, (struct netns_ipv4)->sysctl_tcp_ecn, (struct netns_ipv4)->sysctl_tcp_ecn_fallback, (struct netns_ipv4)->sysctl_ip_default_ttl, (struct netns_ipv4)->sysctl_ip_no_pmtu_disc, (struct netns_ipv4)->sysctl_ip_fwd_use_pmtu, (struct netns_ipv4)->sysctl_ip_nonlocal_bind, (struct netns_ipv4)->sysctl_ip_dynaddr, (struct netns_ipv4)->sysctl_ip_early_demux, (struct netns_ipv4)->sysctl_tcp_early_demux, (struct netns_ipv4)->sysctl_udp_early_demux, (struct netns_ipv4)->sysctl_fwmark_reflect, (struct netns_ipv4)->sysctl_tcp_fwmark_accept, (struct netns_ipv4)->sysctl_tcp_mtu_probing, (struct netns_ipv4)->sysctl_tcp_base_mss, (struct netns_ipv4)->sysctl_tcp_probe_threshold, (struct netns_ipv4)->sysctl_tcp_probe_interval, (struct netns_ipv4)->sysctl_tcp_keepalive_time, (struct netns_ipv4)->sysctl_tcp_keepalive_probes, (struct netns_ipv4)->sysctl_tcp_keepalive_intvl, (struct netns_ipv4)->sysctl_tcp_syn_retries, (struct netns_ipv4)->sysctl_tcp_synack_retries, (struct netns_ipv4)->sysctl_tcp_syncookies, (struct netns_ipv4)->sysctl_tcp_reordering, (struct netns_ipv4)->sysctl_tcp_retries1, (struct netns_ipv4)->sysctl_tcp_retries2, (struct netns_ipv4)->sysctl_tcp_orphan_retries, (struct netns_ipv4)->sysctl_tcp_fin_timeout, (struct netns_ipv4)->sysctl_tcp_notsent_lowat, (struct netns_ipv4)->sysctl_tcp_tw_reuse, (struct netns_ipv4)->sysctl_tcp_sack, (struct netns_ipv4)->sysctl_tcp_window_scaling, (struct netns_ipv4)->sysctl_tcp_timestamps, (struct inet_timewait_death_row)->sysctl_max_tw_buckets, (struct netns_ipv4)->sysctl_max_syn_backlog, (struct netns_ipv4)->sysctl_igmp_max_memberships, (struct netns_ipv4)->sysctl_igmp_max_msf, (struct netns_ipv4)->sysctl_igmp_llm_reports, (struct netns_ipv4)->sysctl_igmp_qrv, (struct netns_ipv4)->sysctl_local_reserved_ports, (struct netns_ipv4)->sysctl_ip_prot_sock, (struct netns_ipv4)->sysctl_fib_multipath_use_neigh, (struct netns_ipv4)->sysctl_fib_multipath_hash_policy, (struct netns_ipv4)->fib_seq, (struct netns_sysctl_ipv6)->bindv6only, (struct netns_sysctl_ipv6)->flush_delay, (struct netns_sysctl_ipv6)->ip6_rt_max_size, (struct netns_sysctl_ipv6)->ip6_rt_gc_min_interval, (struct netns_sysctl_ipv6)->ip6_rt_gc_timeout, (struct netns_sysctl_ipv6)->ip6_rt_gc_interval, (struct netns_sysctl_ipv6)->ip6_rt_gc_elasticity, (struct netns_sysctl_ipv6)->ip6_rt_mtu_expires, (struct netns_sysctl_ipv6)->ip6_rt_min_advmss, (struct netns_sysctl_ipv6)->flowlabel_consistency, (struct netns_sysctl_ipv6)->auto_flowlabels, (struct netns_sysctl_ipv6)->icmpv6_time, (struct netns_sysctl_ipv6)->anycast_src_echo_reply, (struct netns_sysctl_ipv6)->ip_nonlocal_bind, (struct netns_sysctl_ipv6)->fwmark_reflect, (struct netns_sysctl_ipv6)->idgen_retries, (struct netns_sysctl_ipv6)->idgen_delay, (struct netns_sysctl_ipv6)->flowlabel_state_ranges, (struct hlist_node)->pprev, (struct timer_list)->expires, (struct timer_list)->function, (struct timer_list)->data, (struct timer_list)->flags, (struct dst_ops)->family, (struct dst_ops)->gc_thresh, (struct dst_ops)->gc, (struct dst_ops)->check, (struct dst_ops)->default_advmss, (struct dst_ops)->mtu, (struct dst_ops)->cow_metrics, (struct dst_ops)->destroy, (struct dst_ops)->ifdown, (struct dst_ops)->negative_advice, (struct dst_ops)->link_failure, (struct dst_ops)->update_pmtu, (struct dst_ops)->redirect, (struct dst_ops)->local_out, (struct dst_ops)->neigh_lookup, (struct dst_ops)->confirm_neigh, (struct netns_ipv6)->ip6_rt_gc_expire, (struct netns_ipv6)->ip6_rt_last_gc, (struct netns_ipv6)->icmp_sk, (struct netns_nf)->defrag_ipv4, (struct netns_nf)->defrag_ipv6, (struct netns_xt)->notrack_deprecated_warning, (struct netns_xt)->clusterip_deprecated_warning, (struct netns_ct)->expect_count, (struct netns_ct)->sysctl_log_invalid, (struct netns_ct)->sysctl_events, (struct netns_ct)->sysctl_acct, (struct netns_ct)->sysctl_auto_assign_helper, (struct netns_ct)->auto_assign_helper_warned, (struct netns_ct)->sysctl_tstamp, (struct netns_ct)->sysctl_checksum, (struct nf_proto_net)->users, (struct nf_generic_net)->timeout, (struct nf_tcp_net)->tcp_loose, (struct nf_tcp_net)->tcp_be_liberal, (struct nf_tcp_net)->tcp_max_retrans, (struct nf_icmp_net)->timeout, (struct netns_xfrm)->state_hmask, (struct netns_xfrm)->state_num, (struct netns_xfrm)->policy_idx_hmask, (struct xfrm_policy_hthresh)->lbits4, (struct xfrm_policy_hthresh)->rbits4, (struct xfrm_policy_hthresh)->lbits6, (struct xfrm_policy_hthresh)->rbits6, (struct netns_xfrm)->sysctl_aevent_etime, (struct netns_xfrm)->sysctl_aevent_rseqth, (struct netns_xfrm)->sysctl_larval_drop, (struct netns_xfrm)->sysctl_acq_expires, (struct flow_cache)->hash_shift, (struct flow_cache)->low_watermark, (struct flow_cache)->high_watermark, ]
+SYSC_timer_create write_list: [(union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, (struct hlist_node)->pprev, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct k_itimer)->it_clock, (struct k_itimer)->it_id, (struct k_itimer)->it_active, (struct k_itimer)->it_overrun, (struct k_itimer)->it_overrun_last, (struct k_itimer)->it_requeue_pending, (struct k_itimer)->it_sigev_notify, (struct k_itimer)->it_interval, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct cpu_timer_list)->expires, (struct cpu_timer_list)->incr, (struct cpu_timer_list)->firing, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct callback_head)->func, (struct pid)->level, (struct siginfo)->si_signo, (struct siginfo)->si_code, (struct signal_struct)->nr_threads, (struct signal_struct)->group_exit_code, (struct signal_struct)->notify_count, (struct signal_struct)->group_stop_count, (struct signal_struct)->flags, (struct signal_struct)->is_child_subreaper, (struct signal_struct)->has_child_subreaper, (struct signal_struct)->posix_timer_id, (struct signal_struct)->it_real_incr, (struct atomic64_t)->counter, (struct thread_group_cputimer)->running, (struct thread_group_cputimer)->checking_timer, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct signal_struct)->leader, (struct seqcount)->sequence, (struct signal_struct)->utime, (struct signal_struct)->stime, (struct signal_struct)->cutime, (struct signal_struct)->cstime, (struct signal_struct)->gtime, (struct signal_struct)->cgtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct signal_struct)->nvcsw, (struct signal_struct)->nivcsw, (struct signal_struct)->cnvcsw, (struct signal_struct)->cnivcsw, (struct signal_struct)->min_flt, (struct signal_struct)->maj_flt, (struct signal_struct)->cmin_flt, (struct signal_struct)->cmaj_flt, (struct signal_struct)->inblock, (struct signal_struct)->oublock, (struct signal_struct)->cinblock, (struct signal_struct)->coublock, (struct signal_struct)->maxrss, (struct signal_struct)->cmaxrss, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct signal_struct)->sum_sched_runtime, (struct pacct_struct)->ac_flag, (struct pacct_struct)->ac_exitcode, (struct pacct_struct)->ac_mem, (struct pacct_struct)->ac_utime, (struct pacct_struct)->ac_stime, (struct pacct_struct)->ac_minflt, (struct pacct_struct)->ac_majflt, (struct signal_struct)->audit_tty, (struct signal_struct)->oom_flag_origin, (struct signal_struct)->oom_score_adj, (struct signal_struct)->oom_score_adj_min, (struct mutex)->magic, ]
+C_SYSC_timer_create write_list: [(union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, (struct hlist_node)->pprev, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct k_itimer)->it_clock, (struct k_itimer)->it_id, (struct k_itimer)->it_active, (struct k_itimer)->it_overrun, (struct k_itimer)->it_overrun_last, (struct k_itimer)->it_requeue_pending, (struct k_itimer)->it_sigev_notify, (struct k_itimer)->it_interval, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct cpu_timer_list)->expires, (struct cpu_timer_list)->incr, (struct cpu_timer_list)->firing, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct callback_head)->func, (struct pid)->level, (struct siginfo)->si_signo, (struct siginfo)->si_code, (struct signal_struct)->nr_threads, (struct signal_struct)->group_exit_code, (struct signal_struct)->notify_count, (struct signal_struct)->group_stop_count, (struct signal_struct)->flags, (struct signal_struct)->is_child_subreaper, (struct signal_struct)->has_child_subreaper, (struct signal_struct)->posix_timer_id, (struct signal_struct)->it_real_incr, (struct atomic64_t)->counter, (struct thread_group_cputimer)->running, (struct thread_group_cputimer)->checking_timer, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct signal_struct)->leader, (struct seqcount)->sequence, (struct signal_struct)->utime, (struct signal_struct)->stime, (struct signal_struct)->cutime, (struct signal_struct)->cstime, (struct signal_struct)->gtime, (struct signal_struct)->cgtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct signal_struct)->nvcsw, (struct signal_struct)->nivcsw, (struct signal_struct)->cnvcsw, (struct signal_struct)->cnivcsw, (struct signal_struct)->min_flt, (struct signal_struct)->maj_flt, (struct signal_struct)->cmin_flt, (struct signal_struct)->cmaj_flt, (struct signal_struct)->inblock, (struct signal_struct)->oublock, (struct signal_struct)->cinblock, (struct signal_struct)->coublock, (struct signal_struct)->maxrss, (struct signal_struct)->cmaxrss, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct signal_struct)->sum_sched_runtime, (struct pacct_struct)->ac_flag, (struct pacct_struct)->ac_exitcode, (struct pacct_struct)->ac_mem, (struct pacct_struct)->ac_utime, (struct pacct_struct)->ac_stime, (struct pacct_struct)->ac_minflt, (struct pacct_struct)->ac_majflt, (struct signal_struct)->audit_tty, (struct signal_struct)->oom_flag_origin, (struct signal_struct)->oom_score_adj, (struct signal_struct)->oom_score_adj_min, (struct mutex)->magic, ]
+SYSC_timer_gettime write_list: [(struct hlist_node)->pprev, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct k_itimer)->it_clock, (struct k_itimer)->it_id, (struct k_itimer)->it_active, (struct k_itimer)->it_overrun, (struct k_itimer)->it_overrun_last, (struct k_itimer)->it_requeue_pending, (struct k_itimer)->it_sigev_notify, (struct k_itimer)->it_interval, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct cpu_timer_list)->expires, (struct cpu_timer_list)->incr, (struct cpu_timer_list)->firing, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct callback_head)->func, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+C_SYSC_timer_gettime write_list: [(struct hlist_node)->pprev, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct k_itimer)->it_clock, (struct k_itimer)->it_id, (struct k_itimer)->it_active, (struct k_itimer)->it_overrun, (struct k_itimer)->it_overrun_last, (struct k_itimer)->it_requeue_pending, (struct k_itimer)->it_sigev_notify, (struct k_itimer)->it_interval, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct cpu_timer_list)->expires, (struct cpu_timer_list)->incr, (struct cpu_timer_list)->firing, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct callback_head)->func, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+SYSC_timer_getoverrun write_list: [(struct hlist_node)->pprev, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct k_itimer)->it_clock, (struct k_itimer)->it_id, (struct k_itimer)->it_active, (struct k_itimer)->it_overrun, (struct k_itimer)->it_overrun_last, (struct k_itimer)->it_requeue_pending, (struct k_itimer)->it_sigev_notify, (struct k_itimer)->it_interval, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct cpu_timer_list)->expires, (struct cpu_timer_list)->incr, (struct cpu_timer_list)->firing, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct callback_head)->func, ]
+SYSC_timer_settime write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct hlist_node)->pprev, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct k_itimer)->it_clock, (struct k_itimer)->it_id, (struct k_itimer)->it_active, (struct k_itimer)->it_overrun, (struct k_itimer)->it_overrun_last, (struct k_itimer)->it_requeue_pending, (struct k_itimer)->it_sigev_notify, (struct k_itimer)->it_interval, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct cpu_timer_list)->expires, (struct cpu_timer_list)->incr, (struct cpu_timer_list)->firing, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct callback_head)->func, (struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+C_SYSC_timer_settime write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct hlist_node)->pprev, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct k_itimer)->it_clock, (struct k_itimer)->it_id, (struct k_itimer)->it_active, (struct k_itimer)->it_overrun, (struct k_itimer)->it_overrun_last, (struct k_itimer)->it_requeue_pending, (struct k_itimer)->it_sigev_notify, (struct k_itimer)->it_interval, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct cpu_timer_list)->expires, (struct cpu_timer_list)->incr, (struct cpu_timer_list)->firing, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct callback_head)->func, (struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+SYSC_timer_delete write_list: [(struct hlist_node)->pprev, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct k_itimer)->it_clock, (struct k_itimer)->it_id, (struct k_itimer)->it_active, (struct k_itimer)->it_overrun, (struct k_itimer)->it_overrun_last, (struct k_itimer)->it_requeue_pending, (struct k_itimer)->it_sigev_notify, (struct k_itimer)->it_interval, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct cpu_timer_list)->expires, (struct cpu_timer_list)->incr, (struct cpu_timer_list)->firing, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct callback_head)->func, (struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+SYSC_clock_settime write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+SYSC_clock_gettime write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+SYSC_clock_adjtime write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, (struct timex)->modes, (struct timex)->offset, (struct timex)->freq, (struct timex)->maxerror, (struct timex)->esterror, (struct timex)->status, (struct timex)->constant, (struct timex)->precision, (struct timex)->tolerance, (struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct timex)->tick, (struct timex)->ppsfreq, (struct timex)->jitter, (struct timex)->shift, (struct timex)->stabil, (struct timex)->jitcnt, (struct timex)->calcnt, (struct timex)->errcnt, (struct timex)->stbcnt, (struct timex)->tai, ]
+SYSC_clock_getres write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+C_SYSC_clock_settime write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+C_SYSC_clock_gettime write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+C_SYSC_clock_adjtime write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+C_SYSC_clock_getres write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, ]
+SYSC_clock_nanosleep write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_clock_nanosleep write_list: [(struct k_clock)->clock_getres, (struct k_clock)->clock_set, (struct k_clock)->clock_get, (struct k_clock)->clock_adj, (struct k_clock)->timer_create, (struct k_clock)->nsleep, (struct k_clock)->timer_set, (struct k_clock)->timer_del, (struct k_clock)->timer_get, (struct k_clock)->timer_rearm, (struct k_clock)->timer_forward, (struct k_clock)->timer_remaining, (struct k_clock)->timer_try_to_cancel, (struct k_clock)->timer_arm, (struct compat_timespec)->tv_sec, (struct compat_timespec)->tv_nsec, ]
+SYSC_getitimer write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct timeval)->tv_sec, (struct timeval)->tv_usec, ]
+C_SYSC_getitimer write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct timeval)->tv_sec, (struct timeval)->tv_usec, ]
+SYSC_alarm write_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, ]
+SYSC_setitimer write_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct signal_struct)->it_real_incr, ]
+C_SYSC_setitimer write_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct signal_struct)->it_real_incr, ]
+SYSC_nanosleep write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct restart_block)->fn, ]
+C_SYSC_nanosleep write_list: [(struct compat_timespec)->tv_sec, (struct compat_timespec)->tv_nsec, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct restart_block)->fn, ]
+SYSC_stime write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct timespec)->tv_sec, ]
+C_SYSC_stime write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct timespec)->tv_sec, ]
+SYSC_settimeofday write_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct timezone)->tz_minuteswest, (struct timezone)->tz_dsttime, ]
+C_SYSC_settimeofday write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct timezone)->tz_minuteswest, (struct timezone)->tz_dsttime, ]
+SYSC_adjtimex write_list: [(struct timex)->modes, (struct timex)->offset, (struct timex)->freq, (struct timex)->maxerror, (struct timex)->esterror, (struct timex)->status, (struct timex)->constant, (struct timex)->precision, (struct timex)->tolerance, (struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct timex)->tick, (struct timex)->ppsfreq, (struct timex)->jitter, (struct timex)->shift, (struct timex)->stabil, (struct timex)->jitcnt, (struct timex)->calcnt, (struct timex)->errcnt, (struct timex)->stbcnt, (struct timex)->tai, ]
+SYSC_capget write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct __user_cap_data_struct)->effective, (struct __user_cap_data_struct)->permitted, (struct __user_cap_data_struct)->inheritable, ]
+SYSC_capset write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, ]
+SYSC_syslog write_list: [(struct printk_log)->ts_nsec, (struct printk_log)->len, (struct printk_log)->text_len, (struct printk_log)->dict_len, (struct printk_log)->facility, (struct printk_log)->flags, (struct printk_log)->level, ]
+C_SYSC_set_robust_list write_list: [(struct compat_robust_list)->next, (struct compat_robust_list_head)->futex_offset, (struct compat_robust_list_head)->list_op_pending, ]
+C_SYSC_get_robust_list write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct compat_robust_list)->next, (struct compat_robust_list_head)->futex_offset, (struct compat_robust_list_head)->list_op_pending, ]
+SYSC_sysctl write_list: [(struct __sysctl_args)->name, (struct __sysctl_args)->nlen, (struct __sysctl_args)->oldval, (struct __sysctl_args)->oldlenp, (struct __sysctl_args)->newval, (struct __sysctl_args)->newlen, ]
+C_SYSC_sysctl write_list: [(struct compat_sysctl_args)->name, (struct compat_sysctl_args)->nlen, (struct compat_sysctl_args)->oldval, (struct compat_sysctl_args)->oldlenp, (struct compat_sysctl_args)->newval, (struct compat_sysctl_args)->newlen, ]
+SYSC_personality write_list: [(struct task_struct)->personality, ]
+SYSC_sched_setscheduler write_list: [(struct sched_param)->sched_priority, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_sched_setparam write_list: [(struct sched_param)->sched_priority, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_sched_setattr write_list: [(struct sched_attr)->size, (struct sched_attr)->sched_policy, (struct sched_attr)->sched_flags, (struct sched_attr)->sched_nice, (struct sched_attr)->sched_priority, (struct sched_attr)->sched_runtime, (struct sched_attr)->sched_deadline, (struct sched_attr)->sched_period, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_sched_getscheduler write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_sched_getparam write_list: [(struct sched_param)->sched_priority, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_sched_getattr write_list: [(struct sched_attr)->size, (struct sched_attr)->sched_policy, (struct sched_attr)->sched_flags, (struct sched_attr)->sched_nice, (struct sched_attr)->sched_priority, (struct sched_attr)->sched_runtime, (struct sched_attr)->sched_deadline, (struct sched_attr)->sched_period, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_sched_setaffinity write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, ]
+SYSC_sched_getaffinity write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+sys_sched_yield write_list: [(struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct rq)->nr_running, (struct rq)->last_load_update_tick, (struct rq)->nohz_flags, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rq)->nr_load_updates, (struct rq)->nr_switches, (struct cfs_rq)->nr_running, (struct cfs_rq)->h_nr_running, (struct cfs_rq)->exec_clock, (struct cfs_rq)->min_vruntime, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct cfs_rq)->runnable_load_sum, (struct cfs_rq)->runnable_load_avg, (struct cfs_rq)->tg_load_avg_contrib, (struct cfs_rq)->propagate_avg, (struct atomic64_t)->counter, (struct cfs_rq)->h_load, (struct cfs_rq)->last_h_load_update, (struct cfs_rq)->on_list, (struct rt_rq)->rt_nr_running, (struct rt_rq)->rr_nr_running, (struct rt_rq)->rt_nr_migratory, (struct rt_rq)->rt_nr_total, (struct rt_rq)->overloaded, (struct rt_rq)->push_flags, (struct rt_rq)->push_cpu, (struct irq_work)->flags, (struct irq_work)->func, (struct rt_rq)->rt_queued, (struct rt_rq)->rt_throttled, (struct rt_rq)->rt_time, (struct rt_rq)->rt_runtime, (struct dl_rq)->dl_nr_running, (struct dl_rq)->dl_nr_migratory, (struct dl_rq)->overloaded, (struct dl_rq)->running_bw, (struct dl_rq)->this_bw, (struct dl_rq)->extra_bw, (struct dl_rq)->bw_ratio, (struct rq)->nr_uninterruptible, (struct rq)->next_balance, (struct rq)->clock_update_flags, (struct rq)->clock, (struct rq)->clock_task, (struct rq)->cpu_capacity, (struct rq)->cpu_capacity_orig, (struct rq)->idle_balance, (struct rq)->active_balance, (struct rq)->push_cpu, (struct cpu_stop_work)->fn, (struct cpu_stop_work)->arg, (struct rq)->cpu, (struct rq)->online, (struct rq)->rt_avg, (struct rq)->age_stamp, (struct rq)->idle_stamp, (struct rq)->avg_idle, (struct rq)->max_idle_balance_cost, (struct rq)->calc_load_update, (struct rq)->calc_load_active, (struct rq)->hrtick_csd_pending, (struct call_single_data)->func, (struct call_single_data)->info, (struct call_single_data)->flags, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct rq)->rq_cpu_time, (struct rq)->yld_count, (struct rq)->sched_count, (struct rq)->sched_goidle, (struct rq)->ttwu_count, (struct rq)->ttwu_local, ]
+SYSC_sched_rr_get_interval write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct rq_flags)->flags, (struct rq)->nr_running, (struct rq)->last_load_update_tick, (struct rq)->nohz_flags, (struct rq)->nr_load_updates, (struct rq)->nr_switches, (struct cfs_rq)->nr_running, (struct cfs_rq)->h_nr_running, (struct cfs_rq)->exec_clock, (struct cfs_rq)->min_vruntime, (struct cfs_rq)->runnable_load_sum, (struct cfs_rq)->runnable_load_avg, (struct cfs_rq)->tg_load_avg_contrib, (struct cfs_rq)->propagate_avg, (struct cfs_rq)->h_load, (struct cfs_rq)->last_h_load_update, (struct cfs_rq)->on_list, (struct rt_rq)->rt_nr_running, (struct rt_rq)->rr_nr_running, (struct rt_rq)->rt_nr_migratory, (struct rt_rq)->rt_nr_total, (struct rt_rq)->overloaded, (struct rt_rq)->push_flags, (struct rt_rq)->push_cpu, (struct irq_work)->flags, (struct irq_work)->func, (struct rt_rq)->rt_queued, (struct rt_rq)->rt_throttled, (struct rt_rq)->rt_time, (struct rt_rq)->rt_runtime, (struct dl_rq)->dl_nr_running, (struct dl_rq)->dl_nr_migratory, (struct dl_rq)->overloaded, (struct dl_rq)->running_bw, (struct dl_rq)->this_bw, (struct dl_rq)->extra_bw, (struct dl_rq)->bw_ratio, (struct rq)->nr_uninterruptible, (struct rq)->next_balance, (struct rq)->clock_update_flags, (struct rq)->clock, (struct rq)->clock_task, (struct rq)->cpu_capacity, (struct rq)->cpu_capacity_orig, (struct rq)->idle_balance, (struct rq)->active_balance, (struct rq)->push_cpu, (struct cpu_stop_work)->fn, (struct cpu_stop_work)->arg, (struct rq)->cpu, (struct rq)->online, (struct rq)->rt_avg, (struct rq)->age_stamp, (struct rq)->idle_stamp, (struct rq)->avg_idle, (struct rq)->max_idle_balance_cost, (struct rq)->calc_load_update, (struct rq)->calc_load_active, (struct rq)->hrtick_csd_pending, (struct call_single_data)->func, (struct call_single_data)->info, (struct call_single_data)->flags, (struct rq)->rq_cpu_time, (struct rq)->yld_count, (struct rq)->sched_count, (struct rq)->sched_goidle, (struct rq)->ttwu_count, (struct rq)->ttwu_local, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_acct write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct atomic_t)->counter, (struct callback_head)->func, (struct pid_namespace)->last_pid, (struct pid_namespace)->nr_hashed, (struct pid_namespace)->level, (struct atomic64_t)->counter, (struct work_struct)->func, (struct lockdep_map)->name, (struct kgid_t)->val, (struct pid_namespace)->hide_pid, (struct pid_namespace)->reboot, (struct ns_common)->inum, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct fs_pin)->done, (struct hlist_node)->pprev, (struct fs_pin)->kill, (struct mutex)->magic, (struct bsd_acct_struct)->active, (struct bsd_acct_struct)->needcheck, (struct completion)->done, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct vfsmount)->mnt_flags, ]
+SYSC_getresuid16 write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, ]
+SYSC_getresgid16 write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, ]
+SYSC_getgroups16 write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, (struct uid_gid_map)->nr_extents, (struct user_namespace)->level, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, ]
+SYSC_setgroups16 write_list: [(struct atomic_t)->counter, (struct group_info)->ngroups, (struct uid_gid_map)->nr_extents, (struct user_namespace)->level, (struct kuid_t)->val, (struct kgid_t)->val, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct lockdep_map)->name, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, (struct callback_head)->func, ]
+SYSC_mremap write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, ]
+SYSC_memfd_create write_list: [(struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct shmem_inode_info)->seals, (struct shmem_inode_info)->flags, (struct shmem_inode_info)->alloced, (struct shmem_inode_info)->swapped, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+SYSC_brk write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, ]
+SYSC_mmap_pgoff write_list: [(struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct hstate)->next_nid_to_alloc, (struct hstate)->next_nid_to_free, (struct hstate)->order, (struct hstate)->mask, (struct hstate)->max_huge_pages, (struct hstate)->nr_huge_pages, (struct hstate)->free_huge_pages, (struct hstate)->resv_huge_pages, (struct hstate)->surplus_huge_pages, (struct hstate)->nr_overcommit_huge_pages, ]
+SYSC_remap_file_pages write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, (struct callback_head)->func, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_munlock write_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, ]
+SYSC_mlockall write_list: [(struct mm_struct)->def_flags, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, ]
+sys_munlockall write_list: [(struct mm_struct)->def_flags, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, ]
+SYSC_move_pages write_list: [(struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct atomic_t)->counter, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct callback_head)->func, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct mm_struct)->map_count, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct page_to_node)->addr, (struct page_to_node)->node, (struct page_to_node)->status, ]
+SYSC_readahead write_list: [(struct fd)->flags, (struct radix_tree_root)->gfp_mask, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct atomic64_t)->counter, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, ]
+SYSC_swapoff write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct swap_info_struct)->flags, (struct swap_info_struct)->prio, (struct plist_node)->prio, (struct swap_info_struct)->type, (struct swap_info_struct)->max, (struct swap_info_struct)->swap_map, (struct swap_cluster_info)->data, (struct swap_cluster_info)->flags, (struct swap_info_struct)->lowest_bit, (struct swap_info_struct)->highest_bit, (struct swap_info_struct)->pages, (struct swap_info_struct)->inuse_pages, (struct swap_info_struct)->cluster_next, (struct swap_info_struct)->cluster_nr, (struct swap_extent)->start_page, (struct swap_extent)->nr_pages, (struct swap_extent)->start_block, (struct swap_info_struct)->old_block_size, (struct work_struct)->func, (struct signal_struct)->oom_flag_origin, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct mm_struct)->map_count, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct swp_entry_t)->val, (struct page)->flags, (struct page)->s_mem, (struct page)->index, (struct page)->freelist, (struct page)->counters, (struct page)->active, (struct page)->inuse, (struct page)->objects, (struct page)->frozen, (struct page)->units, (struct page)->pages, (struct page)->pobjects, (struct page)->compound_head, (struct page)->compound_dtor, (struct page)->compound_order, (struct page)->private, (struct writeback_control)->sync_mode, (struct writeback_control)->nr_to_write, (struct writeback_control)->pages_skipped, (struct writeback_control)->range_start, (struct writeback_control)->range_end, (struct writeback_control)->for_kupdate, (struct writeback_control)->for_background, (struct writeback_control)->tagged_writepages, (struct writeback_control)->for_reclaim, (struct writeback_control)->range_cyclic, (struct writeback_control)->for_sync, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct inode)->i_version, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct block_device)->bd_dev, (struct block_device)->bd_openers, (struct block_device)->bd_claiming, (struct block_device)->bd_holder, (struct block_device)->bd_holders, (struct block_device)->bd_write_holder, (struct block_device)->bd_block_size, (struct block_device)->bd_part_count, (struct block_device)->bd_invalidated, (struct block_device)->bd_private, (struct block_device)->bd_fsfreeze_count, ]
+SYSC_swapon write_list: [(struct swap_info_struct)->flags, (struct swap_info_struct)->prio, (struct plist_node)->prio, (struct swap_info_struct)->type, (struct swap_info_struct)->max, (struct swap_info_struct)->swap_map, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct swap_cluster_info)->data, (struct swap_cluster_info)->flags, (struct swap_info_struct)->lowest_bit, (struct swap_info_struct)->highest_bit, (struct swap_info_struct)->pages, (struct swap_info_struct)->inuse_pages, (struct swap_info_struct)->cluster_next, (struct swap_info_struct)->cluster_nr, (struct swap_extent)->start_page, (struct swap_extent)->nr_pages, (struct swap_extent)->start_block, (struct swap_info_struct)->old_block_size, (struct atomic64_t)->counter, (struct work_struct)->func, (struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct callback_head)->func, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct inode)->i_version, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct block_device)->bd_dev, (struct block_device)->bd_openers, (struct block_device)->bd_claiming, (struct block_device)->bd_holder, (struct block_device)->bd_holders, (struct block_device)->bd_write_holder, (struct block_device)->bd_block_size, (struct block_device)->bd_part_count, (struct block_device)->bd_invalidated, (struct block_device)->bd_private, (struct block_device)->bd_fsfreeze_count, (struct page)->flags, (struct page)->s_mem, (struct page)->index, (struct page)->freelist, (struct page)->counters, (struct page)->active, (struct page)->inuse, (struct page)->objects, (struct page)->frozen, (struct page)->units, (struct page)->pages, (struct page)->pobjects, (struct page)->compound_head, (struct page)->compound_dtor, (struct page)->compound_order, (struct page)->private, (struct super_block)->s_dev, (struct super_block)->s_blocksize_bits, (struct super_block)->s_blocksize, (struct super_block)->s_maxbytes, (struct super_block)->s_flags, (struct super_block)->s_iflags, (struct super_block)->s_magic, (struct super_block)->s_count, (struct super_block)->s_security, (struct super_block)->s_xattr, (struct super_block)->s_quota_types, (struct quota_info)->flags, (struct sb_writers)->frozen, (struct super_block)->s_fs_info, (struct super_block)->s_max_links, (struct super_block)->s_mode, (struct super_block)->s_time_gran, (struct super_block)->s_subtype, (struct super_block)->cleancache_poolid, (struct shrinker)->count_objects, (struct shrinker)->scan_objects, (struct shrinker)->seeks, (struct shrinker)->batch, (struct shrinker)->flags, (struct super_block)->s_readonly_remount, (struct super_block)->s_stack_depth, (struct percpu_cluster)->next, (struct request_queue)->nr_rqs_elvpriv, (struct request_list)->flags, (struct request_queue)->request_fn, (struct request_queue)->make_request_fn, (struct request_queue)->prep_rq_fn, (struct request_queue)->unprep_rq_fn, (struct request_queue)->softirq_done_fn, (struct request_queue)->rq_timed_out_fn, (struct request_queue)->dma_drain_needed, (struct request_queue)->lld_busy_fn, (struct request_queue)->init_rq_fn, (struct request_queue)->exit_rq_fn, (struct request_queue)->initialize_rq_fn, (struct request_queue)->mq_map, (struct request_queue)->nr_queues, (struct request_queue)->queue_depth, (struct request_queue)->queue_hw_ctx, (struct request_queue)->nr_hw_queues, (struct request_queue)->end_sector, (struct timer_list)->expires, (struct timer_list)->function, (struct timer_list)->data, (struct timer_list)->flags, (struct delayed_work)->cpu, (struct request_queue)->queuedata, (struct request_queue)->queue_flags, (struct request_queue)->id, (struct request_queue)->bounce_gfp, (struct kobject)->name, (struct kobject)->state_initialized, (struct kobject)->state_in_sysfs, (struct kobject)->state_add_uevent_sent, (struct kobject)->state_remove_uevent_sent, (struct kobject)->uevent_suppress, (struct request_queue)->rpm_status, (struct request_queue)->nr_pending, (struct request_queue)->nr_requests, (struct request_queue)->nr_congestion_on, (struct request_queue)->nr_congestion_off, (struct request_queue)->nr_batching, (struct request_queue)->dma_drain_size, (struct request_queue)->dma_drain_buffer, (struct request_queue)->dma_pad_mask, (struct request_queue)->dma_alignment, (struct request_queue)->nr_sorted, (struct request_queue)->request_fn_active, (struct request_queue)->rq_timeout, (struct request_queue)->poll_nsec, (struct queue_limits)->bounce_pfn, (struct queue_limits)->seg_boundary_mask, (struct queue_limits)->virt_boundary_mask, (struct queue_limits)->max_hw_sectors, (struct queue_limits)->max_dev_sectors, (struct queue_limits)->chunk_sectors, (struct queue_limits)->max_sectors, (struct queue_limits)->max_segment_size, (struct queue_limits)->physical_block_size, (struct queue_limits)->alignment_offset, (struct queue_limits)->io_min, (struct queue_limits)->io_opt, (struct queue_limits)->max_discard_sectors, (struct queue_limits)->max_hw_discard_sectors, (struct queue_limits)->max_write_same_sectors, (struct queue_limits)->max_write_zeroes_sectors, (struct queue_limits)->discard_granularity, (struct queue_limits)->discard_alignment, (struct queue_limits)->logical_block_size, (struct queue_limits)->max_segments, (struct queue_limits)->max_integrity_segments, (struct queue_limits)->max_discard_segments, (struct queue_limits)->misaligned, (struct queue_limits)->discard_misaligned, (struct queue_limits)->cluster, (struct queue_limits)->raid_partial_stripes_expensive, (struct queue_limits)->zoned, (struct request_queue)->sg_timeout, (struct request_queue)->sg_reserved_size, (struct request_queue)->node, (struct request_queue)->bypass_depth, (struct request_queue)->bsg_job_fn, (struct bsg_class_device)->minor, (struct bsg_class_device)->release, (struct percpu_ref)->percpu_count_ptr, (struct percpu_ref)->release, (struct percpu_ref)->confirm_switch, (struct percpu_ref)->force_atomic, (struct request_queue)->mq_sysfs_init_done, (struct request_queue)->cmd_size, (struct request_queue)->rq_alloc_data, ]
+SYSC_mprotect write_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, ]
+SYSC_pkey_mprotect write_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, ]
+SYSC_pkey_alloc write_list: [(struct mm_context_t)->pkey_allocation_map, ]
+SYSC_pkey_free write_list: [(struct mm_context_t)->pkey_allocation_map, ]
+SYSC_mincore write_list: [(struct mm_walk)->pmd_entry, (struct mm_walk)->pte_hole, (struct mm_walk)->hugetlb_entry, (struct mm_walk)->private, (struct mm_walk)->pud_entry, (struct mm_walk)->pte_entry, (struct mm_walk)->test_walk, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, ]
+SYSC_mbind write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct mempolicy)->mode, (struct mempolicy)->flags, (union anonymous)->preferred_node, ]
+SYSC_set_mempolicy write_list: [(struct atomic_t)->counter, (struct mempolicy)->mode, (struct mempolicy)->flags, (union anonymous)->preferred_node, (struct task_struct)->il_prev, ]
+SYSC_migrate_pages write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct atomic64_t)->counter, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct mm_struct)->map_count, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, ]
+SYSC_get_mempolicy write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct mempolicy)->mode, (struct mempolicy)->flags, (union anonymous)->preferred_node, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, ]
+SYSC_msync write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, (struct callback_head)->func, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_fadvise64_64 write_list: [(struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct super_block)->s_dev, (struct super_block)->s_blocksize_bits, (struct super_block)->s_blocksize, (struct super_block)->s_maxbytes, (struct super_block)->s_flags, (struct super_block)->s_iflags, (struct super_block)->s_magic, (struct super_block)->s_count, (struct super_block)->s_security, (struct super_block)->s_xattr, (struct super_block)->s_quota_types, (struct quota_info)->flags, (struct mutex)->magic, (struct sb_writers)->frozen, (struct super_block)->s_fs_info, (struct super_block)->s_max_links, (struct super_block)->s_mode, (struct super_block)->s_time_gran, (struct super_block)->s_subtype, (struct super_block)->cleancache_poolid, (struct shrinker)->count_objects, (struct shrinker)->scan_objects, (struct shrinker)->seeks, (struct shrinker)->batch, (struct shrinker)->flags, (struct super_block)->s_readonly_remount, (struct work_struct)->func, (struct super_block)->s_stack_depth, (struct backing_dev_info)->ra_pages, (struct backing_dev_info)->io_pages, (struct backing_dev_info)->congested_fn, (struct backing_dev_info)->congested_data, (struct backing_dev_info)->name, (struct backing_dev_info)->capabilities, (struct backing_dev_info)->min_ratio, (struct backing_dev_info)->max_ratio, (struct backing_dev_info)->max_prop_frac, (struct bdi_writeback)->state, (struct bdi_writeback)->last_old_flush, (struct bdi_writeback)->bw_time_stamp, (struct bdi_writeback)->dirtied_stamp, (struct bdi_writeback)->written_stamp, (struct bdi_writeback)->write_bandwidth, (struct bdi_writeback)->avg_write_bandwidth, (struct bdi_writeback)->dirty_ratelimit, (struct bdi_writeback)->balanced_dirty_ratelimit, (struct percpu_counter)->count, (struct percpu_counter)->counters, (struct fprop_local_percpu)->period, (struct bdi_writeback)->dirty_exceeded, (struct timer_list)->expires, (struct timer_list)->function, (struct timer_list)->data, (struct timer_list)->flags, (struct delayed_work)->cpu, (struct bdi_writeback)->dirty_sleep, (struct file_ra_state)->ra_pages, (struct file)->f_mode, ]
+SYSC_process_vm_readv write_list: [(struct iovec)->iov_base, (struct iovec)->iov_len, ]
+SYSC_process_vm_writev write_list: [(struct iovec)->iov_base, (struct iovec)->iov_len, ]
+C_SYSC_process_vm_readv write_list: [(struct iovec)->iov_base, (struct iovec)->iov_len, ]
+C_SYSC_process_vm_writev write_list: [(struct iovec)->iov_base, (struct iovec)->iov_len, ]
+SYSC_madvise write_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, ]
+sys_rt_sigreturn write_list: [(struct pt_regs)->r15, (struct pt_regs)->r14, (struct pt_regs)->r13, (struct pt_regs)->r12, (struct pt_regs)->bp, (struct pt_regs)->bx, (struct pt_regs)->r11, (struct pt_regs)->r10, (struct pt_regs)->r9, (struct pt_regs)->r8, (struct pt_regs)->ax, (struct pt_regs)->cx, (struct pt_regs)->dx, (struct pt_regs)->si, (struct pt_regs)->di, (struct pt_regs)->orig_ax, (struct pt_regs)->ip, (struct pt_regs)->cs, (struct pt_regs)->flags, (struct pt_regs)->sp, (struct pt_regs)->ss, (struct rt_sigframe)->pretcode, (struct ucontext)->uc_flags, (struct sigaltstack)->ss_sp, (struct sigaltstack)->ss_flags, (struct sigaltstack)->ss_size, (struct sigcontext_64)->r8, (struct sigcontext_64)->r9, (struct sigcontext_64)->r10, (struct sigcontext_64)->r11, (struct sigcontext_64)->r12, (struct sigcontext_64)->r13, (struct sigcontext_64)->r14, (struct sigcontext_64)->r15, (struct sigcontext_64)->di, (struct sigcontext_64)->si, (struct sigcontext_64)->bp, (struct sigcontext_64)->bx, (struct sigcontext_64)->dx, (struct sigcontext_64)->ax, (struct sigcontext_64)->cx, (struct sigcontext_64)->sp, (struct sigcontext_64)->ip, (struct sigcontext_64)->flags, (struct sigcontext_64)->cs, (struct sigcontext_64)->gs, (struct sigcontext_64)->fs, (struct sigcontext_64)->ss, (struct sigcontext_64)->err, (struct sigcontext_64)->trapno, (struct sigcontext_64)->oldmask, (struct sigcontext_64)->cr2, (struct sigcontext_64)->fpstate, (struct siginfo)->si_signo, (struct siginfo)->si_errno, (struct siginfo)->si_code, (union sigval)->sival_int, (union sigval)->sival_ptr, (struct restart_block)->fn, (struct thread_struct)->uaccess_err, (struct pt_regs)->di, (struct pt_regs)->si, (struct pt_regs)->bp, (struct pt_regs)->sp, (struct pt_regs)->bx, (struct pt_regs)->dx, (struct pt_regs)->cx, (struct pt_regs)->ip, (struct pt_regs)->ax, (struct pt_regs)->r8, (struct pt_regs)->r9, (struct pt_regs)->r10, (struct pt_regs)->r11, (struct pt_regs)->r12, (struct pt_regs)->r13, (struct pt_regs)->r14, (struct pt_regs)->r15, ]
+SYSC_set_thread_area write_list: [(struct user_desc)->entry_number, (struct user_desc)->base_addr, (struct user_desc)->limit, (struct user_desc)->seg_32bit, (struct user_desc)->contents, (struct user_desc)->read_exec_only, (struct user_desc)->limit_in_pages, (struct user_desc)->seg_not_present, (struct user_desc)->useable, (struct user_desc)->lm, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, ]
+SYSC_get_thread_area write_list: [(struct user_desc)->entry_number, (struct user_desc)->base_addr, (struct user_desc)->limit, (struct user_desc)->seg_32bit, (struct user_desc)->contents, (struct user_desc)->read_exec_only, (struct user_desc)->limit_in_pages, (struct user_desc)->seg_not_present, (struct user_desc)->useable, (struct user_desc)->lm, ]
+sys_modify_ldt write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct user_desc)->entry_number, (struct user_desc)->base_addr, (struct user_desc)->limit, (struct user_desc)->seg_32bit, (struct user_desc)->contents, (struct user_desc)->read_exec_only, (struct user_desc)->limit_in_pages, (struct user_desc)->seg_not_present, (struct user_desc)->useable, (struct user_desc)->lm, (struct desc_struct)->a, (struct desc_struct)->b, (struct desc_struct)->limit0, (struct desc_struct)->base0, (struct desc_struct)->base1, (struct desc_struct)->type, (struct desc_struct)->s, (struct desc_struct)->dpl, (struct desc_struct)->p, (struct desc_struct)->limit, (struct desc_struct)->avl, (struct desc_struct)->l, (struct desc_struct)->d, (struct desc_struct)->g, (struct desc_struct)->base2, (struct ldt_struct)->nr_entries, ]
+sys_ioperm write_list: [(struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct x86_hw_tss)->reserved1, (struct x86_hw_tss)->sp0, (struct x86_hw_tss)->sp1, (struct x86_hw_tss)->sp2, (struct x86_hw_tss)->reserved2, (struct x86_hw_tss)->reserved3, (struct x86_hw_tss)->reserved4, (struct x86_hw_tss)->reserved5, (struct x86_hw_tss)->io_bitmap_base, ]
+SYSC_iopl write_list: [(struct pt_regs)->r15, (struct pt_regs)->r14, (struct pt_regs)->r13, (struct pt_regs)->r12, (struct pt_regs)->bp, (struct pt_regs)->bx, (struct pt_regs)->r11, (struct pt_regs)->r10, (struct pt_regs)->r9, (struct pt_regs)->r8, (struct pt_regs)->ax, (struct pt_regs)->cx, (struct pt_regs)->dx, (struct pt_regs)->si, (struct pt_regs)->di, (struct pt_regs)->orig_ax, (struct pt_regs)->ip, (struct pt_regs)->cs, (struct pt_regs)->flags, (struct pt_regs)->sp, (struct pt_regs)->ss, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_arch_prctl write_list: [(struct thread_struct)->gsindex, (struct thread_struct)->gsbase, (struct thread_struct)->fsindex, (struct thread_struct)->fsbase, ]
+C_SYSC_keyctl write_list: [(struct iovec)->iov_base, (struct iovec)->iov_len, ]
+SYSC_request_key write_list: [(struct key_type)->name, (struct key_type)->def_datalen, (struct key_type)->vet_description, (struct key_type)->preparse, (struct key_type)->free_preparse, (struct key_type)->instantiate, (struct key_type)->update, (struct key_type)->match_preparse, (struct key_type)->match_free, (struct key_type)->revoke, (struct key_type)->destroy, (struct key_type)->describe, (struct key_type)->read, (struct key_type)->request_key, (struct key_type)->lookup_restriction, (struct atomic_t)->counter, (struct key)->serial, (struct rb_node)->__rb_parent_color, (struct atomic64_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct key)->security, (struct key)->expiry, (struct key)->revoked_at, (struct key)->last_used_at, (struct kuid_t)->val, (struct kgid_t)->val, (struct key)->perm, (struct key)->quotalen, (struct key)->datalen, (struct key)->flags, (struct keyring_index_key)->description, (struct keyring_index_key)->desc_len, (struct key)->description, (union key_payload)->rcu_data0, (struct assoc_array)->nr_leaves_on_tree, (struct key)->reject_error, ]
+SYSC_keyctl write_list: [(struct atomic_t)->counter, (struct key)->serial, (struct rb_node)->__rb_parent_color, (struct atomic64_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct key)->security, (struct key)->expiry, (struct key)->revoked_at, (struct key)->last_used_at, (struct kuid_t)->val, (struct kgid_t)->val, (struct key)->perm, (struct key)->quotalen, (struct key)->datalen, (struct key)->flags, (struct keyring_index_key)->description, (struct keyring_index_key)->desc_len, (struct key)->description, (union key_payload)->rcu_data0, (struct assoc_array)->nr_leaves_on_tree, (struct key)->reject_error, (struct key_type)->name, (struct key_type)->def_datalen, (struct key_type)->vet_description, (struct key_type)->preparse, (struct key_type)->free_preparse, (struct key_type)->instantiate, (struct key_type)->update, (struct key_type)->match_preparse, (struct key_type)->match_free, (struct key_type)->revoke, (struct key_type)->destroy, (struct key_type)->describe, (struct key_type)->read, (struct key_type)->request_key, (struct key_type)->lookup_restriction, (struct mutex)->magic, (struct key_user)->qnkeys, (struct key_user)->qnbytes, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct request_key_auth)->callout_info, (struct request_key_auth)->callout_len, (struct request_key_auth)->pid, (struct iovec)->iov_base, (struct iovec)->iov_len, ]
+SYSC_msgget write_list: [(struct ipc_ops)->getnew, (struct ipc_ops)->associate, (struct ipc_ops)->more_checks, (struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct ipc_params)->key, (struct ipc_params)->flg, ]
+SYSC_msgctl write_list: [(struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct msginfo)->msgpool, (struct msginfo)->msgmap, (struct msginfo)->msgmax, (struct msginfo)->msgmnb, (struct msginfo)->msgmni, (struct msginfo)->msgssz, (struct msginfo)->msgtql, (struct msginfo)->msgseg, (struct ipc64_perm)->key, (struct ipc64_perm)->uid, (struct ipc64_perm)->gid, (struct ipc64_perm)->cuid, (struct ipc64_perm)->cgid, (struct ipc64_perm)->mode, (struct ipc64_perm)->seq, (struct ipc64_perm)->__pad2, (struct ipc64_perm)->__unused1, (struct ipc64_perm)->__unused2, (struct msqid64_ds)->msg_stime, (struct msqid64_ds)->msg_rtime, (struct msqid64_ds)->msg_ctime, (struct msqid64_ds)->msg_cbytes, (struct msqid64_ds)->msg_qnum, (struct msqid64_ds)->msg_qbytes, (struct msqid64_ds)->msg_lspid, (struct msqid64_ds)->msg_lrpid, (struct msqid64_ds)->__unused4, (struct msqid64_ds)->__unused5, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct kern_ipc_perm)->deleted, (struct kern_ipc_perm)->id, (struct kern_ipc_perm)->key, (struct kuid_t)->val, (struct kgid_t)->val, (struct kern_ipc_perm)->mode, (struct kern_ipc_perm)->seq, (struct kern_ipc_perm)->security, (struct callback_head)->func, (struct msg_queue)->q_stime, (struct msg_queue)->q_rtime, (struct msg_queue)->q_ctime, (struct msg_queue)->q_cbytes, (struct msg_queue)->q_qnum, (struct msg_queue)->q_qbytes, (struct msg_queue)->q_lspid, (struct msg_queue)->q_lrpid, (struct wake_q_head)->lastp, ]
+SYSC_msgsnd write_list: [(struct wake_q_head)->lastp, (struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct msg_msg)->m_type, (struct msg_msg)->m_ts, (struct msg_msg)->security, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct kern_ipc_perm)->deleted, (struct kern_ipc_perm)->id, (struct kern_ipc_perm)->key, (struct kuid_t)->val, (struct kgid_t)->val, (struct kern_ipc_perm)->mode, (struct kern_ipc_perm)->seq, (struct kern_ipc_perm)->security, (struct callback_head)->func, (struct msg_queue)->q_stime, (struct msg_queue)->q_rtime, (struct msg_queue)->q_ctime, (struct msg_queue)->q_cbytes, (struct msg_queue)->q_qnum, (struct msg_queue)->q_qbytes, (struct msg_queue)->q_lspid, (struct msg_queue)->q_lrpid, ]
+SYSC_msgrcv write_list: [(struct wake_q_head)->lastp, (struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct msg_msg)->m_type, (struct msg_msg)->m_ts, (struct msg_msg)->security, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct kern_ipc_perm)->deleted, (struct kern_ipc_perm)->id, (struct kern_ipc_perm)->key, (struct kuid_t)->val, (struct kgid_t)->val, (struct kern_ipc_perm)->mode, (struct kern_ipc_perm)->seq, (struct kern_ipc_perm)->security, (struct callback_head)->func, (struct msg_queue)->q_stime, (struct msg_queue)->q_rtime, (struct msg_queue)->q_ctime, (struct msg_queue)->q_cbytes, (struct msg_queue)->q_qnum, (struct msg_queue)->q_qbytes, (struct msg_queue)->q_lspid, (struct msg_queue)->q_lrpid, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct msg_receiver)->r_msgtype, (struct msg_receiver)->r_mode, (struct msg_receiver)->r_maxsize, ]
+SYSC_mq_open write_list: [(struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct vfsmount)->mnt_flags, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_mq_unlink write_list: [(struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct vfsmount)->mnt_flags, (struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+SYSC_mq_timedsend write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct wake_q_head)->lastp, (struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct mqueue_inode_info)->qsize, (struct msg_msg)->m_type, (struct msg_msg)->m_ts, (struct msg_msg)->security, (struct rb_node)->__rb_parent_color, (struct posix_msg_tree_node)->priority, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct ext_wait_queue)->state, ]
+SYSC_mq_timedreceive write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct mqueue_inode_info)->qsize, (struct rb_node)->__rb_parent_color, (struct posix_msg_tree_node)->priority, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct ext_wait_queue)->state, (struct msg_msg)->m_type, (struct msg_msg)->m_ts, (struct msg_msg)->security, (struct wake_q_head)->lastp, ]
+SYSC_mq_notify write_list: [(union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct sk_buff)->tstamp, (struct sk_buff)->skb_mstamp, (struct rb_node)->__rb_parent_color, (struct sk_buff)->dev_scratch, (struct sk_buff)->_skb_refdst, (struct sk_buff)->destructor, (struct sk_buff)->_nfct, (struct sk_buff)->len, (struct sk_buff)->data_len, (struct sk_buff)->mac_len, (struct sk_buff)->hdr_len, (struct sk_buff)->queue_mapping, (struct sk_buff)->cloned, (struct sk_buff)->nohdr, (struct sk_buff)->fclone, (struct sk_buff)->peeked, (struct sk_buff)->head_frag, (struct sk_buff)->xmit_more, (struct sk_buff)->__unused, (struct sk_buff)->pkt_type, (struct sk_buff)->pfmemalloc, (struct sk_buff)->ignore_df, (struct sk_buff)->nf_trace, (struct sk_buff)->ip_summed, (struct sk_buff)->ooo_okay, (struct sk_buff)->l4_hash, (struct sk_buff)->sw_hash, (struct sk_buff)->wifi_acked_valid, (struct sk_buff)->wifi_acked, (struct sk_buff)->no_fcs, (struct sk_buff)->encapsulation, (struct sk_buff)->encap_hdr_csum, (struct sk_buff)->csum_valid, (struct sk_buff)->csum_complete_sw, (struct sk_buff)->csum_level, (struct sk_buff)->csum_not_inet, (struct sk_buff)->dst_pending_confirm, (struct sk_buff)->ndisc_nodetype, (struct sk_buff)->ipvs_property, (struct sk_buff)->inner_protocol_type, (struct sk_buff)->remcsum_offload, (struct sk_buff)->tc_skip_classify, (struct sk_buff)->tc_at_ingress, (struct sk_buff)->tc_redirected, (struct sk_buff)->tc_from_ingress, (struct sk_buff)->tc_index, (struct sk_buff)->csum, (struct sk_buff)->csum_start, (struct sk_buff)->csum_offset, (struct sk_buff)->priority, (struct sk_buff)->skb_iif, (struct sk_buff)->hash, (struct sk_buff)->vlan_proto, (struct sk_buff)->vlan_tci, (struct sk_buff)->napi_id, (struct sk_buff)->sender_cpu, (struct sk_buff)->secmark, (struct sk_buff)->mark, (struct sk_buff)->reserved_tailroom, (struct sk_buff)->inner_protocol, (struct sk_buff)->inner_ipproto, (struct sk_buff)->inner_transport_header, (struct sk_buff)->inner_network_header, (struct sk_buff)->inner_mac_header, (struct sk_buff)->protocol, (struct sk_buff)->transport_header, (struct sk_buff)->network_header, (struct sk_buff)->mac_header, (struct sk_buff)->tail, (struct sk_buff)->end, (struct sk_buff)->head, (struct sk_buff)->data, (struct sk_buff)->truesize, (struct atomic_t)->counter, (struct fd)->flags, (struct sock_common)->skc_addrpair, (struct sock_common)->skc_daddr, (struct sock_common)->skc_rcv_saddr, (struct sock_common)->skc_hash, (struct sock_common)->skc_portpair, (struct sock_common)->skc_dport, (struct sock_common)->skc_num, (struct sock_common)->skc_family, (struct sock_common)->skc_state, (struct sock_common)->skc_reuse, (struct sock_common)->skc_reuseport, (struct sock_common)->skc_ipv6only, (struct sock_common)->skc_net_refcnt, (struct sock_common)->skc_bound_dev_if, (struct hlist_node)->pprev, (struct atomic64_t)->counter, (struct sock_common)->skc_flags, (struct hlist_nulls_node)->pprev, (struct sock_common)->skc_tx_queue_mapping, (struct sock_common)->skc_incoming_cpu, (struct sock_common)->skc_rcv_wnd, (struct sock_common)->skc_tw_rcv_nxt, (struct sock_common)->skc_rxhash, (struct sock_common)->skc_window_clamp, (struct sock_common)->skc_tw_snd_nxt, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct socket_lock_t)->owned, (struct sock)->sk_rcvlowat, (struct sk_buff_head)->qlen, (struct sock)->sk_forward_alloc, (struct sock)->sk_ll_usec, (struct sock)->sk_napi_id, (struct sock)->sk_rcvbuf, (struct sock)->sk_sndbuf, (struct sock)->sk_wmem_queued, (struct sock)->sk_tsq_flags, (struct sock)->sk_peek_off, (struct sock)->sk_write_pending, (struct sock)->sk_dst_pending_confirm, (struct sock)->sk_pacing_status, (struct sock)->sk_sndtimeo, (struct timer_list)->expires, (struct timer_list)->function, (struct timer_list)->data, (struct timer_list)->flags, (struct sock)->sk_priority, (struct sock)->sk_mark, (struct sock)->sk_pacing_rate, (struct sock)->sk_max_pacing_rate, (struct page_frag)->offset, (struct page_frag)->size, (struct sock)->sk_route_caps, (struct sock)->sk_route_nocaps, (struct sock)->sk_gso_type, (struct sock)->sk_gso_max_size, (struct sock)->sk_allocation, (struct sock)->sk_txhash, (struct sock)->sk_padding, (struct sock)->sk_kern_sock, (struct sock)->sk_no_check_tx, (struct sock)->sk_no_check_rx, (struct sock)->sk_userlocks, (struct sock)->sk_protocol, (struct sock)->sk_type, (struct sock)->sk_gso_max_segs, (struct sock)->sk_lingertime, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct sock)->sk_err, (struct sock)->sk_err_soft, (struct sock)->sk_ack_backlog, (struct sock)->sk_max_ack_backlog, (struct kuid_t)->val, (struct sock)->sk_rcvtimeo, (struct sock)->sk_stamp, (struct sock)->sk_tsflags, (struct sock)->sk_shutdown, (struct sock)->sk_tskey, (struct sock)->sk_user_data, (struct sock)->sk_security, (struct sock)->sk_state_change, (struct sock)->sk_data_ready, (struct sock)->sk_write_space, (struct sock)->sk_error_report, (struct sock)->sk_backlog_rcv, (struct sock)->sk_destruct, (struct callback_head)->func, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct mqueue_inode_info)->qsize, (struct sigevent)->sigev_value, (struct pid)->level, (struct uid_gid_map)->nr_extents, (struct user_namespace)->level, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, ]
+SYSC_mq_getsetattr write_list: [(struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct mqueue_inode_info)->qsize, (struct file)->f_flags, ]
+C_SYSC_mq_open write_list: [(struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct compat_mq_attr)->mq_flags, (struct compat_mq_attr)->mq_maxmsg, (struct compat_mq_attr)->mq_msgsize, (struct compat_mq_attr)->mq_curmsgs, (struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct vfsmount)->mnt_flags, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+C_SYSC_mq_timedsend write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct wake_q_head)->lastp, (struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct mqueue_inode_info)->qsize, (struct msg_msg)->m_type, (struct msg_msg)->m_ts, (struct msg_msg)->security, (struct rb_node)->__rb_parent_color, (struct posix_msg_tree_node)->priority, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct ext_wait_queue)->state, ]
+C_SYSC_mq_timedreceive write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct mqueue_inode_info)->qsize, (struct rb_node)->__rb_parent_color, (struct posix_msg_tree_node)->priority, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, (struct ext_wait_queue)->state, (struct msg_msg)->m_type, (struct msg_msg)->m_ts, (struct msg_msg)->security, (struct wake_q_head)->lastp, ]
+C_SYSC_mq_notify write_list: [(union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct sk_buff)->tstamp, (struct sk_buff)->skb_mstamp, (struct rb_node)->__rb_parent_color, (struct sk_buff)->dev_scratch, (struct sk_buff)->_skb_refdst, (struct sk_buff)->destructor, (struct sk_buff)->_nfct, (struct sk_buff)->len, (struct sk_buff)->data_len, (struct sk_buff)->mac_len, (struct sk_buff)->hdr_len, (struct sk_buff)->queue_mapping, (struct sk_buff)->cloned, (struct sk_buff)->nohdr, (struct sk_buff)->fclone, (struct sk_buff)->peeked, (struct sk_buff)->head_frag, (struct sk_buff)->xmit_more, (struct sk_buff)->__unused, (struct sk_buff)->pkt_type, (struct sk_buff)->pfmemalloc, (struct sk_buff)->ignore_df, (struct sk_buff)->nf_trace, (struct sk_buff)->ip_summed, (struct sk_buff)->ooo_okay, (struct sk_buff)->l4_hash, (struct sk_buff)->sw_hash, (struct sk_buff)->wifi_acked_valid, (struct sk_buff)->wifi_acked, (struct sk_buff)->no_fcs, (struct sk_buff)->encapsulation, (struct sk_buff)->encap_hdr_csum, (struct sk_buff)->csum_valid, (struct sk_buff)->csum_complete_sw, (struct sk_buff)->csum_level, (struct sk_buff)->csum_not_inet, (struct sk_buff)->dst_pending_confirm, (struct sk_buff)->ndisc_nodetype, (struct sk_buff)->ipvs_property, (struct sk_buff)->inner_protocol_type, (struct sk_buff)->remcsum_offload, (struct sk_buff)->tc_skip_classify, (struct sk_buff)->tc_at_ingress, (struct sk_buff)->tc_redirected, (struct sk_buff)->tc_from_ingress, (struct sk_buff)->tc_index, (struct sk_buff)->csum, (struct sk_buff)->csum_start, (struct sk_buff)->csum_offset, (struct sk_buff)->priority, (struct sk_buff)->skb_iif, (struct sk_buff)->hash, (struct sk_buff)->vlan_proto, (struct sk_buff)->vlan_tci, (struct sk_buff)->napi_id, (struct sk_buff)->sender_cpu, (struct sk_buff)->secmark, (struct sk_buff)->mark, (struct sk_buff)->reserved_tailroom, (struct sk_buff)->inner_protocol, (struct sk_buff)->inner_ipproto, (struct sk_buff)->inner_transport_header, (struct sk_buff)->inner_network_header, (struct sk_buff)->inner_mac_header, (struct sk_buff)->protocol, (struct sk_buff)->transport_header, (struct sk_buff)->network_header, (struct sk_buff)->mac_header, (struct sk_buff)->tail, (struct sk_buff)->end, (struct sk_buff)->head, (struct sk_buff)->data, (struct sk_buff)->truesize, (struct atomic_t)->counter, (struct fd)->flags, (struct sock_common)->skc_addrpair, (struct sock_common)->skc_daddr, (struct sock_common)->skc_rcv_saddr, (struct sock_common)->skc_hash, (struct sock_common)->skc_portpair, (struct sock_common)->skc_dport, (struct sock_common)->skc_num, (struct sock_common)->skc_family, (struct sock_common)->skc_state, (struct sock_common)->skc_reuse, (struct sock_common)->skc_reuseport, (struct sock_common)->skc_ipv6only, (struct sock_common)->skc_net_refcnt, (struct sock_common)->skc_bound_dev_if, (struct hlist_node)->pprev, (struct atomic64_t)->counter, (struct sock_common)->skc_flags, (struct hlist_nulls_node)->pprev, (struct sock_common)->skc_tx_queue_mapping, (struct sock_common)->skc_incoming_cpu, (struct sock_common)->skc_rcv_wnd, (struct sock_common)->skc_tw_rcv_nxt, (struct sock_common)->skc_rxhash, (struct sock_common)->skc_window_clamp, (struct sock_common)->skc_tw_snd_nxt, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct socket_lock_t)->owned, (struct sock)->sk_rcvlowat, (struct sk_buff_head)->qlen, (struct sock)->sk_forward_alloc, (struct sock)->sk_ll_usec, (struct sock)->sk_napi_id, (struct sock)->sk_rcvbuf, (struct sock)->sk_sndbuf, (struct sock)->sk_wmem_queued, (struct sock)->sk_tsq_flags, (struct sock)->sk_peek_off, (struct sock)->sk_write_pending, (struct sock)->sk_dst_pending_confirm, (struct sock)->sk_pacing_status, (struct sock)->sk_sndtimeo, (struct timer_list)->expires, (struct timer_list)->function, (struct timer_list)->data, (struct timer_list)->flags, (struct sock)->sk_priority, (struct sock)->sk_mark, (struct sock)->sk_pacing_rate, (struct sock)->sk_max_pacing_rate, (struct page_frag)->offset, (struct page_frag)->size, (struct sock)->sk_route_caps, (struct sock)->sk_route_nocaps, (struct sock)->sk_gso_type, (struct sock)->sk_gso_max_size, (struct sock)->sk_allocation, (struct sock)->sk_txhash, (struct sock)->sk_padding, (struct sock)->sk_kern_sock, (struct sock)->sk_no_check_tx, (struct sock)->sk_no_check_rx, (struct sock)->sk_userlocks, (struct sock)->sk_protocol, (struct sock)->sk_type, (struct sock)->sk_gso_max_segs, (struct sock)->sk_lingertime, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct sock)->sk_err, (struct sock)->sk_err_soft, (struct sock)->sk_ack_backlog, (struct sock)->sk_max_ack_backlog, (struct kuid_t)->val, (struct sock)->sk_rcvtimeo, (struct sock)->sk_stamp, (struct sock)->sk_tsflags, (struct sock)->sk_shutdown, (struct sock)->sk_tskey, (struct sock)->sk_user_data, (struct sock)->sk_security, (struct sock)->sk_state_change, (struct sock)->sk_data_ready, (struct sock)->sk_write_space, (struct sock)->sk_error_report, (struct sock)->sk_backlog_rcv, (struct sock)->sk_destruct, (struct callback_head)->func, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct mqueue_inode_info)->qsize, (struct sigevent)->sigev_value, (struct pid)->level, (struct uid_gid_map)->nr_extents, (struct user_namespace)->level, (struct ns_common)->inum, (struct user_namespace)->flags, (struct work_struct)->func, (struct ctl_table_set)->is_seen, (struct ctl_table_header)->used, (struct ctl_table_header)->count, (struct ctl_table_header)->nreg, ]
+C_SYSC_mq_getsetattr write_list: [(struct mq_attr)->mq_flags, (struct mq_attr)->mq_maxmsg, (struct mq_attr)->mq_msgsize, (struct mq_attr)->mq_curmsgs, (struct compat_mq_attr)->mq_flags, (struct compat_mq_attr)->mq_maxmsg, (struct compat_mq_attr)->mq_msgsize, (struct compat_mq_attr)->mq_curmsgs, (struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (union sigval)->sival_int, (union sigval)->sival_ptr, (struct sigevent)->sigev_signo, (struct sigevent)->sigev_notify, (union anonymous)->_tid, (struct mqueue_inode_info)->qsize, (struct file)->f_flags, ]
+C_SYSC_ipc write_list: [(struct ipc64_perm)->key, (struct ipc64_perm)->uid, (struct ipc64_perm)->gid, (struct ipc64_perm)->cuid, (struct ipc64_perm)->cgid, (struct ipc64_perm)->mode, (struct ipc64_perm)->seq, (struct ipc64_perm)->__pad2, (struct ipc64_perm)->__unused1, (struct ipc64_perm)->__unused2, (struct semid64_ds)->sem_otime, (struct semid64_ds)->__unused1, (struct semid64_ds)->sem_ctime, (struct semid64_ds)->__unused2, (struct semid64_ds)->sem_nsems, (struct semid64_ds)->__unused3, (struct semid64_ds)->__unused4, (struct compat_msgbuf)->mtype, (struct compat_ipc_kludge)->msgp, (struct compat_ipc_kludge)->msgtyp, ]
+C_SYSC_semctl write_list: [(struct ipc64_perm)->key, (struct ipc64_perm)->uid, (struct ipc64_perm)->gid, (struct ipc64_perm)->cuid, (struct ipc64_perm)->cgid, (struct ipc64_perm)->mode, (struct ipc64_perm)->seq, (struct ipc64_perm)->__pad2, (struct ipc64_perm)->__unused1, (struct ipc64_perm)->__unused2, (struct semid64_ds)->sem_otime, (struct semid64_ds)->__unused1, (struct semid64_ds)->sem_ctime, (struct semid64_ds)->__unused2, (struct semid64_ds)->sem_nsems, (struct semid64_ds)->__unused3, (struct semid64_ds)->__unused4, ]
+C_SYSC_msgsnd write_list: [(struct compat_msgbuf)->mtype, ]
+C_SYSC_msgctl write_list: [(struct ipc64_perm)->key, (struct ipc64_perm)->uid, (struct ipc64_perm)->gid, (struct ipc64_perm)->cuid, (struct ipc64_perm)->cgid, (struct ipc64_perm)->mode, (struct ipc64_perm)->seq, (struct ipc64_perm)->__pad2, (struct ipc64_perm)->__unused1, (struct ipc64_perm)->__unused2, (struct msqid64_ds)->msg_stime, (struct msqid64_ds)->msg_rtime, (struct msqid64_ds)->msg_ctime, (struct msqid64_ds)->msg_cbytes, (struct msqid64_ds)->msg_qnum, (struct msqid64_ds)->msg_qbytes, (struct msqid64_ds)->msg_lspid, (struct msqid64_ds)->msg_lrpid, (struct msqid64_ds)->__unused4, (struct msqid64_ds)->__unused5, (struct msqid64_ds)->msg_qbytes, ]
+C_SYSC_shmctl write_list: [(struct ipc64_perm)->key, (struct ipc64_perm)->uid, (struct ipc64_perm)->gid, (struct ipc64_perm)->cuid, (struct ipc64_perm)->cgid, (struct ipc64_perm)->mode, (struct ipc64_perm)->seq, (struct ipc64_perm)->__pad2, (struct ipc64_perm)->__unused1, (struct ipc64_perm)->__unused2, (struct shmid64_ds)->shm_segsz, (struct shmid64_ds)->shm_atime, (struct shmid64_ds)->shm_dtime, (struct shmid64_ds)->shm_ctime, (struct shmid64_ds)->shm_cpid, (struct shmid64_ds)->shm_lpid, (struct shmid64_ds)->shm_nattch, (struct shmid64_ds)->__unused4, (struct shmid64_ds)->__unused5, (struct shminfo64)->shmmax, (struct shminfo64)->shmmin, (struct shminfo64)->shmmni, (struct shminfo64)->shmseg, (struct shminfo64)->shmall, (struct shminfo64)->__unused1, (struct shminfo64)->__unused2, (struct shminfo64)->__unused3, (struct shminfo64)->__unused4, (struct shm_info)->used_ids, (struct shm_info)->shm_tot, (struct shm_info)->shm_rss, (struct shm_info)->shm_swp, (struct shm_info)->swap_attempts, (struct shm_info)->swap_successes, ]
+SYSC_semget write_list: [(struct ipc_ops)->getnew, (struct ipc_ops)->associate, (struct ipc_ops)->more_checks, (struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct ipc_params)->key, (struct ipc_params)->flg, (union anonymous)->nsems, ]
+SYSC_semctl write_list: [(struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct seminfo)->semmap, (struct seminfo)->semmni, (struct seminfo)->semmns, (struct seminfo)->semmnu, (struct seminfo)->semmsl, (struct seminfo)->semopm, (struct seminfo)->semume, (struct seminfo)->semusz, (struct seminfo)->semvmx, (struct seminfo)->semaem, (struct ipc64_perm)->key, (struct ipc64_perm)->uid, (struct ipc64_perm)->gid, (struct ipc64_perm)->cuid, (struct ipc64_perm)->cgid, (struct ipc64_perm)->mode, (struct ipc64_perm)->seq, (struct ipc64_perm)->__pad2, (struct ipc64_perm)->__unused1, (struct ipc64_perm)->__unused2, (struct semid64_ds)->sem_otime, (struct semid64_ds)->__unused1, (struct semid64_ds)->sem_ctime, (struct semid64_ds)->__unused2, (struct semid64_ds)->sem_nsems, (struct semid64_ds)->__unused3, (struct semid64_ds)->__unused4, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct kern_ipc_perm)->deleted, (struct kern_ipc_perm)->id, (struct kern_ipc_perm)->key, (struct kuid_t)->val, (struct kgid_t)->val, (struct kern_ipc_perm)->mode, (struct kern_ipc_perm)->seq, (struct kern_ipc_perm)->security, (struct callback_head)->func, (struct sem_array)->sem_ctime, (struct sem_array)->sem_nsems, (struct sem_array)->complex_count, (struct sem_array)->use_global_lock, (struct wake_q_head)->lastp, (struct sem)->semval, (struct sem)->sempid, (struct sem_undo)->semid, (struct sem_undo)->semadj, (struct sem)->sem_otime, ]
+SYSC_semtimedop write_list: [(struct sembuf)->sem_num, (struct sembuf)->sem_op, (struct sembuf)->sem_flg, (struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct callback_head)->func, (struct sem_undo)->semid, (struct sem_undo)->semadj, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct kern_ipc_perm)->deleted, (struct kern_ipc_perm)->id, (struct kern_ipc_perm)->key, (struct kuid_t)->val, (struct kgid_t)->val, (struct kern_ipc_perm)->mode, (struct kern_ipc_perm)->seq, (struct kern_ipc_perm)->security, (struct sem_array)->sem_ctime, (struct sem_array)->sem_nsems, (struct sem_array)->complex_count, (struct sem_array)->use_global_lock, (struct sem)->semval, (struct sem)->sempid, (struct sem)->sem_otime, (struct sem_queue)->nsops, (struct sem_queue)->pid, (struct sem_queue)->alter, (struct sem_queue)->dupsop, (struct wake_q_head)->lastp, (struct sem_queue)->status, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct mutex)->magic, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_shmget write_list: [(struct ipc_ops)->getnew, (struct ipc_ops)->associate, (struct ipc_ops)->more_checks, (struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct ipc_params)->key, (struct ipc_params)->flg, (union anonymous)->size, ]
+SYSC_shmctl write_list: [(struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct shminfo64)->shmmax, (struct shminfo64)->shmmin, (struct shminfo64)->shmmni, (struct shminfo64)->shmseg, (struct shminfo64)->shmall, (struct shminfo64)->__unused1, (struct shminfo64)->__unused2, (struct shminfo64)->__unused3, (struct shminfo64)->__unused4, (struct shm_info)->used_ids, (struct shm_info)->shm_tot, (struct shm_info)->shm_rss, (struct shm_info)->shm_swp, (struct shm_info)->swap_attempts, (struct shm_info)->swap_successes, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct kern_ipc_perm)->deleted, (struct kern_ipc_perm)->id, (struct kern_ipc_perm)->key, (struct kuid_t)->val, (struct kgid_t)->val, (struct kern_ipc_perm)->mode, (struct kern_ipc_perm)->seq, (struct kern_ipc_perm)->security, (struct callback_head)->func, (struct shmid_kernel)->shm_nattch, (struct shmid_kernel)->shm_segsz, (struct shmid_kernel)->shm_atim, (struct shmid_kernel)->shm_dtim, (struct shmid_kernel)->shm_ctim, (struct shmid_kernel)->shm_cprid, (struct shmid_kernel)->shm_lprid, (struct ipc64_perm)->key, (struct ipc64_perm)->uid, (struct ipc64_perm)->gid, (struct ipc64_perm)->cuid, (struct ipc64_perm)->cgid, (struct ipc64_perm)->mode, (struct ipc64_perm)->seq, (struct ipc64_perm)->__pad2, (struct ipc64_perm)->__unused1, (struct ipc64_perm)->__unused2, (struct shmid64_ds)->shm_segsz, (struct shmid64_ds)->shm_atime, (struct shmid64_ds)->shm_dtime, (struct shmid64_ds)->shm_ctime, (struct shmid64_ds)->shm_cpid, (struct shmid64_ds)->shm_lpid, (struct shmid64_ds)->shm_nattch, (struct shmid64_ds)->__unused4, (struct shmid64_ds)->__unused5, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct user_struct)->mq_bytes, (struct user_struct)->locked_shm, (struct user_struct)->unix_inflight, (struct hlist_node)->pprev, ]
+SYSC_shmat write_list: [(struct atomic_t)->counter, (struct ipc_namespace)->used_sems, (struct ipc_namespace)->msg_ctlmax, (struct ipc_namespace)->msg_ctlmnb, (struct ipc_namespace)->msg_ctlmni, (struct ipc_namespace)->shm_ctlmax, (struct ipc_namespace)->shm_ctlall, (struct ipc_namespace)->shm_tot, (struct ipc_namespace)->shm_ctlmni, (struct ipc_namespace)->shm_rmid_forced, (struct notifier_block)->notifier_call, (struct notifier_block)->priority, (struct ipc_namespace)->mq_queues_count, (struct ipc_namespace)->mq_queues_max, (struct ipc_namespace)->mq_msg_max, (struct ipc_namespace)->mq_msgsize_max, (struct ipc_namespace)->mq_msg_default, (struct ipc_namespace)->mq_msgsize_default, (struct atomic64_t)->counter, (struct ns_common)->inum, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct kern_ipc_perm)->deleted, (struct kern_ipc_perm)->id, (struct kern_ipc_perm)->key, (struct kuid_t)->val, (struct kgid_t)->val, (struct kern_ipc_perm)->mode, (struct kern_ipc_perm)->seq, (struct kern_ipc_perm)->security, (struct callback_head)->func, (struct shmid_kernel)->shm_nattch, (struct shmid_kernel)->shm_segsz, (struct shmid_kernel)->shm_atim, (struct shmid_kernel)->shm_dtim, (struct shmid_kernel)->shm_ctim, (struct shmid_kernel)->shm_cprid, (struct shmid_kernel)->shm_lprid, (struct shm_file_data)->id, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, ]
+SYSC_shmdt write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct rb_node)->__rb_parent_color, (struct vm_area_struct)->rb_subtree_gap, (struct pgprot)->pgprot, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_private_data, (struct callback_head)->func, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_quotactl write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct block_device)->bd_dev, (struct block_device)->bd_openers, (struct atomic64_t)->counter, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mutex)->magic, (struct block_device)->bd_claiming, (struct block_device)->bd_holder, (struct block_device)->bd_holders, (struct block_device)->bd_write_holder, (struct block_device)->bd_block_size, (struct block_device)->bd_part_count, (struct block_device)->bd_invalidated, (struct block_device)->bd_private, (struct block_device)->bd_fsfreeze_count, (struct super_block)->s_dev, (struct super_block)->s_blocksize_bits, (struct super_block)->s_blocksize, (struct super_block)->s_maxbytes, (struct super_block)->s_flags, (struct super_block)->s_iflags, (struct super_block)->s_magic, (struct super_block)->s_count, (struct super_block)->s_security, (struct super_block)->s_xattr, (struct hlist_node)->pprev, (struct super_block)->s_quota_types, (struct quota_info)->flags, (struct sb_writers)->frozen, (struct super_block)->s_fs_info, (struct super_block)->s_max_links, (struct super_block)->s_mode, (struct super_block)->s_time_gran, (struct super_block)->s_subtype, (struct super_block)->cleancache_poolid, (struct shrinker)->count_objects, (struct shrinker)->scan_objects, (struct shrinker)->seeks, (struct shrinker)->batch, (struct shrinker)->flags, (struct super_block)->s_readonly_remount, (struct callback_head)->func, (struct work_struct)->func, (struct super_block)->s_stack_depth, ]
+SYSC_vmsplice write_list: [(struct fd)->flags, (struct iovec)->iov_base, (struct iovec)->iov_len, (struct atomic64_t)->counter, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mutex)->magic, (struct pipe_inode_info)->nrbufs, (struct pipe_inode_info)->curbuf, (struct pipe_inode_info)->buffers, (struct pipe_inode_info)->readers, (struct pipe_inode_info)->writers, (struct pipe_inode_info)->files, (struct pipe_inode_info)->waiting_writers, (struct pipe_inode_info)->r_counter, (struct pipe_inode_info)->w_counter, (struct splice_desc)->total_len, (struct splice_desc)->len, (struct splice_desc)->flags, (union anonymous)->data, (struct splice_desc)->pos, ]
+C_SYSC_vmsplice write_list: [(struct iovec)->iov_base, (struct iovec)->iov_len, (struct compat_iovec)->iov_base, (struct compat_iovec)->iov_len, ]
+SYSC_splice write_list: [(struct fd)->flags, (struct atomic64_t)->counter, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mutex)->magic, (struct pipe_inode_info)->nrbufs, (struct pipe_inode_info)->curbuf, (struct pipe_inode_info)->buffers, (struct pipe_inode_info)->readers, (struct pipe_inode_info)->writers, (struct pipe_inode_info)->files, (struct pipe_inode_info)->waiting_writers, (struct pipe_inode_info)->r_counter, (struct pipe_inode_info)->w_counter, (struct file)->f_pos, ]
+SYSC_tee write_list: [(struct fd)->flags, (struct atomic64_t)->counter, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mutex)->magic, (struct pipe_inode_info)->nrbufs, (struct pipe_inode_info)->curbuf, (struct pipe_inode_info)->buffers, (struct pipe_inode_info)->readers, (struct pipe_inode_info)->writers, (struct pipe_inode_info)->files, (struct pipe_inode_info)->waiting_writers, (struct pipe_inode_info)->r_counter, (struct pipe_inode_info)->w_counter, ]
+SYSC_io_setup write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct percpu_ref)->percpu_count_ptr, (struct percpu_ref)->release, (struct percpu_ref)->confirm_switch, (struct percpu_ref)->force_atomic, (struct callback_head)->func, (struct kioctx)->user_id, (struct kioctx)->req_batch, (struct kioctx)->max_reqs, (struct kioctx)->nr_events, (struct kioctx)->mmap_base, (struct kioctx)->mmap_size, (struct kioctx)->ring_pages, (struct kioctx)->nr_pages, (struct kioctx)->tail, (struct kioctx)->completed_events, (struct kioctx)->id, (struct kioctx_cpu)->reqs_available, (struct kioctx_table)->nr, (struct completion)->done, ]
+C_SYSC_io_setup write_list: [(struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct percpu_ref)->percpu_count_ptr, (struct percpu_ref)->release, (struct percpu_ref)->confirm_switch, (struct percpu_ref)->force_atomic, (struct callback_head)->func, (struct kioctx)->user_id, (struct kioctx)->req_batch, (struct kioctx)->max_reqs, (struct kioctx)->nr_events, (struct kioctx)->mmap_base, (struct kioctx)->mmap_size, (struct kioctx)->ring_pages, (struct kioctx)->nr_pages, (struct kioctx)->tail, (struct kioctx)->completed_events, (struct kioctx)->id, (struct kioctx_cpu)->reqs_available, (struct kioctx_table)->nr, (struct completion)->done, ]
+SYSC_io_destroy write_list: [(struct aio_ring)->id, (struct aio_ring)->nr, (struct aio_ring)->head, (struct aio_ring)->tail, (struct aio_ring)->magic, (struct aio_ring)->compat_features, (struct aio_ring)->incompat_features, (struct aio_ring)->header_length, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct callback_head)->func, (struct kioctx_table)->nr, (struct percpu_ref)->percpu_count_ptr, (struct percpu_ref)->release, (struct percpu_ref)->confirm_switch, (struct percpu_ref)->force_atomic, (struct kioctx)->user_id, (struct kioctx)->req_batch, (struct kioctx)->max_reqs, (struct kioctx)->nr_events, (struct kioctx)->mmap_base, (struct kioctx)->mmap_size, (struct kioctx)->ring_pages, (struct kioctx)->nr_pages, (struct kioctx)->tail, (struct kioctx)->completed_events, (struct kioctx)->id, (struct completion)->done, ]
+SYSC_io_submit write_list: [(struct atomic64_t)->counter, (struct percpu_ref)->percpu_count_ptr, (struct percpu_ref)->release, (struct percpu_ref)->confirm_switch, (struct percpu_ref)->force_atomic, (struct callback_head)->func, (struct atomic_t)->counter, (struct kioctx)->user_id, (struct kioctx)->req_batch, (struct kioctx)->max_reqs, (struct kioctx)->nr_events, (struct kioctx)->mmap_base, (struct kioctx)->mmap_size, (struct kioctx)->ring_pages, (struct kioctx)->nr_pages, (struct work_struct)->func, (struct lockdep_map)->name, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct mutex)->magic, (struct kioctx)->tail, (struct kioctx)->completed_events, (struct kioctx)->id, (struct iocb)->aio_data, (struct iocb)->aio_key, (struct iocb)->aio_rw_flags, (struct iocb)->aio_lio_opcode, (struct iocb)->aio_reqprio, (struct iocb)->aio_fildes, (struct iocb)->aio_buf, (struct iocb)->aio_nbytes, (struct iocb)->aio_offset, (struct iocb)->aio_reserved2, (struct iocb)->aio_flags, (struct iocb)->aio_resfd, ]
+C_SYSC_io_submit write_list: [(struct iocb)->aio_data, (struct iocb)->aio_key, (struct iocb)->aio_rw_flags, (struct iocb)->aio_lio_opcode, (struct iocb)->aio_reqprio, (struct iocb)->aio_fildes, (struct iocb)->aio_buf, (struct iocb)->aio_nbytes, (struct iocb)->aio_offset, (struct iocb)->aio_reserved2, (struct iocb)->aio_flags, (struct iocb)->aio_resfd, (struct atomic64_t)->counter, (struct percpu_ref)->percpu_count_ptr, (struct percpu_ref)->release, (struct percpu_ref)->confirm_switch, (struct percpu_ref)->force_atomic, (struct callback_head)->func, (struct atomic_t)->counter, (struct kioctx)->user_id, (struct kioctx)->req_batch, (struct kioctx)->max_reqs, (struct kioctx)->nr_events, (struct kioctx)->mmap_base, (struct kioctx)->mmap_size, (struct kioctx)->ring_pages, (struct kioctx)->nr_pages, (struct work_struct)->func, (struct lockdep_map)->name, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct mutex)->magic, (struct kioctx)->tail, (struct kioctx)->completed_events, (struct kioctx)->id, ]
+SYSC_io_cancel write_list: [(struct aio_ring)->id, (struct aio_ring)->nr, (struct aio_ring)->head, (struct aio_ring)->tail, (struct aio_ring)->magic, (struct aio_ring)->compat_features, (struct aio_ring)->incompat_features, (struct aio_ring)->header_length, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct callback_head)->func, (struct kioctx_table)->nr, (struct percpu_ref)->percpu_count_ptr, (struct percpu_ref)->release, (struct percpu_ref)->confirm_switch, (struct percpu_ref)->force_atomic, (struct kioctx)->user_id, (struct kioctx)->req_batch, (struct kioctx)->max_reqs, (struct kioctx)->nr_events, (struct kioctx)->mmap_base, (struct kioctx)->mmap_size, (struct kioctx)->ring_pages, (struct kioctx)->nr_pages, (struct kioctx)->tail, (struct kioctx)->completed_events, (struct kioctx)->id, (struct kiocb)->ki_pos, (struct kiocb)->ki_complete, (struct kiocb)->private, (struct kiocb)->ki_flags, (struct kiocb)->ki_hint, (struct aio_kiocb)->ki_cancel, (struct aio_kiocb)->ki_user_data, ]
+SYSC_io_getevents write_list: [(struct aio_ring)->id, (struct aio_ring)->nr, (struct aio_ring)->head, (struct aio_ring)->tail, (struct aio_ring)->magic, (struct aio_ring)->compat_features, (struct aio_ring)->incompat_features, (struct aio_ring)->header_length, (struct mm_struct)->vmacache_seqnum, (struct mm_struct)->get_unmapped_area, (struct mm_struct)->mmap_base, (struct mm_struct)->mmap_legacy_base, (struct mm_struct)->mmap_compat_base, (struct mm_struct)->mmap_compat_legacy_base, (struct mm_struct)->task_size, (struct mm_struct)->highest_vm_end, (struct atomic_t)->counter, (struct atomic64_t)->counter, (struct mm_struct)->map_count, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mm_struct)->hiwater_rss, (struct mm_struct)->hiwater_vm, (struct mm_struct)->total_vm, (struct mm_struct)->locked_vm, (struct mm_struct)->pinned_vm, (struct mm_struct)->data_vm, (struct mm_struct)->exec_vm, (struct mm_struct)->stack_vm, (struct mm_struct)->def_flags, (struct mm_struct)->start_code, (struct mm_struct)->end_code, (struct mm_struct)->start_data, (struct mm_struct)->end_data, (struct mm_struct)->start_brk, (struct mm_struct)->brk, (struct mm_struct)->start_stack, (struct mm_struct)->arg_start, (struct mm_struct)->arg_end, (struct mm_struct)->env_start, (struct mm_struct)->env_end, (struct mm_context_t)->ia32_compat, (struct mutex)->magic, (struct mm_context_t)->vdso, (struct mm_context_t)->pkey_allocation_map, (struct mm_context_t)->execute_only_pkey, (struct mm_struct)->flags, (struct mm_struct)->tlb_flush_batched, (struct work_struct)->func, (struct callback_head)->func, (struct kioctx_table)->nr, (struct percpu_ref)->percpu_count_ptr, (struct percpu_ref)->release, (struct percpu_ref)->confirm_switch, (struct percpu_ref)->force_atomic, (struct kioctx)->user_id, (struct kioctx)->req_batch, (struct kioctx)->max_reqs, (struct kioctx)->nr_events, (struct kioctx)->mmap_base, (struct kioctx)->mmap_size, (struct kioctx)->ring_pages, (struct kioctx)->nr_pages, (struct kioctx)->tail, (struct kioctx)->completed_events, (struct kioctx)->id, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, ]
+C_SYSC_io_getevents write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_name_to_handle_at write_list: [(struct file_handle)->handle_bytes, (struct file_handle)->handle_type, ]
+SYSC_open_by_handle_at write_list: [(struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+C_SYSC_open_by_handle_at write_list: [(struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_ioctl write_list: [(struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+SYSC_sysfs write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct file_system_type)->name, (struct file_system_type)->fs_flags, (struct file_system_type)->mount, (struct file_system_type)->kill_sb, ]
+SYSC_signalfd4 write_list: [(struct fd)->flags, ]
+SYSC_pipe2 write_list: [(struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_getcwd write_list: [(struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct vfsmount)->mnt_flags, (struct mount)->mnt_devname, (struct mount)->mnt_fsnotify_mask, (struct mount)->mnt_id, (struct mount)->mnt_group_id, (struct mount)->mnt_expiry_mark, (struct fs_pin)->done, (struct fs_pin)->kill, ]
+SYSC_stat write_list: [(struct __old_kernel_stat)->st_dev, (struct __old_kernel_stat)->st_ino, (struct __old_kernel_stat)->st_mode, (struct __old_kernel_stat)->st_nlink, (struct __old_kernel_stat)->st_uid, (struct __old_kernel_stat)->st_gid, (struct __old_kernel_stat)->st_rdev, (struct __old_kernel_stat)->st_size, (struct __old_kernel_stat)->st_atime, (struct __old_kernel_stat)->st_mtime, (struct __old_kernel_stat)->st_ctime, (struct __old_kernel_stat)->st_uid, (struct __old_kernel_stat)->st_gid, ]
+SYSC_lstat write_list: [(struct __old_kernel_stat)->st_dev, (struct __old_kernel_stat)->st_ino, (struct __old_kernel_stat)->st_mode, (struct __old_kernel_stat)->st_nlink, (struct __old_kernel_stat)->st_uid, (struct __old_kernel_stat)->st_gid, (struct __old_kernel_stat)->st_rdev, (struct __old_kernel_stat)->st_size, (struct __old_kernel_stat)->st_atime, (struct __old_kernel_stat)->st_mtime, (struct __old_kernel_stat)->st_ctime, (struct __old_kernel_stat)->st_uid, (struct __old_kernel_stat)->st_gid, ]
+SYSC_fstat write_list: [(struct __old_kernel_stat)->st_dev, (struct __old_kernel_stat)->st_ino, (struct __old_kernel_stat)->st_mode, (struct __old_kernel_stat)->st_nlink, (struct __old_kernel_stat)->st_uid, (struct __old_kernel_stat)->st_gid, (struct __old_kernel_stat)->st_rdev, (struct __old_kernel_stat)->st_size, (struct __old_kernel_stat)->st_atime, (struct __old_kernel_stat)->st_mtime, (struct __old_kernel_stat)->st_ctime, (struct __old_kernel_stat)->st_uid, (struct __old_kernel_stat)->st_gid, ]
+SYSC_newstat write_list: [(struct stat)->__pad0, (struct stat)->st_dev, (struct stat)->st_ino, (struct stat)->st_mode, (struct stat)->st_nlink, (struct stat)->st_uid, (struct stat)->st_gid, (struct stat)->st_rdev, (struct stat)->st_size, (struct stat)->st_atime, (struct stat)->st_mtime, (struct stat)->st_ctime, (struct stat)->st_atime_nsec, (struct stat)->st_mtime_nsec, (struct stat)->st_ctime_nsec, (struct stat)->st_blocks, (struct stat)->st_blksize, ]
+SYSC_newlstat write_list: [(struct stat)->__pad0, (struct stat)->st_dev, (struct stat)->st_ino, (struct stat)->st_mode, (struct stat)->st_nlink, (struct stat)->st_uid, (struct stat)->st_gid, (struct stat)->st_rdev, (struct stat)->st_size, (struct stat)->st_atime, (struct stat)->st_mtime, (struct stat)->st_ctime, (struct stat)->st_atime_nsec, (struct stat)->st_mtime_nsec, (struct stat)->st_ctime_nsec, (struct stat)->st_blocks, (struct stat)->st_blksize, ]
+SYSC_newfstatat write_list: [(struct stat)->__pad0, (struct stat)->st_dev, (struct stat)->st_ino, (struct stat)->st_mode, (struct stat)->st_nlink, (struct stat)->st_uid, (struct stat)->st_gid, (struct stat)->st_rdev, (struct stat)->st_size, (struct stat)->st_atime, (struct stat)->st_mtime, (struct stat)->st_ctime, (struct stat)->st_atime_nsec, (struct stat)->st_mtime_nsec, (struct stat)->st_ctime_nsec, (struct stat)->st_blocks, (struct stat)->st_blksize, ]
+SYSC_newfstat write_list: [(struct stat)->__pad0, (struct stat)->st_dev, (struct stat)->st_ino, (struct stat)->st_mode, (struct stat)->st_nlink, (struct stat)->st_uid, (struct stat)->st_gid, (struct stat)->st_rdev, (struct stat)->st_size, (struct stat)->st_atime, (struct stat)->st_mtime, (struct stat)->st_ctime, (struct stat)->st_atime_nsec, (struct stat)->st_mtime_nsec, (struct stat)->st_ctime_nsec, (struct stat)->st_blocks, (struct stat)->st_blksize, ]
+SYSC_readlinkat write_list: [(struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+SYSC_statx write_list: [(struct statx)->stx_mask, (struct statx)->stx_blksize, (struct statx)->stx_attributes, (struct statx)->stx_nlink, (struct statx)->stx_uid, (struct statx)->stx_gid, (struct statx)->stx_mode, (struct statx)->stx_ino, (struct statx)->stx_size, (struct statx)->stx_blocks, (struct statx)->stx_attributes_mask, (struct statx_timestamp)->tv_sec, (struct statx_timestamp)->tv_nsec, (struct statx_timestamp)->__reserved, (struct statx)->stx_rdev_major, (struct statx)->stx_rdev_minor, (struct statx)->stx_dev_major, (struct statx)->stx_dev_minor, ]
+C_SYSC_newstat write_list: [(struct compat_stat)->st_dev, (struct compat_stat)->__pad1, (struct compat_stat)->st_ino, (struct compat_stat)->st_mode, (struct compat_stat)->st_nlink, (struct compat_stat)->st_uid, (struct compat_stat)->st_gid, (struct compat_stat)->st_rdev, (struct compat_stat)->__pad2, (struct compat_stat)->st_size, (struct compat_stat)->st_blksize, (struct compat_stat)->st_blocks, (struct compat_stat)->st_atime, (struct compat_stat)->st_atime_nsec, (struct compat_stat)->st_mtime, (struct compat_stat)->st_mtime_nsec, (struct compat_stat)->st_ctime, (struct compat_stat)->st_ctime_nsec, (struct compat_stat)->__unused4, (struct compat_stat)->__unused5, (struct compat_stat)->st_uid, (struct compat_stat)->st_gid, ]
+C_SYSC_newlstat write_list: [(struct compat_stat)->st_dev, (struct compat_stat)->__pad1, (struct compat_stat)->st_ino, (struct compat_stat)->st_mode, (struct compat_stat)->st_nlink, (struct compat_stat)->st_uid, (struct compat_stat)->st_gid, (struct compat_stat)->st_rdev, (struct compat_stat)->__pad2, (struct compat_stat)->st_size, (struct compat_stat)->st_blksize, (struct compat_stat)->st_blocks, (struct compat_stat)->st_atime, (struct compat_stat)->st_atime_nsec, (struct compat_stat)->st_mtime, (struct compat_stat)->st_mtime_nsec, (struct compat_stat)->st_ctime, (struct compat_stat)->st_ctime_nsec, (struct compat_stat)->__unused4, (struct compat_stat)->__unused5, (struct compat_stat)->st_uid, (struct compat_stat)->st_gid, ]
+C_SYSC_newfstatat write_list: [(struct compat_stat)->st_dev, (struct compat_stat)->__pad1, (struct compat_stat)->st_ino, (struct compat_stat)->st_mode, (struct compat_stat)->st_nlink, (struct compat_stat)->st_uid, (struct compat_stat)->st_gid, (struct compat_stat)->st_rdev, (struct compat_stat)->__pad2, (struct compat_stat)->st_size, (struct compat_stat)->st_blksize, (struct compat_stat)->st_blocks, (struct compat_stat)->st_atime, (struct compat_stat)->st_atime_nsec, (struct compat_stat)->st_mtime, (struct compat_stat)->st_mtime_nsec, (struct compat_stat)->st_ctime, (struct compat_stat)->st_ctime_nsec, (struct compat_stat)->__unused4, (struct compat_stat)->__unused5, (struct compat_stat)->st_uid, (struct compat_stat)->st_gid, ]
+C_SYSC_newfstat write_list: [(struct compat_stat)->st_dev, (struct compat_stat)->__pad1, (struct compat_stat)->st_ino, (struct compat_stat)->st_mode, (struct compat_stat)->st_nlink, (struct compat_stat)->st_uid, (struct compat_stat)->st_gid, (struct compat_stat)->st_rdev, (struct compat_stat)->__pad2, (struct compat_stat)->st_size, (struct compat_stat)->st_blksize, (struct compat_stat)->st_blocks, (struct compat_stat)->st_atime, (struct compat_stat)->st_atime_nsec, (struct compat_stat)->st_mtime, (struct compat_stat)->st_mtime_nsec, (struct compat_stat)->st_ctime, (struct compat_stat)->st_ctime_nsec, (struct compat_stat)->__unused4, (struct compat_stat)->__unused5, (struct compat_stat)->st_uid, (struct compat_stat)->st_gid, ]
+SYSC_old_readdir write_list: [(struct fd)->flags, (struct dir_context)->actor, (struct old_linux_dirent)->d_ino, (struct old_linux_dirent)->d_offset, (struct old_linux_dirent)->d_namlen, (struct dir_context)->pos, (struct readdir_callback)->result, ]
+SYSC_getdents write_list: [(struct dir_context)->actor, (struct getdents_callback)->count, (struct linux_dirent)->d_ino, (struct linux_dirent)->d_off, (struct linux_dirent)->d_reclen, (struct dir_context)->pos, (struct getdents_callback)->error, (struct fd)->flags, ]
+SYSC_getdents64 write_list: [(struct dir_context)->actor, (struct getdents_callback64)->count, (struct linux_dirent64)->d_ino, (struct linux_dirent64)->d_off, (struct linux_dirent64)->d_reclen, (struct linux_dirent64)->d_type, (struct dir_context)->pos, (struct getdents_callback64)->error, (struct fd)->flags, ]
+C_SYSC_old_readdir write_list: [(struct fd)->flags, (struct dir_context)->actor, (struct compat_old_linux_dirent)->d_ino, (struct compat_old_linux_dirent)->d_offset, (struct compat_old_linux_dirent)->d_namlen, (struct dir_context)->pos, (struct compat_readdir_callback)->result, ]
+C_SYSC_getdents write_list: [(struct dir_context)->actor, (struct compat_linux_dirent)->d_ino, (struct compat_linux_dirent)->d_off, (struct compat_linux_dirent)->d_reclen, (struct compat_getdents_callback)->count, (struct dir_context)->pos, (struct compat_getdents_callback)->error, (struct fd)->flags, ]
+SYSC_dup3 write_list: [(struct atomic_t)->counter, (struct files_struct)->resize_in_progress, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct fdtable)->max_fds, (struct fdtable)->fd, (struct fdtable)->close_on_exec, (struct fdtable)->open_fds, (struct fdtable)->full_fds_bits, (struct callback_head)->func, (struct files_struct)->next_fd, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_dup2 write_list: [(struct atomic_t)->counter, (struct files_struct)->resize_in_progress, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct fdtable)->max_fds, (struct fdtable)->fd, (struct fdtable)->close_on_exec, (struct fdtable)->open_fds, (struct fdtable)->full_fds_bits, (struct callback_head)->func, (struct files_struct)->next_fd, ]
+SYSC_dup write_list: [(struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_fsetxattr write_list: [(struct fd)->flags, ]
+SYSC_fgetxattr write_list: [(struct fd)->flags, ]
+SYSC_flistxattr write_list: [(struct fd)->flags, ]
+SYSC_fremovexattr write_list: [(struct fd)->flags, ]
+SYSC_uselib write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct open_flags)->open_flag, (struct open_flags)->acc_mode, (struct open_flags)->intent, (struct open_flags)->lookup_flags, (struct open_flags)->mode, (struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct linux_binfmt)->load_binary, (struct linux_binfmt)->load_shlib, (struct linux_binfmt)->core_dump, (struct linux_binfmt)->min_coredump, ]
+SYSC_execve write_list: [(union anonymous)->native, (struct user_arg_ptr)->is_compat, (union anonymous)->compat, ]
+SYSC_execveat write_list: [(union anonymous)->native, (struct user_arg_ptr)->is_compat, (union anonymous)->compat, ]
+C_SYSC_execve write_list: [(struct user_arg_ptr)->is_compat, (union anonymous)->compat, (union anonymous)->native, ]
+C_SYSC_execveat write_list: [(struct user_arg_ptr)->is_compat, (union anonymous)->compat, (union anonymous)->native, ]
+SYSC_umount write_list: [(struct hlist_node)->pprev, (struct vfsmount)->mnt_flags, (struct callback_head)->func, (struct mount)->mnt_devname, (struct mount)->mnt_fsnotify_mask, (struct mount)->mnt_id, (struct mount)->mnt_group_id, (struct mount)->mnt_expiry_mark, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct fs_pin)->done, (struct fs_pin)->kill, (struct super_block)->s_dev, (struct super_block)->s_blocksize_bits, (struct super_block)->s_blocksize, (struct super_block)->s_maxbytes, (struct super_block)->s_flags, (struct super_block)->s_iflags, (struct super_block)->s_magic, (struct atomic64_t)->counter, (struct super_block)->s_count, (struct super_block)->s_security, (struct super_block)->s_xattr, (struct super_block)->s_quota_types, (struct quota_info)->flags, (struct mutex)->magic, (struct sb_writers)->frozen, (struct super_block)->s_fs_info, (struct super_block)->s_max_links, (struct super_block)->s_mode, (struct super_block)->s_time_gran, (struct super_block)->s_subtype, (struct super_block)->cleancache_poolid, (struct shrinker)->count_objects, (struct shrinker)->scan_objects, (struct shrinker)->seeks, (struct shrinker)->batch, (struct shrinker)->flags, (struct super_block)->s_readonly_remount, (struct work_struct)->func, (struct super_block)->s_stack_depth, (struct thread_info)->flags, (struct task_struct)->state, (struct task_struct)->stack, (struct task_struct)->flags, (struct task_struct)->ptrace, (struct task_struct)->on_cpu, (struct task_struct)->cpu, (struct task_struct)->wakee_flips, (struct task_struct)->wakee_flip_decay_ts, (struct task_struct)->wake_cpu, (struct task_struct)->on_rq, (struct task_struct)->prio, (struct task_struct)->static_prio, (struct task_struct)->normal_prio, (struct task_struct)->rt_priority, (struct load_weight)->weight, (struct load_weight)->inv_weight, (struct rb_node)->__rb_parent_color, (struct sched_entity)->on_rq, (struct sched_entity)->exec_start, (struct sched_entity)->sum_exec_runtime, (struct sched_entity)->vruntime, (struct sched_entity)->prev_sum_exec_runtime, (struct sched_entity)->nr_migrations, (struct sched_statistics)->wait_start, (struct sched_statistics)->wait_max, (struct sched_statistics)->wait_count, (struct sched_statistics)->wait_sum, (struct sched_statistics)->iowait_count, (struct sched_statistics)->iowait_sum, (struct sched_statistics)->sleep_start, (struct sched_statistics)->sleep_max, (struct sched_statistics)->sum_sleep_runtime, (struct sched_statistics)->block_start, (struct sched_statistics)->block_max, (struct sched_statistics)->exec_max, (struct sched_statistics)->slice_max, (struct sched_statistics)->nr_migrations_cold, (struct sched_statistics)->nr_failed_migrations_affine, (struct sched_statistics)->nr_failed_migrations_running, (struct sched_statistics)->nr_failed_migrations_hot, (struct sched_statistics)->nr_forced_migrations, (struct sched_statistics)->nr_wakeups, (struct sched_statistics)->nr_wakeups_sync, (struct sched_statistics)->nr_wakeups_migrate, (struct sched_statistics)->nr_wakeups_local, (struct sched_statistics)->nr_wakeups_remote, (struct sched_statistics)->nr_wakeups_affine, (struct sched_statistics)->nr_wakeups_affine_attempts, (struct sched_statistics)->nr_wakeups_passive, (struct sched_statistics)->nr_wakeups_idle, (struct sched_entity)->depth, (struct sched_avg)->last_update_time, (struct sched_avg)->load_sum, (struct sched_avg)->util_sum, (struct sched_avg)->period_contrib, (struct sched_avg)->load_avg, (struct sched_avg)->util_avg, (struct sched_rt_entity)->timeout, (struct sched_rt_entity)->watchdog_stamp, (struct sched_rt_entity)->time_slice, (struct sched_rt_entity)->on_rq, (struct sched_rt_entity)->on_list, (struct sched_dl_entity)->dl_runtime, (struct sched_dl_entity)->dl_deadline, (struct sched_dl_entity)->dl_period, (struct sched_dl_entity)->dl_bw, (struct sched_dl_entity)->dl_density, (struct sched_dl_entity)->runtime, (struct sched_dl_entity)->deadline, (struct sched_dl_entity)->flags, (struct sched_dl_entity)->dl_throttled, (struct sched_dl_entity)->dl_boosted, (struct sched_dl_entity)->dl_yielded, (struct sched_dl_entity)->dl_non_contending, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct task_struct)->btrace_seq, (struct task_struct)->policy, (struct task_struct)->nr_cpus_allowed, (struct sched_info)->pcount, (struct sched_info)->run_delay, (struct sched_info)->last_arrival, (struct sched_info)->last_queued, (struct plist_node)->prio, (struct vmacache)->seqnum, (struct task_rss_stat)->events, (struct task_struct)->exit_state, (struct task_struct)->exit_code, (struct task_struct)->exit_signal, (struct task_struct)->pdeath_signal, (struct task_struct)->jobctl, (struct task_struct)->personality, (struct task_struct)->sched_reset_on_fork, (struct task_struct)->sched_contributes_to_load, (struct task_struct)->sched_migrated, (struct task_struct)->sched_remote_wakeup, (struct task_struct)->in_execve, (struct task_struct)->in_iowait, (struct task_struct)->restore_sigmask, (struct task_struct)->no_cgroup_migration, (struct task_struct)->atomic_flags, (struct restart_block)->fn, (struct task_struct)->pid, (struct task_struct)->tgid, (struct task_struct)->set_child_tid, (struct task_struct)->clear_child_tid, (struct task_struct)->utime, (struct task_struct)->stime, (struct task_struct)->gtime, (struct prev_cputime)->utime, (struct prev_cputime)->stime, (struct task_struct)->nvcsw, (struct task_struct)->nivcsw, (struct task_struct)->start_time, (struct task_struct)->real_start_time, (struct task_struct)->min_flt, (struct task_struct)->maj_flt, (struct task_cputime)->utime, (struct task_cputime)->stime, (struct task_cputime)->sum_exec_runtime, (struct task_struct)->last_switch_count, (struct task_struct)->sas_ss_sp, (struct task_struct)->sas_ss_size, (struct task_struct)->sas_ss_flags, (struct kuid_t)->val, (struct task_struct)->sessionid, (struct seccomp)->mode, (struct task_struct)->parent_exec_id, (struct task_struct)->self_exec_id, (struct task_struct)->irq_events, (struct task_struct)->hardirq_enable_ip, (struct task_struct)->hardirq_disable_ip, (struct task_struct)->hardirq_enable_event, (struct task_struct)->hardirq_disable_event, (struct task_struct)->hardirqs_enabled, (struct task_struct)->hardirq_context, (struct task_struct)->softirq_disable_ip, (struct task_struct)->softirq_enable_ip, (struct task_struct)->softirq_disable_event, (struct task_struct)->softirq_enable_event, (struct task_struct)->softirqs_enabled, (struct task_struct)->softirq_context, (struct task_struct)->curr_chain_key, (struct task_struct)->lockdep_depth, (struct task_struct)->lockdep_recursion, (struct task_struct)->lockdep_reclaim_gfp, (struct task_struct)->journal_info, (struct task_struct)->ptrace_message, (struct task_io_accounting)->rchar, (struct task_io_accounting)->wchar, (struct task_io_accounting)->syscr, (struct task_io_accounting)->syscw, (struct task_io_accounting)->read_bytes, (struct task_io_accounting)->write_bytes, (struct task_io_accounting)->cancelled_write_bytes, (struct task_struct)->acct_rss_mem1, (struct task_struct)->acct_vm_mem1, (struct task_struct)->acct_timexpd, (struct seqcount)->sequence, (struct task_struct)->cpuset_mem_spread_rotor, (struct task_struct)->cpuset_slab_spread_rotor, (struct task_struct)->il_prev, (struct task_struct)->pref_node_fork, (struct tlbflush_unmap_batch)->flush_required, (struct tlbflush_unmap_batch)->writable, (struct page_frag)->offset, (struct page_frag)->size, (struct task_struct)->nr_dirtied, (struct task_struct)->nr_dirtied_pause, (struct task_struct)->dirty_paused_when, (struct task_struct)->timer_slack_ns, (struct task_struct)->default_timer_slack_ns, (struct task_struct)->kasan_depth, (struct task_struct)->trace, (struct task_struct)->trace_recursion, (struct task_struct)->kcov_mode, (struct task_struct)->kcov_size, (struct task_struct)->kcov_area, (struct task_struct)->task_state_change, (struct task_struct)->pagefault_disabled, (struct task_struct)->security, (struct thread_struct)->sp0, (struct thread_struct)->sp, (struct thread_struct)->es, (struct thread_struct)->ds, (struct thread_struct)->fsindex, (struct thread_struct)->gsindex, (struct thread_struct)->status, (struct thread_struct)->fsbase, (struct thread_struct)->gsbase, (struct thread_struct)->debugreg6, (struct thread_struct)->ptrace_dr7, (struct thread_struct)->cr2, (struct thread_struct)->trap_nr, (struct thread_struct)->error_code, (struct thread_struct)->io_bitmap_ptr, (struct thread_struct)->iopl, (struct thread_struct)->io_bitmap_max, (struct mm_segment_t)->seg, (struct thread_struct)->sig_on_uaccess_err, (struct thread_struct)->uaccess_err, (struct fpu)->last_cpu, (struct fpu)->fpstate_active, (struct fpu)->fpregs_active, (struct fregs_state)->cwd, (struct fregs_state)->swd, (struct fregs_state)->twd, (struct fregs_state)->fip, (struct fregs_state)->fcs, (struct fregs_state)->foo, (struct fregs_state)->fos, (struct fregs_state)->status, (struct fxregs_state)->cwd, (struct fxregs_state)->swd, (struct fxregs_state)->twd, (struct fxregs_state)->fop, (struct fxregs_state)->rip, (struct fxregs_state)->rdp, (struct fxregs_state)->fip, (struct fxregs_state)->fcs, (struct fxregs_state)->foo, (struct fxregs_state)->fos, (struct fxregs_state)->mxcsr, (struct fxregs_state)->mxcsr_mask, (struct swregs_state)->cwd, (struct swregs_state)->swd, (struct swregs_state)->twd, (struct swregs_state)->fip, (struct swregs_state)->fcs, (struct swregs_state)->foo, (struct swregs_state)->fos, (struct swregs_state)->ftop, (struct swregs_state)->changed, (struct swregs_state)->lookahead, (struct swregs_state)->no_update, (struct swregs_state)->rm, (struct swregs_state)->alimit, (struct swregs_state)->entry_eip, (struct xstate_header)->xfeatures, (struct xstate_header)->xcomp_bv, ]
+SYSC_pivot_root write_list: [(struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct vfsmount)->mnt_flags, (struct mountpoint)->m_count, (struct mount)->mnt_devname, (struct mount)->mnt_fsnotify_mask, (struct mount)->mnt_id, (struct mount)->mnt_group_id, (struct mount)->mnt_expiry_mark, (struct fs_pin)->done, (struct fs_pin)->kill, (struct mnt_namespace)->event, ]
+C_SYSC_mount write_list: [(struct compat_ncp_mount_data)->version, (struct compat_ncp_mount_data)->ncp_fd, (struct compat_ncp_mount_data)->mounted_uid, (struct compat_ncp_mount_data)->wdog_pid, (struct compat_ncp_mount_data)->time_out, (struct compat_ncp_mount_data)->retry_count, (struct compat_ncp_mount_data)->flags, (struct compat_ncp_mount_data)->uid, (struct compat_ncp_mount_data)->gid, (struct compat_ncp_mount_data)->file_mode, (struct compat_ncp_mount_data)->dir_mode, (struct ncp_mount_data)->version, (struct ncp_mount_data)->ncp_fd, (struct ncp_mount_data)->mounted_uid, (struct ncp_mount_data)->wdog_pid, (struct ncp_mount_data)->time_out, (struct ncp_mount_data)->retry_count, (struct ncp_mount_data)->flags, (struct ncp_mount_data)->uid, (struct ncp_mount_data)->gid, (struct ncp_mount_data)->file_mode, (struct ncp_mount_data)->dir_mode, (struct compat_ncp_mount_data_v4)->version, (struct compat_ncp_mount_data_v4)->flags, (struct compat_ncp_mount_data_v4)->mounted_uid, (struct compat_ncp_mount_data_v4)->wdog_pid, (struct compat_ncp_mount_data_v4)->ncp_fd, (struct compat_ncp_mount_data_v4)->time_out, (struct compat_ncp_mount_data_v4)->retry_count, (struct compat_ncp_mount_data_v4)->uid, (struct compat_ncp_mount_data_v4)->gid, (struct compat_ncp_mount_data_v4)->file_mode, (struct compat_ncp_mount_data_v4)->dir_mode, (struct ncp_mount_data_v4)->version, (struct ncp_mount_data_v4)->flags, (struct ncp_mount_data_v4)->mounted_uid, (struct ncp_mount_data_v4)->wdog_pid, (struct ncp_mount_data_v4)->ncp_fd, (struct ncp_mount_data_v4)->time_out, (struct ncp_mount_data_v4)->retry_count, (struct ncp_mount_data_v4)->uid, (struct ncp_mount_data_v4)->gid, (struct ncp_mount_data_v4)->file_mode, (struct ncp_mount_data_v4)->dir_mode, (struct compat_nfs4_mount_data_v1)->version, (struct compat_nfs4_mount_data_v1)->flags, (struct compat_nfs4_mount_data_v1)->rsize, (struct compat_nfs4_mount_data_v1)->wsize, (struct compat_nfs4_mount_data_v1)->timeo, (struct compat_nfs4_mount_data_v1)->retrans, (struct compat_nfs4_mount_data_v1)->acregmin, (struct compat_nfs4_mount_data_v1)->acregmax, (struct compat_nfs4_mount_data_v1)->acdirmin, (struct compat_nfs4_mount_data_v1)->acdirmax, (struct compat_nfs_string)->len, (struct compat_nfs_string)->data, (struct compat_nfs4_mount_data_v1)->host_addrlen, (struct compat_nfs4_mount_data_v1)->host_addr, (struct compat_nfs4_mount_data_v1)->proto, (struct compat_nfs4_mount_data_v1)->auth_flavourlen, (struct compat_nfs4_mount_data_v1)->auth_flavours, (struct nfs4_mount_data)->version, (struct nfs4_mount_data)->flags, (struct nfs4_mount_data)->rsize, (struct nfs4_mount_data)->wsize, (struct nfs4_mount_data)->timeo, (struct nfs4_mount_data)->retrans, (struct nfs4_mount_data)->acregmin, (struct nfs4_mount_data)->acregmax, (struct nfs4_mount_data)->acdirmin, (struct nfs4_mount_data)->acdirmax, (struct nfs_string)->len, (struct nfs_string)->data, (struct nfs4_mount_data)->host_addrlen, (struct nfs4_mount_data)->proto, (struct nfs4_mount_data)->auth_flavourlen, (struct nfs4_mount_data)->auth_flavours, (struct sockaddr)->sa_family, ]
+SYSC_lseek write_list: [(struct fd)->flags, ]
+SYSC_llseek write_list: [(struct fd)->flags, ]
+SYSC_read write_list: [(struct fd)->flags, (struct file)->f_pos, ]
+SYSC_write write_list: [(struct fd)->flags, (struct file)->f_pos, ]
+SYSC_pread64 write_list: [(struct fd)->flags, ]
+SYSC_pwrite64 write_list: [(struct fd)->flags, ]
+SYSC_readv write_list: [(struct fd)->flags, ]
+SYSC_writev write_list: [(struct fd)->flags, ]
+SYSC_preadv write_list: [(struct fd)->flags, ]
+SYSC_preadv2 write_list: [(struct fd)->flags, ]
+SYSC_pwritev write_list: [(struct fd)->flags, ]
+SYSC_pwritev2 write_list: [(struct fd)->flags, ]
+C_SYSC_readv write_list: [(struct fd)->flags, (struct file)->f_pos, ]
+C_SYSC_preadv64 write_list: [(struct fd)->flags, ]
+C_SYSC_preadv write_list: [(struct fd)->flags, ]
+C_SYSC_preadv64v2 write_list: [(struct fd)->flags, ]
+C_SYSC_preadv2 write_list: [(struct fd)->flags, (struct file)->f_pos, ]
+C_SYSC_writev write_list: [(struct fd)->flags, (struct file)->f_pos, ]
+C_SYSC_pwritev64 write_list: [(struct fd)->flags, ]
+C_SYSC_pwritev write_list: [(struct fd)->flags, ]
+C_SYSC_pwritev64v2 write_list: [(struct fd)->flags, ]
+C_SYSC_pwritev2 write_list: [(struct fd)->flags, (struct file)->f_pos, ]
+SYSC_sendfile write_list: [(struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct file)->f_pos, ]
+SYSC_sendfile64 write_list: [(struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct file)->f_pos, ]
+C_SYSC_sendfile write_list: [(struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct file)->f_pos, ]
+C_SYSC_sendfile64 write_list: [(struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct file)->f_pos, ]
+SYSC_copy_file_range write_list: [(struct fd)->flags, (struct file)->f_pos, ]
+SYSC_timerfd_create write_list: [(struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct timerfd_ctx)->tintv, (struct timerfd_ctx)->moffs, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct timerfd_ctx)->ticks, (struct timerfd_ctx)->clockid, (struct timerfd_ctx)->expired, (struct timerfd_ctx)->settime_flags, (struct callback_head)->func, (struct timerfd_ctx)->might_cancel, ]
+SYSC_timerfd_settime write_list: [(struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct timerfd_ctx)->tintv, (struct timerfd_ctx)->moffs, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct timerfd_ctx)->ticks, (struct timerfd_ctx)->clockid, (struct timerfd_ctx)->expired, (struct timerfd_ctx)->settime_flags, (struct callback_head)->func, (struct timerfd_ctx)->might_cancel, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_timerfd_gettime write_list: [(struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct timerfd_ctx)->tintv, (struct timerfd_ctx)->moffs, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct timerfd_ctx)->ticks, (struct timerfd_ctx)->clockid, (struct timerfd_ctx)->expired, (struct timerfd_ctx)->settime_flags, (struct callback_head)->func, (struct timerfd_ctx)->might_cancel, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_timerfd_settime write_list: [(struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct timerfd_ctx)->tintv, (struct timerfd_ctx)->moffs, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct timerfd_ctx)->ticks, (struct timerfd_ctx)->clockid, (struct timerfd_ctx)->expired, (struct timerfd_ctx)->settime_flags, (struct callback_head)->func, (struct timerfd_ctx)->might_cancel, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_timerfd_gettime write_list: [(struct rb_node)->__rb_parent_color, (struct timerqueue_node)->expires, (struct hrtimer)->_softexpires, (struct hrtimer)->function, (struct hrtimer)->state, (struct hrtimer)->is_rel, (struct alarm)->function, (struct alarm)->type, (struct alarm)->state, (struct alarm)->data, (struct timerfd_ctx)->tintv, (struct timerfd_ctx)->moffs, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct timerfd_ctx)->ticks, (struct timerfd_ctx)->clockid, (struct timerfd_ctx)->expired, (struct timerfd_ctx)->settime_flags, (struct callback_head)->func, (struct timerfd_ctx)->might_cancel, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_eventfd2 write_list: [(struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct eventfd_ctx)->count, (struct eventfd_ctx)->flags, (struct callback_head)->func, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_select write_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct fdtable)->max_fds, (struct fdtable)->fd, (struct fdtable)->close_on_exec, (struct fdtable)->open_fds, (struct fdtable)->full_fds_bits, (struct callback_head)->func, (struct fd_set_bits)->in, (struct fd_set_bits)->out, (struct fd_set_bits)->ex, (struct fd_set_bits)->res_in, (struct fd_set_bits)->res_out, (struct fd_set_bits)->res_ex, ]
+SYSC_pselect6 write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_poll write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct poll_list)->len, (struct pollfd)->fd, (struct pollfd)->events, (struct pollfd)->revents, (struct restart_block)->fn, ]
+SYSC_ppoll write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct poll_list)->len, (struct pollfd)->fd, (struct pollfd)->events, (struct pollfd)->revents, (struct task_struct)->restore_sigmask, (struct timeval)->tv_sec, (struct timeval)->tv_usec, ]
+C_SYSC_select write_list: [(struct compat_timeval)->tv_sec, (struct compat_timeval)->tv_usec, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct fdtable)->max_fds, (struct fdtable)->fd, (struct fdtable)->close_on_exec, (struct fdtable)->open_fds, (struct fdtable)->full_fds_bits, (struct callback_head)->func, (struct fd_set_bits)->in, (struct fd_set_bits)->out, (struct fd_set_bits)->ex, (struct fd_set_bits)->res_in, (struct fd_set_bits)->res_out, (struct fd_set_bits)->res_ex, (struct compat_timespec)->tv_sec, (struct compat_timespec)->tv_nsec, ]
+C_SYSC_old_select write_list: [(struct compat_sel_arg_struct)->n, (struct compat_sel_arg_struct)->inp, (struct compat_sel_arg_struct)->outp, (struct compat_sel_arg_struct)->exp, (struct compat_sel_arg_struct)->tvp, ]
+C_SYSC_pselect6 write_list: [(struct compat_timespec)->tv_sec, (struct compat_timespec)->tv_nsec, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_ppoll write_list: [(struct compat_timespec)->tv_sec, (struct compat_timespec)->tv_nsec, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct poll_list)->len, (struct pollfd)->fd, (struct pollfd)->events, (struct pollfd)->revents, (struct task_struct)->restore_sigmask, (struct compat_timeval)->tv_sec, (struct compat_timeval)->tv_usec, ]
+SYSC_syncfs write_list: [(struct fd)->flags, (struct super_block)->s_dev, (struct super_block)->s_blocksize_bits, (struct super_block)->s_blocksize, (struct super_block)->s_maxbytes, (struct super_block)->s_flags, (struct super_block)->s_iflags, (struct super_block)->s_magic, (struct atomic64_t)->counter, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct super_block)->s_count, (struct super_block)->s_security, (struct super_block)->s_xattr, (struct hlist_node)->pprev, (struct super_block)->s_quota_types, (struct quota_info)->flags, (struct mutex)->magic, (struct sb_writers)->frozen, (struct super_block)->s_fs_info, (struct super_block)->s_max_links, (struct super_block)->s_mode, (struct super_block)->s_time_gran, (struct super_block)->s_subtype, (struct super_block)->cleancache_poolid, (struct shrinker)->count_objects, (struct shrinker)->scan_objects, (struct shrinker)->seeks, (struct shrinker)->batch, (struct shrinker)->flags, (struct super_block)->s_readonly_remount, (struct callback_head)->func, (struct work_struct)->func, (struct super_block)->s_stack_depth, ]
+SYSC_fsync write_list: [(struct fd)->flags, ]
+SYSC_fdatasync write_list: [(struct fd)->flags, ]
+SYSC_sync_file_range write_list: [(struct fd)->flags, (struct radix_tree_root)->gfp_mask, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct atomic64_t)->counter, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, ]
+SYSC_ftruncate write_list: [(struct fd)->flags, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+C_SYSC_ftruncate write_list: [(struct fd)->flags, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+SYSC_fallocate write_list: [(struct fd)->flags, ]
+SYSC_faccessat write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, (struct inode)->i_mode, (struct inode)->i_opflags, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+SYSC_fchdir write_list: [(struct fd)->flags, ]
+SYSC_fchmod write_list: [(struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct iattr)->ia_mode, (struct iattr)->ia_valid, ]
+SYSC_fchmodat write_list: [(struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct iattr)->ia_mode, (struct iattr)->ia_valid, ]
+SYSC_fchownat write_list: [(struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct iattr)->ia_valid, ]
+SYSC_fchown write_list: [(struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct iattr)->ia_valid, ]
+SYSC_open write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_openat write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+C_SYSC_open write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+C_SYSC_openat write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct callback_head)->func, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_utime write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_utimensat write_list: [(struct fd)->flags, ]
+SYSC_futimesat write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct fd)->flags, ]
+C_SYSC_utime write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct fd)->flags, ]
+C_SYSC_utimensat write_list: [(struct fd)->flags, ]
+C_SYSC_futimesat write_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct timespec)->tv_nsec, (struct fd)->flags, ]
+SYSC_flock write_list: [(struct fd)->flags, (struct hlist_node)->pprev, (struct file_lock)->fl_owner, (struct file_lock)->fl_flags, (struct file_lock)->fl_type, (struct file_lock)->fl_pid, (struct file_lock)->fl_link_cpu, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct file_lock)->fl_start, (struct file_lock)->fl_end, (struct file_lock)->fl_break_time, (struct file_lock)->fl_downgrade_time, (struct nfs_lock_info)->state, (struct callback_head)->func, (struct file)->f_write_hint, (struct atomic64_t)->counter, (struct file)->f_flags, (struct file)->f_mode, (struct mutex)->magic, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_epoll_create1 write_list: [(struct atomic_t)->counter, (struct kuid_t)->val, (struct kgid_t)->val, (struct cred)->securebits, (struct cred)->jit_keyring, (struct cred)->security, (struct callback_head)->func, (struct atomic64_t)->counter, (struct user_struct)->mq_bytes, (struct user_struct)->locked_shm, (struct user_struct)->unix_inflight, (struct hlist_node)->pprev, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct mutex)->magic, (struct eventpoll)->visited, (struct eventpoll)->napi_id, (struct rb_node)->__rb_parent_color, (struct epoll_filefd)->fd, (struct epitem)->nwait, (struct epoll_event)->events, (struct epoll_event)->data, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, ]
+SYSC_epoll_ctl write_list: [(struct epoll_event)->events, (struct epoll_event)->data, (struct fd)->flags, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct atomic64_t)->counter, (struct mutex)->magic, (struct eventpoll)->visited, (struct eventpoll)->napi_id, (struct callback_head)->func, (struct file)->f_write_hint, (struct file)->f_flags, (struct file)->f_mode, (struct file)->f_pos, (struct rwlock_t)->magic, (struct rwlock_t)->owner_cpu, (struct rwlock_t)->owner, (struct fown_struct)->pid_type, (struct kuid_t)->val, (struct fown_struct)->signum, (struct file_ra_state)->start, (struct file_ra_state)->size, (struct file_ra_state)->async_size, (struct file_ra_state)->ra_pages, (struct file_ra_state)->mmap_miss, (struct file_ra_state)->prev_pos, (struct file)->f_version, (struct file)->f_security, (struct file)->private_data, (struct file)->f_wb_err, (struct rb_node)->__rb_parent_color, (struct epoll_filefd)->fd, (struct epitem)->nwait, ]
+SYSC_epoll_wait write_list: [(struct fd)->flags, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct atomic64_t)->counter, (struct mutex)->magic, (struct eventpoll)->visited, (struct eventpoll)->napi_id, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct task_struct)->task_state_change, (struct task_struct)->state, ]
+SYSC_epoll_pwait write_list: [(struct task_struct)->restore_sigmask, ]
+C_SYSC_epoll_pwait write_list: [(struct task_struct)->restore_sigmask, ]
+SYSC_statfs write_list: [(struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct statfs)->f_type, (struct statfs)->f_bsize, (struct statfs)->f_blocks, (struct statfs)->f_bfree, (struct statfs)->f_bavail, (struct statfs)->f_files, (struct statfs)->f_ffree, (struct statfs)->f_namelen, (struct statfs)->f_frsize, (struct statfs)->f_flags, ]
+SYSC_statfs64 write_list: [(struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct statfs64)->f_type, (struct statfs64)->f_bsize, (struct statfs64)->f_blocks, (struct statfs64)->f_bfree, (struct statfs64)->f_bavail, (struct statfs64)->f_files, (struct statfs64)->f_ffree, (struct statfs64)->f_namelen, (struct statfs64)->f_frsize, (struct statfs64)->f_flags, ]
+SYSC_fstatfs write_list: [(struct fd)->flags, (struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct statfs)->f_type, (struct statfs)->f_bsize, (struct statfs)->f_blocks, (struct statfs)->f_bfree, (struct statfs)->f_bavail, (struct statfs)->f_files, (struct statfs)->f_ffree, (struct statfs)->f_namelen, (struct statfs)->f_frsize, (struct statfs)->f_flags, ]
+SYSC_fstatfs64 write_list: [(struct fd)->flags, (struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct statfs64)->f_type, (struct statfs64)->f_bsize, (struct statfs64)->f_blocks, (struct statfs64)->f_bfree, (struct statfs64)->f_bavail, (struct statfs64)->f_files, (struct statfs64)->f_ffree, (struct statfs64)->f_namelen, (struct statfs64)->f_frsize, (struct statfs64)->f_flags, ]
+SYSC_ustat write_list: [(struct super_block)->s_dev, (struct super_block)->s_blocksize_bits, (struct super_block)->s_blocksize, (struct super_block)->s_maxbytes, (struct super_block)->s_flags, (struct super_block)->s_iflags, (struct super_block)->s_magic, (struct atomic64_t)->counter, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct super_block)->s_count, (struct super_block)->s_security, (struct super_block)->s_xattr, (struct hlist_node)->pprev, (struct super_block)->s_quota_types, (struct quota_info)->flags, (struct mutex)->magic, (struct sb_writers)->frozen, (struct super_block)->s_fs_info, (struct super_block)->s_max_links, (struct super_block)->s_mode, (struct super_block)->s_time_gran, (struct super_block)->s_subtype, (struct super_block)->cleancache_poolid, (struct shrinker)->count_objects, (struct shrinker)->scan_objects, (struct shrinker)->seeks, (struct shrinker)->batch, (struct shrinker)->flags, (struct super_block)->s_readonly_remount, (struct callback_head)->func, (struct work_struct)->func, (struct super_block)->s_stack_depth, (struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct ustat)->f_tfree, (struct ustat)->f_tinode, ]
+C_SYSC_statfs write_list: [(struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct compat_statfs)->f_type, (struct compat_statfs)->f_bsize, (struct compat_statfs)->f_blocks, (struct compat_statfs)->f_bfree, (struct compat_statfs)->f_bavail, (struct compat_statfs)->f_files, (struct compat_statfs)->f_ffree, (struct compat_statfs)->f_namelen, (struct compat_statfs)->f_frsize, (struct compat_statfs)->f_flags, ]
+C_SYSC_fstatfs write_list: [(struct fd)->flags, (struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct compat_statfs)->f_type, (struct compat_statfs)->f_bsize, (struct compat_statfs)->f_blocks, (struct compat_statfs)->f_bfree, (struct compat_statfs)->f_bavail, (struct compat_statfs)->f_files, (struct compat_statfs)->f_ffree, (struct compat_statfs)->f_namelen, (struct compat_statfs)->f_frsize, (struct compat_statfs)->f_flags, ]
+C_SYSC_statfs64 write_list: [(struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct compat_statfs64)->f_type, (struct compat_statfs64)->f_bsize, (struct compat_statfs64)->f_blocks, (struct compat_statfs64)->f_bfree, (struct compat_statfs64)->f_bavail, (struct compat_statfs64)->f_files, (struct compat_statfs64)->f_ffree, (struct compat_statfs64)->f_namelen, (struct compat_statfs64)->f_frsize, (struct compat_statfs64)->f_flags, ]
+C_SYSC_fstatfs64 write_list: [(struct fd)->flags, (struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct compat_statfs64)->f_type, (struct compat_statfs64)->f_bsize, (struct compat_statfs64)->f_blocks, (struct compat_statfs64)->f_bfree, (struct compat_statfs64)->f_bavail, (struct compat_statfs64)->f_files, (struct compat_statfs64)->f_ffree, (struct compat_statfs64)->f_namelen, (struct compat_statfs64)->f_frsize, (struct compat_statfs64)->f_flags, ]
+C_SYSC_ustat write_list: [(struct super_block)->s_dev, (struct super_block)->s_blocksize_bits, (struct super_block)->s_blocksize, (struct super_block)->s_maxbytes, (struct super_block)->s_flags, (struct super_block)->s_iflags, (struct super_block)->s_magic, (struct atomic64_t)->counter, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct super_block)->s_count, (struct super_block)->s_security, (struct super_block)->s_xattr, (struct hlist_node)->pprev, (struct super_block)->s_quota_types, (struct quota_info)->flags, (struct mutex)->magic, (struct sb_writers)->frozen, (struct super_block)->s_fs_info, (struct super_block)->s_max_links, (struct super_block)->s_mode, (struct super_block)->s_time_gran, (struct super_block)->s_subtype, (struct super_block)->cleancache_poolid, (struct shrinker)->count_objects, (struct shrinker)->scan_objects, (struct shrinker)->seeks, (struct shrinker)->batch, (struct shrinker)->flags, (struct super_block)->s_readonly_remount, (struct callback_head)->func, (struct work_struct)->func, (struct super_block)->s_stack_depth, (struct kstatfs)->f_type, (struct kstatfs)->f_bsize, (struct kstatfs)->f_blocks, (struct kstatfs)->f_bfree, (struct kstatfs)->f_bavail, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, (struct kstatfs)->f_namelen, (struct kstatfs)->f_frsize, (struct kstatfs)->f_flags, (struct compat_ustat)->f_tfree, (struct compat_ustat)->f_tinode, ]
+SYSC_fcntl write_list: [(struct fd)->flags, (struct flock)->l_type, (struct flock)->l_whence, (struct flock)->l_start, (struct flock)->l_len, (struct flock)->l_pid, (struct fown_struct)->signum, ]
+C_SYSC_fcntl64 write_list: [(struct fd)->flags, (struct compat_flock)->l_type, (struct compat_flock)->l_whence, (struct compat_flock)->l_start, (struct compat_flock)->l_len, (struct compat_flock)->l_pid, (struct flock)->l_type, (struct flock)->l_whence, (struct flock)->l_start, (struct flock)->l_len, (struct flock)->l_pid, (struct compat_flock64)->l_type, (struct compat_flock64)->l_whence, (struct compat_flock64)->l_start, (struct compat_flock64)->l_len, (struct compat_flock64)->l_pid, (struct fown_struct)->signum, ]
+SYSC_mknodat write_list: [(struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, ]
+SYSC_mkdirat write_list: [(struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, ]
+SYSC_rmdir write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, ]
+SYSC_unlinkat write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+SYSC_unlink write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+SYSC_symlinkat write_list: [(struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, ]
+SYSC_linkat write_list: [(struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, ]
+SYSC_renameat2 write_list: [(struct qstr)->hash, (struct qstr)->len, (struct qstr)->hash_len, (struct qstr)->name, (struct filename)->name, (struct filename)->uptr, (struct filename)->refcnt, (struct dentry)->d_flags, (struct seqcount)->sequence, (struct lockdep_map)->name, (struct hlist_bl_node)->pprev, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockref)->count, (struct dentry)->d_time, (struct dentry)->d_fsdata, (struct hlist_node)->pprev, (struct callback_head)->func, ]
+C_SYSC_ioctl write_list: [(struct fd)->flags, (struct space_resv)->l_type, (struct space_resv)->l_whence, (struct space_resv)->l_start, (struct space_resv)->l_len, (struct space_resv)->l_sysid, (struct space_resv)->l_pid, ]
+SYSC_inotify_init1 write_list: [(struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct fsnotify_group)->q_len, (struct fsnotify_group)->max_events, (struct fsnotify_group)->priority, (struct fsnotify_group)->shutdown, (struct atomic64_t)->counter, (struct mutex)->magic, (struct fsnotify_group)->private, (struct radix_tree_root)->gfp_mask, (struct idr)->idr_next, (struct fsnotify_event)->mask, (struct inotify_event_info)->wd, (struct inotify_event_info)->sync_cookie, (struct inotify_event_info)->name_len, (struct hlist_node)->pprev, (struct kuid_t)->val, (struct ucounts)->count, ]
+SYSC_inotify_add_watch write_list: [(struct fd)->flags, (struct inode)->i_mode, (struct inode)->i_opflags, (struct kuid_t)->val, (struct kgid_t)->val, (struct inode)->i_flags, (struct inode)->i_security, (struct inode)->i_ino, (struct inode)->i_nlink, (struct inode)->__i_nlink, (struct inode)->i_rdev, (struct inode)->i_size, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct inode)->i_bytes, (struct inode)->i_blkbits, (struct inode)->i_write_hint, (struct inode)->i_blocks, (struct inode)->i_state, (struct atomic64_t)->counter, (struct inode)->dirtied_when, (struct inode)->dirtied_time_when, (struct hlist_node)->pprev, (struct callback_head)->func, (struct inode)->i_version, (struct radix_tree_root)->gfp_mask, (struct address_space)->nrpages, (struct address_space)->nrexceptional, (struct address_space)->writeback_index, (struct address_space)->flags, (struct address_space)->gfp_mask, (struct address_space)->private_data, (struct address_space)->wb_err, (struct inode)->i_link, (struct inode)->i_dir_seq, (struct inode)->i_generation, (struct inode)->i_fsnotify_mask, (struct inode)->i_private, (struct fsnotify_group)->q_len, (struct fsnotify_group)->max_events, (struct fsnotify_group)->priority, (struct fsnotify_group)->shutdown, (struct mutex)->magic, (struct fsnotify_group)->private, (struct idr)->idr_next, ]
+SYSC_inotify_rm_watch write_list: [(struct fd)->flags, (struct atomic_t)->counter, (struct raw_spinlock)->magic, (struct raw_spinlock)->owner_cpu, (struct raw_spinlock)->owner, (struct lockdep_map)->name, (struct fsnotify_group)->q_len, (struct fsnotify_group)->max_events, (struct fsnotify_group)->priority, (struct fsnotify_group)->shutdown, (struct atomic64_t)->counter, (struct mutex)->magic, (struct fsnotify_group)->private, (struct radix_tree_root)->gfp_mask, (struct idr)->idr_next, (struct fsnotify_mark)->mask, (struct hlist_node)->pprev, (struct fsnotify_mark)->ignored_mask, (struct fsnotify_mark)->flags, (struct inotify_inode_mark)->wd, ]
+sys_dmi_modalias_show write_list: [(struct mafield)->prefix, (struct mafield)->field, ]
+sys_get_curr_temp write_list: [(struct pkg_device)->cpu, (struct pkg_device)->work_scheduled, (struct pkg_device)->tj_max, (struct pkg_device)->msr_pkg_therm_low, (struct pkg_device)->msr_pkg_therm_high, (struct atomic64_t)->counter, (struct work_struct)->func, (struct lockdep_map)->name, (struct hlist_node)->pprev, (struct timer_list)->expires, (struct timer_list)->function, (struct timer_list)->data, (struct timer_list)->flags, (struct delayed_work)->cpu, ]
+sys_get_trip_temp write_list: [(struct pkg_device)->cpu, (struct pkg_device)->work_scheduled, (struct pkg_device)->tj_max, (struct pkg_device)->msr_pkg_therm_low, (struct pkg_device)->msr_pkg_therm_high, (struct atomic64_t)->counter, (struct work_struct)->func, (struct lockdep_map)->name, (struct hlist_node)->pprev, (struct timer_list)->expires, (struct timer_list)->function, (struct timer_list)->data, (struct timer_list)->flags, (struct delayed_work)->cpu, ]
+sys_set_trip_temp write_list: [(struct pkg_device)->cpu, (struct pkg_device)->work_scheduled, (struct pkg_device)->tj_max, (struct pkg_device)->msr_pkg_therm_low, (struct pkg_device)->msr_pkg_therm_high, (struct atomic64_t)->counter, (struct work_struct)->func, (struct lockdep_map)->name, (struct hlist_node)->pprev, (struct timer_list)->expires, (struct timer_list)->function, (struct timer_list)->data, (struct timer_list)->flags, (struct delayed_work)->cpu, ]
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.implicit_dependencies.v1 b/usr/src/tools/smatch/src/smatch_data/kernel.implicit_dependencies.v1
new file mode 100644
index 0000000000..ca8860dc84
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.implicit_dependencies.v1
@@ -0,0 +1,965 @@
+// list of syscalls and the fields they write/read to.
+// generated by `gen_implicit_dependencies.sh`
+SyS_ioprio_set read_list: []
+SyS_ioprio_get read_list: []
+SYSC_ioprio_get read_list: [(struct task_struct)->io_context, (struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->real_cred, (struct task_struct)->real_cred, ]
+SYSC_ioprio_set read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->real_cred, (struct task_struct)->real_cred, ]
+compat_SyS_setsockopt read_list: []
+compat_SyS_getsockopt read_list: []
+compat_SyS_sendmsg read_list: []
+compat_SyS_sendmmsg read_list: []
+compat_SyS_recvmsg read_list: []
+compat_SyS_recv read_list: []
+compat_SyS_recvfrom read_list: []
+compat_SyS_recvmmsg read_list: []
+compat_SyS_socketcall read_list: []
+C_SYSC_socketcall read_list: []
+C_SYSC_recvmmsg read_list: []
+C_SYSC_recvfrom read_list: []
+C_SYSC_recv read_list: []
+C_SYSC_recvmsg read_list: []
+C_SYSC_sendmmsg read_list: []
+C_SYSC_sendmsg read_list: []
+C_SYSC_getsockopt read_list: [(struct proto_ops)->compat_getsockopt, ]
+C_SYSC_setsockopt read_list: [(struct proto_ops)->compat_setsockopt, ]
+SyS_socket read_list: []
+SyS_socketpair read_list: []
+SyS_bind read_list: []
+SyS_listen read_list: []
+SyS_accept4 read_list: []
+SyS_accept read_list: []
+SyS_connect read_list: []
+SyS_getsockname read_list: []
+SyS_getpeername read_list: []
+SyS_sendto read_list: []
+SyS_send read_list: []
+SyS_recvfrom read_list: []
+SyS_recv read_list: []
+SyS_setsockopt read_list: []
+SyS_getsockopt read_list: []
+SyS_shutdown read_list: []
+SyS_sendmsg read_list: []
+SyS_sendmmsg read_list: []
+SyS_recvmsg read_list: []
+SyS_recvmmsg read_list: []
+SyS_socketcall read_list: []
+SYSC_socketcall read_list: []
+SYSC_recvmmsg read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct msghdr)->msg_flags, ]
+SYSC_recvmsg read_list: []
+SYSC_sendmmsg read_list: []
+SYSC_sendmsg read_list: []
+SYSC_shutdown read_list: [(struct fd)->file, ]
+SYSC_getsockopt read_list: [(struct fd)->file, ]
+SYSC_setsockopt read_list: [(struct fd)->file, ]
+SYSC_recv read_list: []
+SYSC_recvfrom read_list: [(struct fd)->file, (struct file)->f_flags, ]
+SYSC_send read_list: []
+SYSC_sendto read_list: [(struct fd)->file, (struct file)->f_flags, ]
+SYSC_getpeername read_list: [(struct fd)->file, ]
+SYSC_getsockname read_list: [(struct fd)->file, ]
+SYSC_connect read_list: [(struct fd)->file, ]
+SYSC_accept read_list: []
+SYSC_accept4 read_list: [(struct fd)->file, ]
+SYSC_listen read_list: [(struct fd)->file, ]
+SYSC_bind read_list: [(struct fd)->file, ]
+SYSC_socketpair read_list: []
+SYSC_socket read_list: []
+SyS_bpf read_list: []
+SYSC_bpf read_list: [(struct bpf_map)->map_type, (union bpf_attr)->prog_flags, (union bpf_attr)->insn_cnt, (union bpf_attr)->kern_version, (union bpf_attr)->bpf_fd, (struct bpf_verifier_ops)->test_run, (struct fd)->file, (struct file)->f_op, ]
+sys_restart_syscall read_list: []
+SyS_rt_sigprocmask read_list: []
+compat_SyS_rt_sigprocmask read_list: []
+SyS_rt_sigpending read_list: []
+compat_SyS_rt_sigpending read_list: []
+SyS_rt_sigtimedwait read_list: []
+compat_SyS_rt_sigtimedwait read_list: []
+SyS_kill read_list: []
+SyS_tgkill read_list: []
+SyS_tkill read_list: []
+SyS_rt_sigqueueinfo read_list: []
+compat_SyS_rt_sigqueueinfo read_list: []
+SyS_rt_tgsigqueueinfo read_list: []
+compat_SyS_rt_tgsigqueueinfo read_list: []
+SyS_sigaltstack read_list: []
+compat_SyS_sigaltstack read_list: []
+SyS_sigpending read_list: []
+compat_SyS_sigpending read_list: []
+SyS_sigprocmask read_list: []
+SyS_rt_sigaction read_list: []
+compat_SyS_rt_sigaction read_list: []
+compat_SyS_sigaction read_list: []
+sys_sgetmask read_list: []
+SyS_ssetmask read_list: []
+SyS_signal read_list: []
+sys_pause read_list: []
+SyS_rt_sigsuspend read_list: []
+compat_SyS_rt_sigsuspend read_list: []
+SyS_sigsuspend read_list: []
+SYSC_sigsuspend read_list: []
+C_SYSC_rt_sigsuspend read_list: []
+SYSC_rt_sigsuspend read_list: []
+SYSC_signal read_list: []
+SYSC_ssetmask read_list: []
+C_SYSC_sigaction read_list: []
+C_SYSC_rt_sigaction read_list: []
+SYSC_rt_sigaction read_list: []
+SYSC_sigprocmask read_list: []
+C_SYSC_sigpending read_list: []
+SYSC_sigpending read_list: []
+C_SYSC_sigaltstack read_list: []
+SYSC_sigaltstack read_list: []
+C_SYSC_rt_tgsigqueueinfo read_list: [(struct siginfo)->si_code, ]
+SYSC_rt_tgsigqueueinfo read_list: [(struct siginfo)->si_code, ]
+C_SYSC_rt_sigqueueinfo read_list: [(struct siginfo)->si_code, ]
+SYSC_rt_sigqueueinfo read_list: [(struct siginfo)->si_code, ]
+SYSC_tkill read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_tgkill read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_kill read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+C_SYSC_rt_sigtimedwait read_list: []
+SYSC_rt_sigtimedwait read_list: [(struct siginfo)->si_code, (struct siginfo)->si_signo, ]
+C_SYSC_rt_sigpending read_list: []
+SYSC_rt_sigpending read_list: []
+C_SYSC_rt_sigprocmask read_list: []
+SYSC_rt_sigprocmask read_list: []
+SyS_delete_module read_list: []
+SyS_init_module read_list: []
+SyS_finit_module read_list: []
+SYSC_finit_module read_list: []
+SYSC_init_module read_list: [(struct load_info)->len, (struct load_info)->hdr, ]
+SYSC_delete_module read_list: [(struct module)->state, (struct module)->init, (struct module)->exit, ]
+SyS_kexec_load read_list: []
+compat_SyS_kexec_load read_list: []
+C_SYSC_kexec_load read_list: []
+SYSC_kexec_load read_list: []
+SyS_getgroups read_list: []
+SyS_setgroups read_list: []
+SYSC_setgroups read_list: []
+SYSC_getgroups read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SyS_ptrace read_list: []
+compat_SyS_ptrace read_list: []
+C_SYSC_ptrace read_list: [(struct task_struct)->ptrace, (struct task_struct)->flags, (struct task_struct)->exit_state, (struct task_struct)->state, (struct task_struct)->parent, ]
+SYSC_ptrace read_list: [(struct task_struct)->ptrace, (struct task_struct)->flags, (struct task_struct)->exit_state, (struct task_struct)->state, (struct task_struct)->parent, ]
+sys_ni_syscall read_list: []
+SyS_reboot read_list: []
+SYSC_reboot read_list: []
+SyS_set_tid_address read_list: []
+sys_fork read_list: []
+sys_vfork read_list: []
+SyS_clone read_list: []
+SyS_unshare read_list: []
+SYSC_unshare read_list: [(struct fs_struct)->users, ]
+SYSC_clone read_list: []
+SYSC_set_tid_address read_list: []
+SyS_seccomp read_list: []
+SYSC_seccomp read_list: []
+compat_SyS_sigprocmask read_list: []
+compat_SyS_sched_setaffinity read_list: []
+compat_SyS_sched_getaffinity read_list: []
+compat_SyS_move_pages read_list: []
+compat_SyS_migrate_pages read_list: []
+compat_SyS_sched_rr_get_interval read_list: []
+C_SYSC_sched_rr_get_interval read_list: []
+C_SYSC_migrate_pages read_list: []
+C_SYSC_move_pages read_list: []
+C_SYSC_sched_getaffinity read_list: []
+C_SYSC_sched_setaffinity read_list: []
+C_SYSC_sigprocmask read_list: []
+SyS_perf_event_open read_list: []
+SYSC_perf_event_open read_list: [(struct perf_event_attr)->__reserved_1, (struct perf_event_attr)->sample_type, (struct perf_event_attr)->read_format, (struct perf_event_attr)->exclude_kernel, (struct perf_event_attr)->exclude_user, (struct perf_event_attr)->exclude_hv, (struct perf_event_attr)->sample_stack_user, (struct perf_event_attr)->sample_stack_user, (struct perf_event_attr)->namespaces, (struct perf_event_attr)->freq, (struct perf_event_attr)->sample_freq, (struct perf_event_attr)->sample_period, (struct perf_event_attr)->sample_max_stack, (struct fd)->file, (struct file)->f_op, (struct perf_event_attr)->inherit, (struct perf_event)->addr_filters_offs, (struct perf_event)->parent, (struct perf_event)->destroy, (struct perf_event)->ns, (struct pmu)->capabilities, (struct perf_event_attr)->use_clockid, (struct pmu)->task_ctx_nr, (struct perf_event)->event_caps, (struct perf_event)->group_caps, (struct perf_event)->attach_state, (struct perf_event_context)->task_ctx_data, (struct task_struct)->flags, (struct perf_event)->group_leader, (struct perf_event)->clock, (struct perf_event)->cpu, (struct perf_event_context)->task, (struct perf_event)->ctx, (struct perf_event_attr)->exclusive, (struct perf_event_attr)->pinned, (struct perf_event)->pmu, (struct perf_event)->read_size, (struct perf_event)->header_size, (struct perf_event)->id_header_size, (struct perf_cpu_context)->online, (struct perf_event_context)->parent_ctx, (struct perf_event_attr)->disabled, (struct fd)->flags, ]
+SyS_exit read_list: []
+SyS_exit_group read_list: []
+SyS_waitid read_list: []
+SyS_wait4 read_list: []
+SyS_waitpid read_list: []
+compat_SyS_wait4 read_list: []
+compat_SyS_waitid read_list: []
+C_SYSC_waitid read_list: []
+C_SYSC_wait4 read_list: []
+SYSC_waitpid read_list: []
+SYSC_wait4 read_list: []
+SYSC_waitid read_list: []
+SYSC_exit_group read_list: []
+SYSC_exit read_list: []
+SyS_set_robust_list read_list: []
+SyS_get_robust_list read_list: []
+SyS_futex read_list: []
+SYSC_futex read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_get_robust_list read_list: []
+SYSC_set_robust_list read_list: []
+SyS_setpriority read_list: []
+SyS_getpriority read_list: []
+SyS_setregid read_list: []
+SyS_setgid read_list: []
+SyS_setreuid read_list: []
+SyS_setuid read_list: []
+SyS_setresuid read_list: []
+SyS_getresuid read_list: []
+SyS_setresgid read_list: []
+SyS_getresgid read_list: []
+SyS_setfsuid read_list: []
+SyS_setfsgid read_list: []
+sys_getpid read_list: []
+sys_gettid read_list: []
+sys_getppid read_list: [(struct task_struct)->real_parent, (struct task_struct)->real_parent, ]
+sys_getuid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+sys_geteuid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+sys_getgid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+sys_getegid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SyS_times read_list: []
+compat_SyS_times read_list: []
+SyS_setpgid read_list: []
+SyS_getpgid read_list: []
+sys_getpgrp read_list: []
+SyS_getsid read_list: []
+sys_setsid read_list: [(struct signal_struct)->leader, ]
+SyS_newuname read_list: []
+SyS_uname read_list: []
+SyS_olduname read_list: []
+SyS_sethostname read_list: []
+SyS_gethostname read_list: []
+SyS_setdomainname read_list: []
+SyS_getrlimit read_list: []
+compat_SyS_setrlimit read_list: []
+compat_SyS_getrlimit read_list: []
+SyS_old_getrlimit read_list: []
+compat_SyS_old_getrlimit read_list: []
+SyS_prlimit64 read_list: []
+SyS_setrlimit read_list: []
+SyS_getrusage read_list: []
+compat_SyS_getrusage read_list: []
+SyS_umask read_list: []
+SyS_prctl read_list: []
+SyS_getcpu read_list: []
+SyS_sysinfo read_list: []
+compat_SyS_sysinfo read_list: []
+C_SYSC_sysinfo read_list: [(struct timespec)->tv_nsec, (struct sysinfo)->totalram, (struct sysinfo)->totalswap, (struct sysinfo)->mem_unit, ]
+SYSC_sysinfo read_list: [(struct timespec)->tv_nsec, (struct sysinfo)->totalram, (struct sysinfo)->totalswap, ]
+SYSC_getcpu read_list: []
+SYSC_prctl read_list: [(struct task_struct)->timer_slack_ns, (struct task_struct)->flags, (struct task_struct)->personality, ]
+SYSC_umask read_list: []
+C_SYSC_getrusage read_list: [(struct signal_struct)->maxrss, ]
+SYSC_getrusage read_list: [(struct signal_struct)->maxrss, ]
+SYSC_setrlimit read_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, (struct task_struct)->sighand, ]
+SYSC_prlimit64 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->real_cred, (struct task_struct)->real_cred, (struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, (struct task_struct)->sighand, ]
+C_SYSC_old_getrlimit read_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+SYSC_old_getrlimit read_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+C_SYSC_getrlimit read_list: [(struct rlimit)->rlim_cur, (struct rlimit)->rlim_max, ]
+C_SYSC_setrlimit read_list: [(struct compat_rlimit)->rlim_cur, (struct compat_rlimit)->rlim_max, ]
+SYSC_getrlimit read_list: []
+SYSC_setdomainname read_list: []
+SYSC_gethostname read_list: []
+SYSC_sethostname read_list: []
+SYSC_olduname read_list: [(struct task_struct)->personality, ]
+SYSC_uname read_list: [(struct task_struct)->personality, ]
+SYSC_newuname read_list: [(struct task_struct)->personality, ]
+SYSC_getsid read_list: []
+SYSC_getpgid read_list: []
+SYSC_setpgid read_list: [(struct task_struct)->exit_signal, (struct task_struct)->signal, (struct task_struct)->flags, (struct signal_struct)->leader, ]
+C_SYSC_times read_list: []
+SYSC_times read_list: []
+SYSC_setfsgid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setfsuid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_getresgid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setresgid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_getresuid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setresuid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setuid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setreuid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setgid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setregid read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_getpriority read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->real_cred, (struct task_struct)->real_cred, ]
+SYSC_setpriority read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->real_cred, (struct task_struct)->real_cred, ]
+SyS_setns read_list: []
+SYSC_setns read_list: [(struct proc_ns_operations)->type, (struct nsproxy)->pid_ns_for_children, (struct nsproxy)->ipc_ns, (struct nsproxy)->uts_ns, (struct nsproxy)->mnt_ns, ]
+SyS_timer_create read_list: []
+compat_SyS_timer_create read_list: []
+SyS_timer_gettime read_list: []
+compat_SyS_timer_gettime read_list: []
+SyS_timer_getoverrun read_list: []
+SyS_timer_settime read_list: []
+compat_SyS_timer_settime read_list: []
+SyS_timer_delete read_list: []
+SyS_clock_settime read_list: []
+SyS_clock_gettime read_list: []
+SyS_clock_adjtime read_list: []
+SyS_clock_getres read_list: []
+compat_SyS_clock_settime read_list: []
+compat_SyS_clock_gettime read_list: []
+compat_SyS_clock_adjtime read_list: []
+compat_SyS_clock_getres read_list: []
+SyS_clock_nanosleep read_list: []
+compat_SyS_clock_nanosleep read_list: []
+C_SYSC_clock_nanosleep read_list: [(struct k_clock)->nsleep, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_clock_nanosleep read_list: [(struct k_clock)->nsleep, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_clock_getres read_list: []
+C_SYSC_clock_adjtime read_list: [(struct k_clock)->clock_adj, ]
+C_SYSC_clock_gettime read_list: []
+C_SYSC_clock_settime read_list: [(struct k_clock)->clock_set, ]
+SYSC_clock_getres read_list: []
+SYSC_clock_adjtime read_list: [(struct k_clock)->clock_adj, ]
+SYSC_clock_gettime read_list: []
+SYSC_clock_settime read_list: [(struct k_clock)->clock_set, ]
+SYSC_timer_delete read_list: [(struct k_itimer)->it_signal, (struct task_struct)->signal, (struct k_clock)->timer_del, ]
+C_SYSC_timer_settime read_list: [(struct k_clock)->timer_set, ]
+SYSC_timer_settime read_list: [(struct k_clock)->timer_set, ]
+SYSC_timer_getoverrun read_list: [(struct k_itimer)->it_signal, (struct task_struct)->signal, ]
+C_SYSC_timer_gettime read_list: [(struct k_clock)->timer_get, ]
+SYSC_timer_gettime read_list: [(struct k_clock)->timer_get, ]
+C_SYSC_timer_create read_list: [(struct k_clock)->timer_create, (struct k_itimer)->it_pid, ]
+SYSC_timer_create read_list: [(struct k_clock)->timer_create, (struct k_itimer)->it_pid, ]
+SyS_getitimer read_list: []
+compat_SyS_getitimer read_list: []
+SyS_alarm read_list: []
+SyS_setitimer read_list: []
+compat_SyS_setitimer read_list: []
+C_SYSC_setitimer read_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, ]
+SYSC_setitimer read_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, ]
+SYSC_alarm read_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, ]
+C_SYSC_getitimer read_list: []
+SYSC_getitimer read_list: []
+SyS_nanosleep read_list: []
+compat_SyS_nanosleep read_list: []
+C_SYSC_nanosleep read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_nanosleep read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SyS_time read_list: []
+SyS_stime read_list: []
+compat_SyS_time read_list: []
+compat_SyS_stime read_list: []
+SyS_gettimeofday read_list: []
+SyS_settimeofday read_list: []
+compat_SyS_gettimeofday read_list: []
+compat_SyS_settimeofday read_list: []
+SyS_adjtimex read_list: []
+compat_SyS_adjtimex read_list: []
+C_SYSC_adjtimex read_list: []
+SYSC_adjtimex read_list: []
+C_SYSC_settimeofday read_list: [(struct timezone)->tz_minuteswest, ]
+C_SYSC_gettimeofday read_list: []
+SYSC_settimeofday read_list: [(struct timeval)->tv_sec, (struct timeval)->tv_usec, (struct timezone)->tz_minuteswest, ]
+SYSC_gettimeofday read_list: []
+C_SYSC_stime read_list: []
+C_SYSC_time read_list: []
+SYSC_stime read_list: []
+SYSC_time read_list: []
+SyS_capget read_list: []
+SyS_capset read_list: []
+SYSC_capset read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_capget read_list: []
+SyS_syslog read_list: []
+SYSC_syslog read_list: []
+compat_SyS_set_robust_list read_list: []
+compat_SyS_get_robust_list read_list: []
+compat_SyS_futex read_list: []
+C_SYSC_futex read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_get_robust_list read_list: []
+C_SYSC_set_robust_list read_list: []
+SyS_sysctl read_list: []
+compat_SyS_sysctl read_list: []
+C_SYSC_sysctl read_list: [(struct compat_sysctl_args)->oldval, (struct compat_sysctl_args)->oldlenp, ]
+SYSC_sysctl read_list: [(struct __sysctl_args)->oldval, (struct __sysctl_args)->oldlenp, ]
+SyS_membarrier read_list: []
+SyS_personality read_list: []
+SYSC_personality read_list: []
+SyS_nice read_list: []
+SyS_sched_setscheduler read_list: []
+SyS_sched_setparam read_list: []
+SyS_sched_setattr read_list: []
+SyS_sched_getscheduler read_list: []
+SyS_sched_getparam read_list: []
+SyS_sched_getattr read_list: []
+SyS_sched_setaffinity read_list: []
+SyS_sched_getaffinity read_list: []
+sys_sched_yield read_list: []
+SyS_sched_get_priority_max read_list: []
+SyS_sched_get_priority_min read_list: []
+SyS_sched_rr_get_interval read_list: []
+SYSC_sched_rr_get_interval read_list: [(struct sched_class)->get_rr_interval, ]
+SYSC_sched_get_priority_min read_list: []
+SYSC_sched_get_priority_max read_list: []
+SYSC_sched_getaffinity read_list: []
+SYSC_sched_setaffinity read_list: [(struct task_struct)->flags, (struct task_struct)->real_cred, (struct task_struct)->real_cred, ]
+SYSC_sched_getattr read_list: [(struct task_struct)->sched_reset_on_fork, ]
+SYSC_sched_getparam read_list: []
+SYSC_sched_getscheduler read_list: [(struct task_struct)->sched_reset_on_fork, ]
+SYSC_sched_setattr read_list: [(struct sched_attr)->sched_policy, ]
+SYSC_sched_setparam read_list: []
+SYSC_sched_setscheduler read_list: []
+SYSC_nice read_list: []
+SyS_acct read_list: []
+SYSC_acct read_list: [(struct file)->f_mode, ]
+SyS_chown16 read_list: []
+SyS_lchown16 read_list: []
+SyS_fchown16 read_list: []
+SyS_setregid16 read_list: []
+SyS_setgid16 read_list: []
+SyS_setreuid16 read_list: []
+SyS_setuid16 read_list: []
+SyS_setresuid16 read_list: []
+SyS_getresuid16 read_list: []
+SyS_setresgid16 read_list: []
+SyS_getresgid16 read_list: []
+SyS_setfsuid16 read_list: []
+SyS_setfsgid16 read_list: []
+SyS_getgroups16 read_list: []
+SyS_setgroups16 read_list: []
+sys_getuid16 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->cred, ]
+sys_geteuid16 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->cred, ]
+sys_getgid16 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->cred, ]
+sys_getegid16 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setgroups16 read_list: [(struct group_info)->ngroups, ]
+SYSC_getgroups16 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct group_info)->ngroups, ]
+SYSC_setfsgid16 read_list: []
+SYSC_setfsuid16 read_list: []
+SYSC_getresgid16 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setresgid16 read_list: []
+SYSC_getresuid16 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_setresuid16 read_list: []
+SYSC_setuid16 read_list: []
+SYSC_setreuid16 read_list: []
+SYSC_setgid16 read_list: []
+SYSC_setregid16 read_list: []
+SYSC_fchown16 read_list: []
+SYSC_lchown16 read_list: []
+SYSC_chown16 read_list: []
+SyS_mremap read_list: []
+SYSC_mremap read_list: [(struct task_struct)->personality, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct vm_area_struct)->vm_next, (struct mm_struct)->map_count, (struct vm_area_struct)->vm_ops, (struct vm_operations_struct)->mremap, ]
+SyS_memfd_create read_list: []
+SYSC_memfd_create read_list: []
+SyS_brk read_list: []
+SyS_mmap_pgoff read_list: []
+SyS_munmap read_list: []
+SyS_remap_file_pages read_list: []
+SYSC_remap_file_pages read_list: [(struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, (struct vm_area_struct)->vm_file, ]
+SYSC_munmap read_list: []
+SYSC_mmap_pgoff read_list: [(struct file)->f_op, ]
+SYSC_brk read_list: [(struct mm_struct)->brk, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_start, (struct mm_struct)->def_flags, ]
+SyS_mlock read_list: []
+SyS_mlock2 read_list: []
+SyS_munlock read_list: []
+SyS_mlockall read_list: []
+sys_munlockall read_list: []
+SYSC_mlockall read_list: [(struct mm_struct)->total_vm, (struct task_struct)->personality, ]
+SYSC_munlock read_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, ]
+SYSC_mlock2 read_list: []
+SYSC_mlock read_list: []
+SyS_move_pages read_list: []
+SYSC_move_pages read_list: []
+SyS_readahead read_list: []
+SYSC_readahead read_list: [(struct fd)->file, (struct file)->f_mode, (struct address_space)->a_ops, (struct fd)->flags, ]
+SyS_swapoff read_list: []
+SyS_swapon read_list: []
+SYSC_swapon read_list: [(struct swap_info_struct)->flags, (struct inode)->i_flags, (struct address_space_operations)->readpage, (struct swap_info_struct)->bdev, (struct swap_info_struct)->percpu_cluster, ]
+SYSC_swapoff read_list: [(struct task_struct)->mm, (struct swap_info_struct)->flags, (struct file)->f_mapping, (struct swap_info_struct)->prio, (struct page)->private, (struct swp_entry_t)->val, (struct swap_info_struct)->inuse_pages, ]
+SyS_mprotect read_list: []
+SyS_pkey_mprotect read_list: []
+SyS_pkey_alloc read_list: []
+SyS_pkey_free read_list: []
+SYSC_pkey_free read_list: []
+SYSC_pkey_alloc read_list: [(struct mm_context_t)->pkey_allocation_map, ]
+SYSC_pkey_mprotect read_list: [(struct task_struct)->personality, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_end, ]
+SYSC_mprotect read_list: [(struct task_struct)->personality, (struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_flags, (struct vm_area_struct)->vm_end, ]
+SyS_mincore read_list: []
+SYSC_mincore read_list: [(struct vm_area_struct)->vm_start, ]
+SyS_mbind read_list: []
+SyS_set_mempolicy read_list: []
+SyS_migrate_pages read_list: []
+SyS_get_mempolicy read_list: []
+compat_SyS_get_mempolicy read_list: []
+compat_SyS_set_mempolicy read_list: []
+compat_SyS_mbind read_list: []
+C_SYSC_mbind read_list: []
+C_SYSC_set_mempolicy read_list: []
+C_SYSC_get_mempolicy read_list: []
+SYSC_get_mempolicy read_list: [(struct vm_area_struct)->vm_ops, (struct vm_operations_struct)->get_policy, (struct task_struct)->mempolicy, (struct mempolicy)->mode, ]
+SYSC_migrate_pages read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->real_cred, (struct task_struct)->real_cred, ]
+SYSC_set_mempolicy read_list: [(struct mempolicy)->mode, ]
+SYSC_mbind read_list: []
+SyS_msync read_list: []
+SyS_fadvise64_64 read_list: []
+SyS_fadvise64 read_list: []
+SyS_process_vm_readv read_list: []
+SyS_process_vm_writev read_list: []
+compat_SyS_process_vm_readv read_list: []
+compat_SyS_process_vm_writev read_list: []
+C_SYSC_process_vm_writev read_list: []
+C_SYSC_process_vm_readv read_list: []
+SYSC_process_vm_writev read_list: []
+SYSC_process_vm_readv read_list: []
+SyS_madvise read_list: []
+SYSC_madvise read_list: [(struct vm_area_struct)->vm_start, (struct vm_area_struct)->vm_end, ]
+sys_rt_sigreturn read_list: [(struct thread_struct)->uaccess_err, ]
+SyS_set_thread_area read_list: []
+SyS_get_thread_area read_list: []
+SYSC_get_thread_area read_list: []
+SYSC_set_thread_area read_list: [(struct thread_struct)->fsindex, (struct thread_struct)->gsindex, ]
+sys_modify_ldt read_list: [(struct mm_context_t)->ldt, (struct user_desc)->entry_number, (struct user_desc)->contents, (struct user_desc)->seg_not_present, (struct user_desc)->base_addr, (struct user_desc)->limit, (struct user_desc)->read_exec_only, (struct user_desc)->seg_32bit, (struct user_desc)->limit_in_pages, (struct user_desc)->useable, ]
+SyS_mmap read_list: []
+SYSC_mmap read_list: []
+sys_ioperm read_list: [(struct thread_struct)->io_bitmap_ptr, ]
+SyS_iopl read_list: []
+SyS_arch_prctl read_list: []
+compat_SyS_arch_prctl read_list: []
+C_SYSC_arch_prctl read_list: []
+SYSC_arch_prctl read_list: []
+compat_SyS_keyctl read_list: []
+C_SYSC_keyctl read_list: []
+SyS_add_key read_list: []
+SyS_request_key read_list: []
+SyS_keyctl read_list: []
+SYSC_keyctl read_list: [(struct key_type)->read, (struct key_user)->qnkeys, (struct key_user)->qnbytes, (struct key)->quotalen, (struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->cred, (struct task_struct)->pid, (struct task_struct)->mm, (struct task_struct)->cred, (struct task_struct)->real_cred, (struct task_struct)->real_cred, (struct cred)->session_keyring, (struct task_struct)->cred, (struct key)->serial, ]
+SYSC_request_key read_list: []
+SYSC_add_key read_list: []
+SyS_msgget read_list: []
+SyS_msgctl read_list: []
+SyS_msgsnd read_list: []
+SyS_msgrcv read_list: []
+SYSC_msgrcv read_list: [(struct msg_msg)->m_ts, ]
+SYSC_msgsnd read_list: [(struct ipc_namespace)->msg_ctlmax, ]
+SYSC_msgctl read_list: [(struct msqid64_ds)->msg_qbytes, (struct ipc_namespace)->msg_ctlmnb, ]
+SYSC_msgget read_list: []
+SyS_mq_open read_list: []
+SyS_mq_unlink read_list: []
+SyS_mq_timedsend read_list: []
+SyS_mq_timedreceive read_list: []
+SyS_mq_notify read_list: []
+SyS_mq_getsetattr read_list: []
+compat_SyS_mq_open read_list: []
+compat_SyS_mq_timedsend read_list: []
+compat_SyS_mq_timedreceive read_list: []
+compat_SyS_mq_notify read_list: []
+compat_SyS_mq_getsetattr read_list: []
+C_SYSC_mq_getsetattr read_list: [(struct mq_attr)->mq_flags, (struct fd)->file, (struct file)->f_op, ]
+C_SYSC_mq_notify read_list: [(struct sigevent)->sigev_notify, (struct fd)->file, (struct file)->f_op, (struct mqueue_inode_info)->notify_owner, ]
+C_SYSC_mq_timedreceive read_list: [(struct fd)->file, (struct file)->f_op, (struct file)->f_mode, (struct mq_attr)->mq_msgsize, (struct mqueue_inode_info)->node_cache, (struct mq_attr)->mq_curmsgs, (struct file)->f_flags, ]
+C_SYSC_mq_timedsend read_list: [(struct fd)->file, (struct file)->f_op, (struct file)->f_mode, (struct mq_attr)->mq_msgsize, (struct mqueue_inode_info)->node_cache, (struct mq_attr)->mq_curmsgs, (struct mq_attr)->mq_maxmsg, (struct file)->f_flags, ]
+C_SYSC_mq_open read_list: []
+SYSC_mq_getsetattr read_list: [(struct mq_attr)->mq_flags, (struct fd)->file, (struct file)->f_op, ]
+SYSC_mq_notify read_list: [(struct sigevent)->sigev_notify, (struct fd)->file, (struct file)->f_op, (struct mqueue_inode_info)->notify_owner, ]
+SYSC_mq_timedreceive read_list: [(struct fd)->file, (struct file)->f_op, (struct file)->f_mode, (struct mq_attr)->mq_msgsize, (struct mqueue_inode_info)->node_cache, (struct mq_attr)->mq_curmsgs, (struct file)->f_flags, ]
+SYSC_mq_timedsend read_list: [(struct fd)->file, (struct file)->f_op, (struct file)->f_mode, (struct mq_attr)->mq_msgsize, (struct mqueue_inode_info)->node_cache, (struct mq_attr)->mq_curmsgs, (struct mq_attr)->mq_maxmsg, (struct file)->f_flags, ]
+SYSC_mq_unlink read_list: []
+SYSC_mq_open read_list: []
+compat_SyS_ipc read_list: []
+compat_SyS_semctl read_list: []
+compat_SyS_msgsnd read_list: []
+compat_SyS_msgrcv read_list: []
+compat_SyS_msgctl read_list: []
+compat_SyS_shmat read_list: []
+compat_SyS_shmctl read_list: []
+compat_SyS_semtimedop read_list: []
+C_SYSC_semtimedop read_list: []
+C_SYSC_shmctl read_list: [(struct shminfo64)->shmmax, ]
+C_SYSC_shmat read_list: []
+C_SYSC_msgctl read_list: []
+C_SYSC_msgrcv read_list: []
+C_SYSC_msgsnd read_list: []
+C_SYSC_semctl read_list: []
+C_SYSC_ipc read_list: []
+SyS_semget read_list: []
+SyS_semctl read_list: []
+SyS_semtimedop read_list: []
+SyS_semop read_list: []
+SYSC_semop read_list: []
+SYSC_semtimedop read_list: [(struct timespec)->tv_sec, (struct timespec)->tv_nsec, (struct sembuf)->sem_num, (struct sembuf)->sem_flg, (struct sembuf)->sem_op, (struct sem_array)->sem_nsems, (struct sem_array)->use_global_lock, (struct kern_ipc_perm)->deleted, (struct sem_undo)->semid, (struct sem_queue)->dupsop, (struct sem_array)->complex_count, (struct sem_queue)->nsops, ]
+SYSC_semctl read_list: [(struct sem_array)->sem_nsems, ]
+SYSC_semget read_list: []
+SyS_shmget read_list: []
+SyS_shmctl read_list: []
+SyS_shmat read_list: []
+SyS_shmdt read_list: []
+SYSC_shmdt read_list: [(struct vm_area_struct)->vm_ops, (struct vm_area_struct)->vm_pgoff, (struct vm_area_struct)->vm_file, ]
+SYSC_shmat read_list: []
+SYSC_shmctl read_list: [(struct kern_ipc_perm)->deleted, (struct task_struct)->cred, (struct task_struct)->cred, (struct file)->f_op, (struct task_struct)->cred, (struct kern_ipc_perm)->mode, ]
+SYSC_shmget read_list: []
+SyS_quotactl read_list: []
+SYSC_quotactl read_list: [(struct super_block)->s_qcop, (struct super_block)->s_quota_types, (struct quotactl_ops)->quota_sync, (struct super_block)->s_flags, ]
+SyS_vmsplice read_list: []
+compat_SyS_vmsplice read_list: []
+SyS_splice read_list: []
+SyS_tee read_list: []
+SYSC_tee read_list: [(struct fd)->file, (struct file)->f_mode, (struct fd)->flags, ]
+SYSC_splice read_list: [(struct fd)->file, (struct file)->f_mode, (struct file)->f_flags, (struct fd)->flags, ]
+C_SYSC_vmsplice read_list: []
+SYSC_vmsplice read_list: [(struct fd)->file, (struct file)->f_mode, (struct splice_desc)->total_len, (struct fd)->flags, ]
+SyS_io_setup read_list: []
+compat_SyS_io_setup read_list: []
+SyS_io_destroy read_list: []
+SyS_io_submit read_list: []
+compat_SyS_io_submit read_list: []
+SyS_io_cancel read_list: []
+SyS_io_getevents read_list: []
+compat_SyS_io_getevents read_list: []
+C_SYSC_io_getevents read_list: []
+SYSC_io_getevents read_list: [(struct mm_struct)->ioctx_table, (struct mm_struct)->ioctx_table, (struct kioctx_table)->nr, (struct kioctx)->user_id, (struct hrtimer_sleeper)->task, ]
+SYSC_io_cancel read_list: [(struct mm_struct)->ioctx_table, (struct mm_struct)->ioctx_table, (struct kioctx_table)->nr, (struct kioctx)->user_id, (struct aio_kiocb)->ki_user_iocb, ]
+C_SYSC_io_submit read_list: []
+SYSC_io_submit read_list: []
+SYSC_io_destroy read_list: [(struct mm_struct)->ioctx_table, (struct mm_struct)->ioctx_table, (struct kioctx_table)->nr, (struct kioctx)->user_id, (struct kioctx)->mmap_size, ]
+C_SYSC_io_setup read_list: [(struct kioctx)->cpu, (struct kioctx)->req_batch, (struct kioctx)->mmap_size, ]
+SYSC_io_setup read_list: [(struct kioctx)->cpu, (struct kioctx)->req_batch, (struct kioctx)->mmap_size, ]
+SyS_name_to_handle_at read_list: []
+SyS_open_by_handle_at read_list: []
+compat_SyS_open_by_handle_at read_list: []
+C_SYSC_open_by_handle_at read_list: []
+SYSC_open_by_handle_at read_list: []
+SYSC_name_to_handle_at read_list: [(struct super_block)->s_export_op, (struct export_operations)->fh_to_dentry, (struct file_handle)->handle_bytes, ]
+SyS_ioctl read_list: []
+SYSC_ioctl read_list: [(struct fd)->file, (struct fd)->flags, ]
+SyS_sysfs read_list: []
+SYSC_sysfs read_list: []
+SyS_signalfd4 read_list: []
+SyS_signalfd read_list: []
+compat_SyS_signalfd4 read_list: []
+compat_SyS_signalfd read_list: []
+C_SYSC_signalfd read_list: []
+C_SYSC_signalfd4 read_list: []
+SYSC_signalfd read_list: []
+SYSC_signalfd4 read_list: [(struct fd)->file, (struct file)->f_op, (struct fd)->flags, ]
+SyS_pipe2 read_list: []
+SyS_pipe read_list: []
+SYSC_pipe read_list: []
+SYSC_pipe2 read_list: []
+SyS_getcwd read_list: []
+SYSC_getcwd read_list: [(struct dentry)->d_parent, (struct path)->dentry, (struct path)->mnt, (struct vfsmount)->mnt_root, ]
+SyS_stat read_list: []
+SyS_lstat read_list: []
+SyS_fstat read_list: []
+SyS_newstat read_list: []
+SyS_newlstat read_list: []
+SyS_newfstatat read_list: []
+SyS_newfstat read_list: []
+SyS_readlinkat read_list: []
+SyS_readlink read_list: []
+SyS_statx read_list: []
+compat_SyS_newstat read_list: []
+compat_SyS_newlstat read_list: []
+compat_SyS_newfstatat read_list: []
+compat_SyS_newfstat read_list: []
+C_SYSC_newfstat read_list: [(struct compat_stat)->st_ino, (struct kstat)->ino, (struct compat_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->size, ]
+C_SYSC_newfstatat read_list: [(struct compat_stat)->st_ino, (struct kstat)->ino, (struct compat_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->size, ]
+C_SYSC_newlstat read_list: [(struct compat_stat)->st_ino, (struct kstat)->ino, (struct compat_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->size, ]
+C_SYSC_newstat read_list: [(struct compat_stat)->st_ino, (struct kstat)->ino, (struct compat_stat)->st_nlink, (struct kstat)->nlink, (struct kstat)->size, ]
+SYSC_statx read_list: []
+SYSC_readlink read_list: []
+SYSC_readlinkat read_list: [(struct inode_operations)->readlink, ]
+SYSC_newfstat read_list: [(struct stat)->st_ino, (struct kstat)->ino, (struct stat)->st_nlink, (struct kstat)->nlink, ]
+SYSC_newfstatat read_list: [(struct stat)->st_ino, (struct kstat)->ino, (struct stat)->st_nlink, (struct kstat)->nlink, ]
+SYSC_newlstat read_list: [(struct stat)->st_ino, (struct kstat)->ino, (struct stat)->st_nlink, (struct kstat)->nlink, ]
+SYSC_newstat read_list: [(struct stat)->st_ino, (struct kstat)->ino, (struct stat)->st_nlink, (struct kstat)->nlink, ]
+SYSC_fstat read_list: [(struct __old_kernel_stat)->st_ino, (struct kstat)->ino, (struct __old_kernel_stat)->st_nlink, (struct kstat)->nlink, ]
+SYSC_lstat read_list: [(struct __old_kernel_stat)->st_ino, (struct kstat)->ino, (struct __old_kernel_stat)->st_nlink, (struct kstat)->nlink, ]
+SYSC_stat read_list: [(struct __old_kernel_stat)->st_ino, (struct kstat)->ino, (struct __old_kernel_stat)->st_nlink, (struct kstat)->nlink, ]
+SyS_old_readdir read_list: []
+SyS_getdents read_list: []
+SyS_getdents64 read_list: []
+compat_SyS_old_readdir read_list: []
+compat_SyS_getdents read_list: []
+C_SYSC_getdents read_list: [(struct fd)->file, (struct fd)->flags, ]
+C_SYSC_old_readdir read_list: [(struct fd)->file, (struct compat_readdir_callback)->result, (struct fd)->flags, ]
+SYSC_getdents64 read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_getdents read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_old_readdir read_list: [(struct fd)->file, (struct readdir_callback)->result, (struct fd)->flags, ]
+SyS_dup3 read_list: []
+SyS_dup2 read_list: []
+SyS_dup read_list: []
+SYSC_dup read_list: []
+SYSC_dup2 read_list: []
+SYSC_dup3 read_list: [(struct files_struct)->fdt, (struct files_struct)->fdt, (struct fdtable)->max_fds, (struct files_struct)->resize_in_progress, (struct files_struct)->fdt, ]
+SyS_bdflush read_list: []
+SYSC_bdflush read_list: []
+SyS_setxattr read_list: []
+SyS_lsetxattr read_list: []
+SyS_fsetxattr read_list: []
+SyS_getxattr read_list: []
+SyS_lgetxattr read_list: []
+SyS_fgetxattr read_list: []
+SyS_listxattr read_list: []
+SyS_llistxattr read_list: []
+SyS_flistxattr read_list: []
+SyS_removexattr read_list: []
+SyS_lremovexattr read_list: []
+SyS_fremovexattr read_list: []
+SYSC_fremovexattr read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_lremovexattr read_list: []
+SYSC_removexattr read_list: []
+SYSC_flistxattr read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_llistxattr read_list: []
+SYSC_listxattr read_list: []
+SYSC_fgetxattr read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_lgetxattr read_list: []
+SYSC_getxattr read_list: []
+SYSC_fsetxattr read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_lsetxattr read_list: []
+SYSC_setxattr read_list: []
+SyS_uselib read_list: []
+SyS_execve read_list: []
+SyS_execveat read_list: []
+compat_SyS_execve read_list: []
+compat_SyS_execveat read_list: []
+C_SYSC_execveat read_list: []
+C_SYSC_execve read_list: []
+SYSC_execveat read_list: []
+SYSC_execve read_list: []
+SYSC_uselib read_list: [(struct vfsmount)->mnt_flags, (struct super_block)->s_iflags, (struct linux_binfmt)->load_shlib, ]
+SyS_umount read_list: []
+SyS_oldumount read_list: []
+SyS_mount read_list: []
+SyS_pivot_root read_list: []
+SYSC_pivot_root read_list: [(struct vfsmount)->mnt_flags, (struct mount)->mnt_ns, (struct nsproxy)->mnt_ns, (struct dentry)->d_parent, (struct vfsmount)->mnt_root, (struct path)->dentry, (struct mount)->mnt_parent, (struct path)->mnt, ]
+SYSC_mount read_list: [(struct task_struct)->personality, ]
+SYSC_oldumount read_list: []
+SYSC_umount read_list: [(struct path)->dentry, (struct vfsmount)->mnt_root, (struct mount)->mnt_ns, (struct nsproxy)->mnt_ns, (struct vfsmount)->mnt_flags, (struct path)->mnt, (struct super_operations)->umount_begin, (struct super_block)->s_flags, (struct task_struct)->flags, ]
+compat_SyS_mount read_list: []
+C_SYSC_mount read_list: []
+SyS_lseek read_list: []
+compat_SyS_lseek read_list: []
+SyS_llseek read_list: []
+SyS_read read_list: []
+SyS_write read_list: []
+SyS_pread64 read_list: []
+SyS_pwrite64 read_list: []
+SyS_readv read_list: []
+SyS_writev read_list: []
+SyS_preadv read_list: []
+SyS_preadv2 read_list: []
+SyS_pwritev read_list: []
+SyS_pwritev2 read_list: []
+compat_SyS_readv read_list: []
+compat_SyS_preadv64 read_list: []
+compat_SyS_preadv read_list: []
+compat_SyS_preadv64v2 read_list: []
+compat_SyS_preadv2 read_list: []
+compat_SyS_writev read_list: []
+compat_SyS_pwritev64 read_list: []
+compat_SyS_pwritev read_list: []
+compat_SyS_pwritev64v2 read_list: []
+compat_SyS_pwritev2 read_list: []
+SyS_sendfile read_list: []
+SyS_sendfile64 read_list: []
+compat_SyS_sendfile read_list: []
+compat_SyS_sendfile64 read_list: []
+SyS_copy_file_range read_list: []
+SYSC_copy_file_range read_list: [(struct fd)->file, (struct fd)->flags, ]
+C_SYSC_sendfile64 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_sendfile read_list: [(struct fd)->file, (struct file)->f_mode, ]
+SYSC_sendfile64 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+SYSC_sendfile read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_pwritev2 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_pwritev64v2 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_pwritev read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_pwritev64 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_writev read_list: [(struct fd)->file, ]
+C_SYSC_preadv2 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_preadv64v2 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_preadv read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_preadv64 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+C_SYSC_readv read_list: [(struct fd)->file, ]
+SYSC_pwritev2 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+SYSC_pwritev read_list: [(struct fd)->file, (struct file)->f_mode, ]
+SYSC_preadv2 read_list: [(struct fd)->file, (struct file)->f_mode, ]
+SYSC_preadv read_list: [(struct fd)->file, (struct file)->f_mode, ]
+SYSC_writev read_list: [(struct fd)->file, ]
+SYSC_readv read_list: [(struct fd)->file, ]
+SYSC_pwrite64 read_list: [(struct fd)->file, (struct file)->f_mode, (struct fd)->flags, ]
+SYSC_pread64 read_list: [(struct fd)->file, (struct file)->f_mode, (struct fd)->flags, ]
+SYSC_write read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_read read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_llseek read_list: [(struct fd)->file, (struct fd)->flags, ]
+C_SYSC_lseek read_list: []
+SYSC_lseek read_list: [(struct fd)->file, (struct fd)->flags, ]
+SyS_timerfd_create read_list: []
+SyS_timerfd_settime read_list: []
+SyS_timerfd_gettime read_list: []
+compat_SyS_timerfd_settime read_list: []
+compat_SyS_timerfd_gettime read_list: []
+C_SYSC_timerfd_gettime read_list: [(struct timerfd_ctx)->expired, (struct timerfd_ctx)->tintv, ]
+C_SYSC_timerfd_settime read_list: [(struct timerfd_ctx)->expired, (struct timerfd_ctx)->tintv, ]
+SYSC_timerfd_gettime read_list: [(struct timerfd_ctx)->expired, (struct timerfd_ctx)->tintv, ]
+SYSC_timerfd_settime read_list: [(struct timerfd_ctx)->expired, (struct timerfd_ctx)->tintv, ]
+SYSC_timerfd_create read_list: [(struct timerfd_ctx)->clockid, ]
+SyS_eventfd2 read_list: []
+SyS_eventfd read_list: []
+SYSC_eventfd read_list: []
+SYSC_eventfd2 read_list: []
+SyS_select read_list: []
+SyS_pselect6 read_list: []
+SyS_poll read_list: []
+SyS_ppoll read_list: []
+compat_SyS_select read_list: []
+compat_SyS_old_select read_list: []
+compat_SyS_pselect6 read_list: []
+compat_SyS_ppoll read_list: []
+C_SYSC_ppoll read_list: [(struct poll_list)->len, (struct task_struct)->personality, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+C_SYSC_pselect6 read_list: []
+C_SYSC_old_select read_list: []
+C_SYSC_select read_list: [(struct files_struct)->fdt, (struct files_struct)->fdt, (struct task_struct)->personality, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_ppoll read_list: [(struct poll_list)->len, (struct task_struct)->personality, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+SYSC_poll read_list: [(struct poll_list)->len, ]
+SYSC_pselect6 read_list: []
+SYSC_select read_list: [(struct files_struct)->fdt, (struct files_struct)->fdt, (struct task_struct)->personality, (struct timespec)->tv_sec, (struct timespec)->tv_nsec, ]
+sys_sync read_list: []
+SyS_syncfs read_list: []
+SyS_fsync read_list: []
+SyS_fdatasync read_list: []
+SyS_sync_file_range read_list: []
+SyS_sync_file_range2 read_list: []
+SYSC_sync_file_range2 read_list: []
+SYSC_sync_file_range read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_fdatasync read_list: [(struct fd)->file, ]
+SYSC_fsync read_list: [(struct fd)->file, ]
+SYSC_syncfs read_list: [(struct fd)->file, (struct fd)->flags, ]
+SyS_truncate read_list: []
+compat_SyS_truncate read_list: []
+SyS_ftruncate read_list: []
+compat_SyS_ftruncate read_list: []
+SyS_fallocate read_list: []
+SyS_faccessat read_list: []
+SyS_access read_list: []
+SyS_chdir read_list: []
+SyS_fchdir read_list: []
+SyS_chroot read_list: []
+SyS_fchmod read_list: []
+SyS_fchmodat read_list: []
+SyS_chmod read_list: []
+SyS_fchownat read_list: []
+SyS_chown read_list: []
+SyS_lchown read_list: []
+SyS_fchown read_list: []
+SyS_open read_list: []
+SyS_openat read_list: []
+compat_SyS_open read_list: []
+compat_SyS_openat read_list: []
+SyS_creat read_list: []
+SyS_close read_list: []
+sys_vhangup read_list: []
+SYSC_close read_list: []
+SYSC_creat read_list: []
+C_SYSC_openat read_list: []
+C_SYSC_open read_list: []
+SYSC_openat read_list: []
+SYSC_open read_list: []
+SYSC_fchown read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_lchown read_list: []
+SYSC_chown read_list: []
+SYSC_fchownat read_list: []
+SYSC_chmod read_list: []
+SYSC_fchmodat read_list: []
+SYSC_fchmod read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_chroot read_list: []
+SYSC_fchdir read_list: [(struct fd)->file, (struct fd)->flags, ]
+SYSC_chdir read_list: []
+SYSC_access read_list: []
+SYSC_faccessat read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SYSC_fallocate read_list: [(struct fd)->file, (struct fd)->flags, ]
+C_SYSC_ftruncate read_list: [(struct fd)->file, (struct file)->f_flags, (struct file)->f_mode, (struct inode)->i_flags, ]
+SYSC_ftruncate read_list: [(struct fd)->file, (struct file)->f_flags, (struct file)->f_mode, (struct inode)->i_flags, ]
+C_SYSC_truncate read_list: []
+SYSC_truncate read_list: []
+SyS_utime read_list: []
+SyS_utimensat read_list: []
+SyS_futimesat read_list: []
+SyS_utimes read_list: []
+compat_SyS_utime read_list: []
+compat_SyS_utimensat read_list: []
+compat_SyS_futimesat read_list: []
+compat_SyS_utimes read_list: []
+C_SYSC_utimes read_list: []
+C_SYSC_futimesat read_list: [(struct timespec)->tv_nsec, (struct fd)->file, ]
+C_SYSC_utimensat read_list: [(struct timespec)->tv_nsec, (struct fd)->file, ]
+C_SYSC_utime read_list: [(struct fd)->file, ]
+SYSC_utimes read_list: []
+SYSC_futimesat read_list: [(struct timeval)->tv_usec, (struct fd)->file, ]
+SYSC_utimensat read_list: [(struct timespec)->tv_nsec, (struct fd)->file, ]
+SYSC_utime read_list: []
+SyS_flock read_list: []
+SYSC_flock read_list: [(struct fd)->file, (struct file)->f_mode, (struct file_operations)->flock, (struct super_block)->s_flags, (struct fd)->flags, ]
+SyS_epoll_create1 read_list: []
+SyS_epoll_create read_list: []
+SyS_epoll_ctl read_list: []
+SyS_epoll_wait read_list: []
+SyS_epoll_pwait read_list: []
+compat_SyS_epoll_pwait read_list: []
+C_SYSC_epoll_pwait read_list: []
+SYSC_epoll_pwait read_list: []
+SYSC_epoll_wait read_list: [(struct fd)->file, (struct file)->f_op, (struct fd)->flags, ]
+SYSC_epoll_ctl read_list: [(struct fd)->file, (struct file_operations)->poll, (struct epoll_event)->events, (struct file)->f_op, (struct epitem)->ws, (struct epitem)->ws, (struct epitem)->nwait, (struct fd)->flags, ]
+SYSC_epoll_create read_list: []
+SYSC_epoll_create1 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, ]
+SyS_statfs read_list: []
+SyS_statfs64 read_list: []
+SyS_fstatfs read_list: []
+SyS_fstatfs64 read_list: []
+SyS_ustat read_list: []
+compat_SyS_statfs read_list: []
+compat_SyS_fstatfs read_list: []
+compat_SyS_statfs64 read_list: []
+compat_SyS_fstatfs64 read_list: []
+compat_SyS_ustat read_list: []
+C_SYSC_ustat read_list: []
+C_SYSC_fstatfs64 read_list: [(struct fd)->file, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, ]
+C_SYSC_statfs64 read_list: [(struct kstatfs)->f_files, (struct kstatfs)->f_ffree, ]
+C_SYSC_fstatfs read_list: [(struct fd)->file, (struct kstatfs)->f_files, (struct kstatfs)->f_ffree, ]
+C_SYSC_statfs read_list: [(struct kstatfs)->f_files, (struct kstatfs)->f_ffree, ]
+SYSC_ustat read_list: []
+SYSC_fstatfs64 read_list: [(struct fd)->file, ]
+SYSC_fstatfs read_list: [(struct fd)->file, ]
+SYSC_statfs64 read_list: []
+SYSC_statfs read_list: []
+SyS_fcntl read_list: []
+compat_SyS_fcntl64 read_list: []
+compat_SyS_fcntl read_list: []
+C_SYSC_fcntl read_list: []
+C_SYSC_fcntl64 read_list: [(struct fd)->file, (struct file)->f_mode, (struct flock)->l_start, (struct flock)->l_len, (struct fd)->flags, ]
+SYSC_fcntl read_list: [(struct fd)->file, (struct file)->f_mode, (struct fd)->flags, ]
+SyS_mknodat read_list: []
+SyS_mknod read_list: []
+SyS_mkdirat read_list: []
+SyS_mkdir read_list: []
+SyS_rmdir read_list: []
+SyS_unlinkat read_list: []
+SyS_unlink read_list: []
+SyS_symlinkat read_list: []
+SyS_symlink read_list: []
+SyS_linkat read_list: []
+SyS_link read_list: []
+SyS_renameat2 read_list: []
+SyS_renameat read_list: []
+SyS_rename read_list: []
+SYSC_rename read_list: []
+SYSC_renameat read_list: []
+SYSC_renameat2 read_list: [(struct path)->mnt, (struct filename)->refcnt, (struct filename)->name, (struct filename)->iname, ]
+SYSC_link read_list: []
+SYSC_linkat read_list: [(struct path)->mnt, ]
+SYSC_symlink read_list: []
+SYSC_symlinkat read_list: [(struct filename)->refcnt, (struct filename)->name, (struct filename)->iname, ]
+SYSC_unlink read_list: []
+SYSC_unlinkat read_list: [(struct dentry)->d_inode, ]
+SYSC_rmdir read_list: [(struct dentry)->d_inode, ]
+SYSC_mkdir read_list: []
+SYSC_mkdirat read_list: [(struct super_block)->s_flags, ]
+SYSC_mknod read_list: []
+SYSC_mknodat read_list: [(struct super_block)->s_flags, ]
+SyS_lookup_dcookie read_list: []
+compat_SyS_lookup_dcookie read_list: []
+C_SYSC_lookup_dcookie read_list: []
+SYSC_lookup_dcookie read_list: []
+compat_SyS_ioctl read_list: []
+C_SYSC_ioctl read_list: [(struct fd)->file, (struct file_operations)->compat_ioctl, (struct file_operations)->unlocked_ioctl, (struct fd)->flags, ]
+SyS_inotify_init1 read_list: []
+sys_inotify_init read_list: []
+SyS_inotify_add_watch read_list: []
+SyS_inotify_rm_watch read_list: []
+SYSC_inotify_rm_watch read_list: [(struct fd)->file, (struct file)->f_op, (struct fd)->flags, ]
+SYSC_inotify_add_watch read_list: [(struct fd)->file, (struct file)->f_op, (struct fd)->flags, ]
+SYSC_inotify_init1 read_list: [(struct task_struct)->cred, (struct task_struct)->cred, (struct inotify_group_private_data)->ucounts, ]
+sys_dmi_field_show read_list: []
+sys_dmi_modalias_show read_list: [(struct mafield)->prefix, ]
+sys_copyarea read_list: [(struct fb_info)->state, (struct fb_ops)->fb_sync, ]
+sys_fillrect read_list: [(struct fb_info)->state, (struct fb_fix_screeninfo)->visual, (struct fb_ops)->fb_sync, ]
+sys_imageblit read_list: [(struct fb_info)->state, (struct fb_ops)->fb_sync, (struct fb_image)->depth, (struct fb_fix_screeninfo)->visual, ]
+sys_get_curr_temp read_list: []
+sys_get_trip_temp read_list: []
+sys_set_trip_temp read_list: [(struct pkg_device)->tj_max, ]
+sys_get_trip_type read_list: []
+SyS_getrandom read_list: []
+SYSC_getrandom read_list: []
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.ioctls b/usr/src/tools/smatch/src/smatch_data/kernel.ioctls
new file mode 100644
index 0000000000..c668d2a914
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.ioctls
@@ -0,0 +1,246 @@
+aac_cfg_ioctl
+ac_ioctl
+acq_ioctl
+adpt_unlocked_ioctl
+adsp_ioctl
+advwdt_ioctl
+adx_wdt_ioctl
+agp_ioctl
+ali_ioctl
+anslcd_ioctl
+apm_ioctl
+ar7_wdt_ioctl
+asr_ioctl
+at32_wdt_ioctl
+at91_wdt_ioctl
+audamrnb_ioctl
+audevrc_ioctl
+audio_in_ioctl
+audio_ioctl
+audpp_ioctl
+audpre_ioctl
+audqcelp_ioctl
+autofs_root_ioctl
+bcm47xx_wdt_ioctl
+bcm_char_ioctl
+bfin_otp_ioctl
+bfin_wdt_ioctl
+booke_wdt_ioctl
+bridge_ioctl
+capi_unlocked_ioctl
+chd_dec_ioctl
+ch_ioctl
+chsc_ioctl
+cmm_ioctl
+coh901327_ioctl
+comedi_unlocked_ioctl
+cosa_chardev_ioctl
+cpu5wdt_ioctl
+cpwd_ioctl
+_ctl_ioctl
+ctrl_cdev_ioctl
+d7s_ioctl
+dabusb_ioctl
+davinci_wdt_ioctl
+dev_ioctl
+dm_ctl_ioctl
+drm_ioctl
+ds1620_unlocked_ioctl
+dsp56k_ioctl
+dst_ca_ioctl
+dtlk_ioctl
+dv1394_ioctl
+dvb_ca_en50221_io_ioctl
+dvb_demux_ioctl
+dvb_dvr_ioctl
+dvb_generic_ioctl
+dvb_net_ioctl
+easycap_ioctl
+easysnd_ioctl
+efi_rtc_ioctl
+envctrl_ioctl
+ep93xx_wdt_ioctl
+ep_ioctl
+epx_c3_ioctl
+erst_dbg_ioctl
+esb_ioctl
+eurwdt_ioctl
+evdev_ioctl
+evtchn_ioctl
+fb_ioctl
+ffs_ep0_ioctl
+ffs_epfile_ioctl
+fitpc2_wdt_ioctl
+flash_ioctl
+fop_ioctl
+fs3270_ioctlioctl
+ft1000_ChIoctl
+fw_device_op_ioctl
+gdth_unlocked_ioctl
+gef_wdt_ioctl
+gen_rtc_unlocked_ioctl
+geodewdt_ioctl
+GLOB_SBD_unlocked_ioctl
+gru_file_unlocked_ioctl
+hiddev_ioctl
+hidraw_ioctl
+hpet_ioctl
+hp_sdc_rtc_unlocked_ioctl
+hpwdt_ioctl
+hub_ioctl
+hung_up_tty_ioctl
+i2cdev_ioctl
+i2o_cfg_ioctl
+i810_ioctl
+i830_ioctl
+i8k_ioctl
+ib_umad_ioctl
+ibwdt_ioctl
+idetape_chrdev_ioctl
+imx2_wdt_ioctl
+indydog_ioctl
+intel_sst_ioctl
+ioctl
+ioctl_rio
+iop_wdt_ioctl
+iowarrior_ioctl
+ip2_ipl_ioctl
+ipmi_unlocked_ioctl
+ir_lirc_ioctl
+isdn_divert_ioctl
+isdn_unlocked_ioctl
+it8712f_wdt_ioctl
+iTCO_wdt_ioctl
+ivtv_v4l2_ioctl
+ixj_ioctl
+ixp2000_wdt_ioctl
+ixp4xx_wdt_ioctl
+joydev_ioctl
+jsf_ioctl
+ks8695_wdt_ioctl
+lcd_ioctl
+lirc_dev_fop_ioctl
+lirc_ioctl
+lp_ioctl
+macvtap_ioctl
+max63xx_wdt_ioctl
+megadev_unlocked_ioctl
+megasas_mgmt_ioctl
+memrar_ioctl
+mISDN_ioctl
+mixcomwd_ioctl
+mmtimer_ioctl
+mon_bin_ioctl
+mon_stat_ioctl
+mpc8xxx_wdt_ioctl
+mpcore_wdt_ioctl
+mptctl_ioctl
+mraid_mm_unlocked_ioctl
+msm_ioctl_config
+msm_ioctl_control
+msm_ioctl_frame
+mtd_unlocked_ioctl
+mtx1_wdt_ioctl
+mv64x60_wdt_ioctl
+mwave_ioctl
+nosy_ioctl
+nuc900_wdt_ioctl
+nvram_ioctl
+nvram_unlocked_ioctl
+octeon_wdt_ioctl
+omap_wdt_ioctl
+openprom_ioctl
+orion_wdt_ioctl
+osd_uld_ioctl
+osst_ioctl
+pc87413_ioctl
+pcipcwd_ioctl
+pcwd_ioctl
+phantom_ioctl
+pikawdt_ioctl
+pkt_ctl_ioctl
+pmcraid_chr_ioctl
+pmem_ioctl
+pmu_unlocked_ioctl
+pnx4008_wdt_ioctl
+pnx833x_wdt_ioctl
+pp_ioctl
+ppp_ioctl
+pps_cdev_ioctl
+printer_ioctl
+proc_bus_pci_ioctl
+pt_ioctl
+random_ioctl
+raw1394_ioctl
+raw_ctl_ioctl
+raw_ioctl
+rc32434_wdt_ioctl
+rdc321x_wdt_ioctl
+rio_fw_ioctl
+riowd_ioctl
+rtc_dev_ioctl
+rtc_ioctl
+s3c2410wdt_ioctl
+sa1100dog_ioctl
+sbwdog_ioctl
+sc1200wdt_ioctl
+sch311x_wdt_ioctl
+scx200_wdt_ioctl
+sg_unlocked_ioctl
+sh_wdt_ioctl
+smb_ioctl
+snd_ioctl
+softdog_ioctl
+sonypi_misc_ioctl
+sp805_wdt_ioctl
+spidev_ioctl
+st_ioctl
+stli_memioctl
+stl_memioctl
+stmp3xxx_wdt_ioctl
+sx_fw_ioctl
+tapechar_ioctl
+tosh_ioctl
+ts72xx_wdt_ioctl
+tty_ioctl
+tun_chr_ioctl
+twa_chrdev_ioctl
+tw_chrdev_ioctl
+twl4030_wdt_ioctl
+twl_chrdev_ioctl
+txx9wdt_ioctl
+ubi_cdev_ioctl
+uctrl_ioctl
+uinput_ioctl
+usbdev_ioctl
+usblp_ioctl
+usb_pcwd_ioctl
+usbtest_ioctl
+usbtmc_ioctl
+uv_mmtimer_ioctl
+v4l2_ioctl
+vfd_ioctl
+vhost_net_ioctl
+video1394_ioctl
+video_ioctl2
+video_ioctl2V4L2ioctlhandler
+vino_ioctl
+viotap_unlocked_ioctl
+vmcp_ioctl
+vme_user_unlocked_ioctl
+vmwdt_ioctl
+vmw_unlocked_ioctl
+vol_cdev_ioctl
+wafwdt_ioctl
+watchdog_ioctl
+wb_smsc_wdt_ioctl
+wdrtas_ioctl
+wdt977_ioctl
+wdt_ioctl
+wdtpci_ioctl
+wdt_unlocked_ioctl
+wm831x_wdt_ioctl
+wm8350_wdt_ioctl
+zcrypt_unlocked_ioctl
+zfcp_cfdc_dev_ioctl
+zf_ioctl
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.macro_takes_sizeof_argument b/usr/src/tools/smatch/src/smatch_data/kernel.macro_takes_sizeof_argument
new file mode 100644
index 0000000000..9ad6faf249
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.macro_takes_sizeof_argument
@@ -0,0 +1,4 @@
+BNX2FC_RQ_BUF_LOG_SZ
+BNX2FC_NUM_MAX_SESS_LOG
+ilog2
+FP_XSTATE_MAGIC2_SIZE
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.must_check_funcs b/usr/src/tools/smatch/src/smatch_data/kernel.must_check_funcs
new file mode 100644
index 0000000000..38305d22e7
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.must_check_funcs
@@ -0,0 +1,5 @@
+ERR_PTR
+PTR_ERR
+IS_ERR
+IS_ERR_OR_NULL
+ERR_CAST
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.no_inline_functions b/usr/src/tools/smatch/src/smatch_data/kernel.no_inline_functions
new file mode 100644
index 0000000000..149bc0deaa
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.no_inline_functions
@@ -0,0 +1,12 @@
+__fswab16
+__fswab32
+__fswab64
+__builtin_bswap16
+__builtin_bswap32
+__builtin_bswap64
+__arch_hweight8
+__arch_hweight16
+__arch_hweight32
+__arch_hweight64
+__write_once_size
+atomic_set
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.no_return_funcs b/usr/src/tools/smatch/src/smatch_data/kernel.no_return_funcs
new file mode 100644
index 0000000000..c221a12f3e
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.no_return_funcs
@@ -0,0 +1,103 @@
+// list of functions which don't return.
+// generated by `gen_no_return_funcs.sh`
+__assert_fail
+exit
+__builtin_unreachable
+ahd_handle_hwerrint
+aic7xxx_panic_abort
+assfail
+ast_gem_init_object
+audit_tree_handle_event
+backref_tree_panic
+bnep_session
+cafe_nand_bug
+cifs_demultiplex_thread
+cirrus_gem_init_object
+cmtp_session
+complete_and_exit
+cpu_bringup_and_idle
+cpu_idle_loop
+cpu_startup_entry
+cryptomgr_probe
+cryptomgr_test
+denali_ecc_calculate
+denali_ecc_correct
+denali_ecc_hwctl
+df_debug
+die_kmmio_nesting_error
+do_double_fault
+do_exit
+do_group_exit
+drm_framebuffer_free_bug
+drm_gem_object_ref_bug
+dummy_handler
+early_panic
+extent_io_tree_panic
+fsnotify_mark_destroy
+gru_abort
+hidp_session_thread
+hlt_play_dead
+hugetlbfs_write_end
+hugetlb_vm_op_fault
+i915_gem_init_object
+i915_gem_object_get_pages_stolen
+__invalid_creds
+jffs2_garbage_collect_thread
+kdb_reboot
+kgdboc_reset_disconnect
+kthread
+kthreadd
+kvm_spurious_fault
+logfs_mark_segment_bad
+machine_real_restart
+mgag200_gem_init_object
+mpt_halt_firmware
+native_machine_emergency_restart
+native_machine_halt
+netlink_data_ready
+nfs4_run_state_manager
+nfsd
+nfs_proc_commit_rpc_prepare
+nfs_proc_commit_setup
+__ocfs2_recovery_thread
+ordered_data_tree_panic
+panic
+panic_smp_self_stop
+ping_hash
+prio_changed_idle
+prio_changed_stop
+r100_semaphore_ring_emit
+r8712_cmd_thread
+radeon_gem_object_init
+rcu_gp_kthread
+rcu_nocb_kthread
+__reiserfs_panic
+report_instruction_timeout
+rest_init
+retu_power_off
+skb_over_panic
+skb_panic
+skb_under_panic
+__stack_chk_fail
+start_kernel
+start_secondary
+stop_self
+stop_this_cpu
+svc_udp_accept
+switched_to_idle
+switched_to_stop
+SYSC_exit
+SYSC_exit_group
+SyS_exit
+SyS_exit_group
+task_tick_rt
+ttm_bo_ref_bug
+txd_chain
+udl_gem_init_object
+usbatm_do_heavy_init
+vdump_bucket_and_panic
+wait_for_helper
+wait_for_panic
+x86_64_start_kernel
+x86_64_start_reservations
+yield_task_stop
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.no_return_funcs.remove b/usr/src/tools/smatch/src/smatch_data/kernel.no_return_funcs.remove
new file mode 100644
index 0000000000..e59495eee0
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.no_return_funcs.remove
@@ -0,0 +1 @@
+watchdog
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.parameter_implications.add b/usr/src/tools/smatch/src/smatch_data/kernel.parameter_implications.add
new file mode 100644
index 0000000000..66cd1cc317
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.parameter_implications.add
@@ -0,0 +1,15 @@
+/*
+ * It's pretty common that the return value implies something about a parameter.
+ * This gives you a way to tell Smatch about it.
+ *
+ * The format is:
+ * function "return range" parameter "implied value range list of parameter"
+ *
+ * You have to specify at least two return ranges for a function.  The implied
+ * value is a range list, but the return range is just a range and we only care
+ * about the min and the max.  We start counting the first parameter at zero.
+ *
+ */
+
+rw_verify_area "0-1000000" 3 "0-1000000"
+rw_verify_area "-4095-(-1)" 3 "min-max"
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.puts_argument b/usr/src/tools/smatch/src/smatch_data/kernel.puts_argument
new file mode 100644
index 0000000000..b2e5346f71
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.puts_argument
@@ -0,0 +1,9 @@
+// list of functions and the argument they decrement the ref of.
+// generated by `gen_puts_list.sh`
+batadv_sysfs_del_hardif 0
+class_compat_unregister 0
+cleanup_glue_dir 1
+hugepage_exit_sysfs 0
+hugepage_init_sysfs 0
+ib_device_unregister_sysfs 0
+uio_dev_del_attributes 0
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.returns_err_ptr b/usr/src/tools/smatch/src/smatch_data/kernel.returns_err_ptr
new file mode 100644
index 0000000000..55e82b4dbc
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.returns_err_ptr
@@ -0,0 +1,1627 @@
+// list of functions that return a new allocation.
+// generated by `gen_err_ptr_list.sh`
+aa_dfa_unpack
+aa_simple_write_to_buffer
+aa_unpack
+acer_rfkill_register
+acquire_group
+ad714x_probe
+ad7606_probe
+ad7879_probe
+add_inode
+add_numbered_child
+add_partition
+add_qgroup_rb
+addrconf_add_dev
+addrconf_dst_alloc
+add_tracepoint
+add_volume
+adfs_lookup
+ads7846_probe_dt
+adxl34x_probe
+aead_geniv_alloc
+affs_alloc_extblock
+affs_bread_ino
+affs_find_entry
+affs_getemptyblk_ino
+affs_get_extblock_slow
+affs_getzeroblk_ino
+affs_iget
+afs_cell_alloc
+afs_cell_create
+afs_cell_lookup
+afs_dir_get_page
+afs_iget
+afs_iget_autocell
+afs_lookup
+afs_lookup_server
+afs_mntpt_do_automount
+afs_mntpt_lookup
+afs_mount
+afs_try_auto_mntpt
+afs_vlocation_lookup
+afs_volume_lookup
+afs_volume_pick_fileserver
+alg_get_type
+alloc
+allocate_fake_cpuc
+allocate_partition
+alloc_cmd
+alloc_cmd_box
+alloc_counters
+alloc_huge_page
+alloc_log_tree
+alloc_mnt_ns
+alloc_msg
+alloc_nfs_open_context
+alloc_nfs_open_dir_context
+alloc_param_target
+alloc_rbio
+alloc_sdesc
+alloc_swap_info
+alloc_trace_uprobe
+alloc_ts_config
+alloc_upcall
+alloc_vmap_area
+anon_inode_getfile
+anon_inode_mkinode
+applesmc_get_entry_by_index
+applesmc_get_entry_by_key
+arpt_register_table
+ast_user_framebuffer_create
+ath10k_fetch_fw_file
+ath10k_htc_create
+ath5k_txq_setup
+ath6kl_cfg80211_add_iface
+atk_ggrp
+atk_gitm
+atk_sitm
+audit_data_to_entry
+audit_dupe_rule
+audit_dupe_watch
+audit_init_parent
+audit_init_watch
+audit_to_entry_common
+audit_unpack_string
+auo_pixcir_parse_dt
+autofs4_d_automount
+autofs4_lookup
+b43_wireless_init
+backlight_device_register
+bad_inode_lookup
+balloon_devinfo_alloc
+balloon_mapping_alloc
+bar_init
+bch_btree_node_alloc
+bch_btree_node_get
+bclean
+bcma_hcd_create_pdev
+bd_start_claiming
+befs_iget
+befs_lookup
+beiscsi_ep_connect
+bfs_iget
+bfs_lookup
+bio_copy_user_iov
+__bio_map_kern
+bio_map_kern
+__bio_map_user_iov
+bl_alloc_lseg
+bl_find_get_zeroing_page
+blkcg_css_alloc
+blkdev_get_by_dev
+blkdev_get_by_path
+blkg_create
+blkg_lookup_create
+blk_make_request
+bnx2i_ep_connect
+brcmf_add_if
+brcmf_alloc_vif
+brcmf_bus_gettxq
+brcmf_cfg80211_add_iface
+brcmf_fws_macdesc_lookup
+brcmf_p2p_add_vif
+brcmf_p2p_create_p2pdev
+brcmf_setup_wiphy
+brd_probe
+br_multicast_get_group
+br_multicast_new_group
+bsg_add_device
+bsg_alloc_command
+bsg_get_device
+bsg_get_done_cmd
+bsg_map_hdr
+btree_get_extent
+btrfs_alloc_free_block
+btrfs_create_tree
+btrfs_get_acl
+btrfs_get_dentry
+btrfs_get_extent
+btrfs_get_extent_fiemap
+btrfs_get_or_create_delayed_node
+btrfs_get_parent
+btrfs_iget
+btrfs_init_new_buffer
+btrfs_lookup_csum
+btrfs_lookup_dentry
+btrfs_lookup_dir_index_item
+btrfs_lookup_dir_item
+btrfs_lookup_inode_extref
+btrfs_lookup_inode_ref
+btrfs_lookup_xattr
+btrfs_mount
+btrfs_new_extent_direct
+btrfs_new_inode
+btrfs_reada_add
+btrfs_read_fs_root_no_name
+btrfs_read_tree_root
+btrfs_ref_to_path
+btrfs_search_dir_index_item
+bu21013_parse_dt
+build_backref_tree
+build_map_info
+build_unc_path_to_root
+c2_ah_create
+c2_alloc_pd
+c2_alloc_ucontext
+c2_create_cq
+c2_create_qp
+c2port_device_register
+c2_reg_phys_mr
+c2_reg_user_mr
+c4iw_ah_create
+c4iw_alloc
+c4iw_allocate_pd
+c4iw_alloc_fast_reg_mr
+c4iw_alloc_fastreg_pbl
+c4iw_alloc_mw
+c4iw_alloc_ucontext
+c4iw_create_cq
+c4iw_create_qp
+c4iw_get_dma_mr
+c4iw_register_phys_mem
+c4iw_reg_user_mr
+c4iw_uld_add
+cache_create_net
+cachefiles_alloc_object
+cachefiles_check_active
+cachefiles_get_directory
+carl9170_alloc
+cciss_seq_start
+ceph_alloc_page_vector
+ceph_auth_init
+ceph_create_client
+ceph_create_snap_realm
+ceph_extract_encoded_string
+ceph_fh_to_parent
+ceph_finish_lookup
+ceph_get_direct_page_vector
+ceph_get_inode
+ceph_lookup
+ceph_mdsc_build_path
+ceph_mdsc_create_request
+ceph_mdsmap_decode
+ceph_monmap_decode
+ceph_mount
+ceph_osdc_new_request
+ceph_parse_options
+ceph_real_mount
+cfg80211_get_dev_from_ifindex
+__cfg80211_rdev_from_attrs
+__cfg80211_wdev_from_attrs
+__cfh_to_dentry
+cgroup_css_from_dir
+cgroup_lookup
+cgroup_mount
+cgroup_root_from_opts
+cgrp_css_alloc
+chainiv_alloc
+check_partition
+check_range
+cifs_build_devname
+cifs_compose_mount_options
+cifs_construct_tcon
+cifs_dfs_do_automount
+cifs_do_mount
+cifs_get_root
+cifs_get_smb_ses
+cifs_get_spnego_key
+cifs_get_tcon
+cifs_get_tcp_session
+cifs_get_volume_info
+cifs_lookup
+cifs_root_iget
+cifs_sb_tlink
+cifs_setup_async_request
+cifs_setup_request
+ci_hdrc_add_device
+cirrus_user_framebuffer_create
+__class_create
+__clk_register
+clk_register
+clk_register_composite
+clk_register_fixed_factor
+clk_register_fixed_rate
+clk_register_gate
+clk_register_mux_table
+clone_fs_devices
+clone_mnt
+clone_uts_ns
+clusterip_seq_start
+cma3000_init
+cm_copy_private_data
+cm_create_timewait_info
+coda_cnode_make
+coda_cnode_makectl
+coda_iget
+coda_lookup
+config_desc_make
+configfs_lookup
+configfs_new_dirent
+construct_key_and_link
+context_alloc
+copy_dev_ioctl
+copy_gadget_strings
+copy_msg
+copy_net_ns
+copy_pid_ns
+copy_process
+copy_tree
+copy_znode
+core_alloc_hba
+core_alloc_port
+core_alua_allocate_lu_gp
+core_alua_allocate_lu_gp_mem
+core_alua_allocate_tg_pt_gp_mem
+core_dev_add_lun
+core_tpg_add_initiator_node_acl
+core_tpg_pre_addlun
+core_tpg_pre_dellun
+cpuacct_css_alloc
+cpu_cgroup_css_alloc
+cpufreq_cooling_register
+cpuset_css_alloc
+cpuset_mount
+create_and_register_pcpu
+create_empty_lvol
+create_entry
+create_fs_client
+create_hw_context
+create_iboe_ah
+create_ipc_ns
+create_new_namespaces
+create_pid_namespace
+create_pinned_em
+create_reloc_inode
+create_request_message
+_create_sg_bios
+create_xattr_datum
+create_xattr_ref
+crush_decode
+cryptd_alloc_ablkcipher
+cryptd_alloc_aead
+cryptd_alloc_ahash
+cryptd_alloc_instance
+crypto_alg_mod_lookup
+crypto_alloc_ablkcipher
+crypto_alloc_aead
+crypto_alloc_base
+crypto_alloc_instance
+crypto_alloc_instance2
+__crypto_alloc_tfm
+crypto_alloc_tfm
+crypto_attr_alg_name
+crypto_authenc_ahash
+crypto_authenc_ahash_fb
+crypto_authenc_alloc
+crypto_authenc_esn_ahash
+crypto_authenc_esn_alloc
+crypto_cbc_alloc
+crypto_ccm_alloc
+crypto_ccm_alloc_common
+crypto_ccm_base_alloc
+crypto_create_tfm
+crypto_ctr_alloc
+crypto_cts_alloc
+crypto_ecb_alloc
+crypto_fpu_alloc
+crypto_gcm_alloc
+crypto_gcm_alloc_common
+crypto_gcm_base_alloc
+crypto_get_attr_type
+crypto_larval_alloc
+crypto_larval_lookup
+crypto_larval_wait
+crypto_lookup_aead
+crypto_lookup_skcipher
+crypto_pcbc_alloc
+crypto_rfc3686_alloc
+crypto_rfc4106_alloc
+crypto_rfc4309_alloc
+crypto_rfc4543_alloc
+crypto_spawn_alg
+crypto_spawn_tfm
+crypto_user_aead_alg
+crypto_user_skcipher_alg
+ctnetlink_create_conntrack
+ctrl_build_family_msg
+ctrl_build_mcgrp_msg
+cxgbi_check_route
+cxgbi_ep_connect
+cyttsp4_probe
+cyttsp_probe
+d_absolute_path
+d_add_ci
+db9_probe
+debug_css_alloc
+dentry_open
+__dentry_path
+dentry_path
+devcgroup_css_alloc
+devfreq_add_device
+device_create_vargs
+devm_backlight_device_register
+devm_clk_get
+devm_clk_register
+devm_ioremap_resource
+devm_lcd_device_register
+devm_of_pwm_get
+devm_pinctrl_get_select
+devm_pwm_get
+devm_regmap_field_alloc
+devm_regmap_init
+devm_regulator_get
+devm_reset_control_get
+devm_rtc_device_register
+devm_usb_get_phy_by_phandle
+devpts_mount
+devpts_pty_new
+d_hash_and_lookup
+dio_get_page
+dirty_cow_bottom_up
+dirty_cow_nnode
+dirty_cow_pnode
+dirty_cow_znode
+disk_seqf_start
+dlm_register_domain
+dl_seq_start
+dma_buf_attach
+dma_buf_export_named
+dma_buf_get
+dma_buf_map_attachment
+d_materialise_unique
+dm_block_manager_create
+dm_bufio_client_create
+dm_build_path_uevent
+dm_cache_metadata_open
+dm_hash_rename
+dm_io_client_create
+dm_kcopyd_client_create
+dm_pool_metadata_open
+dm_region_hash_create
+dm_sm_disk_create
+dm_sm_disk_open
+dm_sm_metadata_init
+dm_swap_table
+dm_tm_create
+do_add_page_to_bio
+d_obtain_alias
+doc_probe_device
+do_create
+do_file_open_root
+do_find_free_space
+do_open
+do_read_cache_page
+__d_path
+d_path
+drbd_nla_find_nested
+drbd_request_prepare
+drm_gem_map_dma_buf
+drm_gem_prime_import
+drm_prime_pages_to_sg
+drm_sysfs_create
+ds620_update_client
+dsa_switch_setup
+dummy_allocate_iso_context
+__d_unalias
+dwc3_alloc_one_event_buffer
+dw_dma_cyclic_prep
+dynamic_dname
+e100_request_firmware
+ebt_register_table
+ecm_alloc
+ecm_alloc_inst
+ecryptfs_do_create
+__ecryptfs_get_inode
+ecryptfs_lookup
+ecryptfs_mount
+edid_load
+eem_alloc
+eem_alloc_inst
+efivarfs_alloc_dentry
+efivarfs_lookup
+efs_get_parent
+efs_iget
+efs_nfs_get_inode
+emergency_read_begin
+enclosure_component_register
+enclosure_register
+encrypted_key_alloc
+eseqiv_alloc
+eventfd_ctx_fileget
+eventfd_fget
+eventfd_file_create
+exofs_get_page
+exofs_get_parent
+exofs_iget
+exofs_lookup
+exofs_mount
+exofs_new_inode
+exofs_nfs_get_inode
+exp_find_key
+exp_get_by_name
+exportfs_decode_fh
+ext2_acl_from_disk
+ext2_acl_to_disk
+ext2_get_acl
+ext2_get_inode
+ext2_get_page
+ext2_get_parent
+ext2_iget
+ext2_lookup
+ext2_new_inode
+ext2_nfs_get_inode
+ext3_acl_from_disk
+ext3_acl_to_disk
+ext3_get_acl
+ext3_get_parent
+ext3_iget
+ext3_journal_start_sb
+ext3_lookup
+ext3_new_inode
+ext3_nfs_get_inode
+ext3_orphan_get
+ext4_acl_from_disk
+ext4_acl_to_disk
+ext4_append
+ext4_ext_find_extent
+ext4_get_acl
+ext4_get_parent
+ext4_iget
+__ext4_journal_start_reserved
+__ext4_journal_start_sb
+ext4_lookup
+__ext4_new_inode
+ext4_nfs_get_inode
+ext4_orphan_get
+__ext4_read_dirblock
+extract_hostname
+extract_sharename
+f2fs_acl_from_disk
+f2fs_acl_to_disk
+f2fs_get_acl
+f2fs_get_parent
+f2fs_iget
+f2fs_lookup
+f2fs_new_inode
+f2fs_nfs_get_inode
+fanotify_add_new_mark
+fanotify_merge
+fat_build_inode
+fault_create_debugfs_attr
+fcoe_if_create
+fcoe_interface_create
+ff_dev_create
+__fh_to_dentry
+fib6_add_1
+fib_create_info
+fib_rules_register
+__file_cft
+file_open_root
+find_alloc_undo
+find_data_page
+find_devfreq_governor
+find_device_devfreq
+find_get_context
+find_hosted_bus
+find_keyring_by_name
+find_lively_task_by_vpid
+find_msg
+find_nfs_version
+find_subdir
+__flow_tbl_rehash
+__fmc_scan_sdb_tree
+follow_huge_addr
+follow_page_mask
+follow_trans_huge_pmd
+freeze_bdev
+freezer_css_alloc
+freq_reg_info_regd
+frontswap_register_ops
+__fscache_lookup_cache_tag
+fsm_init
+fsnotify_add_notify_event
+fsnotify_alloc_group
+fs_set_subtype
+ft_add_acl
+function_make
+fuse_d_add_directory
+fuse_get_dentry
+fuse_get_parent
+__fuse_get_req
+fuse_lookup
+fw_create_instance
+fwserial_claim_port
+g762_update_client
+gadget_config_name_strings_make
+gadgets_make
+gadget_strings_strings_make
+gc_probe
+generic_create_cred
+get_authorizer
+get_buffer
+get_cifs_acl_by_fid
+get_cifs_acl_by_path
+get_connect_authorizer
+get_cramfs_inode
+get_default_root
+__get_device_from_cb
+get_device_pmkids
+get_domain
+get_empty_filp
+get_fb_info
+get_free_i2c_dev
+geth_alloc
+geth_alloc_inst
+gether_connect
+gether_setup_name
+gether_setup_name_default
+get_highmem_page_buffer
+get_i2c
+get_key
+get_ldops
+get_lock_data_page
+get_mtd_device
+get_mtd_device_nm
+getname_flags
+get_net_ns_by_fd
+get_net_ns_by_pid
+get_new_cssid
+get_new_data_page
+get_node_page
+get_node_page_ra
+get_one_event
+__get_or_create_frag
+get_phy_device
+__get_policy_once
+_get_posix_acl
+get_raw_socket
+get_socket
+get_subdir
+get_sysctl
+get_tap_socket
+get_ticket_handler
+__get_txreq
+get_user_arg_ptr
+get_vfsmount_from_fd
+get_vlan
+gfs2_dirent_scan
+gfs2_dirent_search
+gfs2_dir_get_hash_table
+gfs2_dir_search
+gfs2_get_acl
+gfs2_get_dentry
+gfs2_inode_lookup
+__gfs2_lookup
+gfs2_lookup_by_inum
+gfs2_lookupi
+gfs2_lookup_simple
+gfs2_mount
+gfs2_mount_meta
+ghes_new
+gpio_keys_get_devtree_pdata
+gpio_leds_create_of
+gre_create
+gre_gso_segment
+gre_handle_offloads
+gru_alloc_gts
+gru_alloc_locked_gts
+gru_register_mmu_notifier
+gss_alloc_msg
+gss_create
+gss_create_cred
+gss_fill_context
+gss_setup_upcall
+halve
+hbcall_from_type
+__hci_cmd_sync_ev
+hci_connect
+hci_connect_acl
+hci_connect_le
+hci_connect_sco
+hci_get_cmd_complete
+hdlcdrv_register
+hfs_bmap_alloc
+hfs_bnode_create
+hfs_bnode_find
+hfs_bnode_split
+hfs_file_lookup
+hfs_lookup
+hfsplus_bmap_alloc
+hfsplus_bnode_create
+hfsplus_bnode_find
+hfsplus_file_lookup
+hfsplus_iget
+hfsplus_lookup
+hid_allocate_device
+hpfs_lookup
+hugetlb_cgroup_css_alloc
+hugetlb_file_setup
+hvc_alloc
+hwmon_device_register
+i2400m_get_device_info
+i2400m_msg_to_dev
+i2o_block_device_alloc
+i2o_block_request_alloc
+i2o_device_alloc
+i2o_iop_alloc
+i2o_msg_get
+i2o_msg_get_wait
+i2o_scsi_host_alloc
+i915_gem_context_get_hang_stats
+i915_gem_dmabuf_vmap
+i915_gem_map_dma_buf
+i915_gem_prime_import
+ialloc
+ib_alloc_fast_reg_mr
+ib_alloc_fast_reg_page_list
+ib_alloc_fmr
+ib_alloc_mw
+ib_alloc_xrcd
+ib_create_ah_from_wc
+ib_create_cm_id
+ib_create_fmr_pool
+ib_create_send_mad
+ib_create_srq
+ib_fmr_pool_map_phys
+__ib_open_qp
+ib_open_qp
+ib_redirect_mad_qp
+ib_register_mad_agent
+ib_register_mad_snoop
+ib_reg_phys_mr
+ib_sa_join_multicast
+ib_ucm_ctx_get
+ib_umem_get
+ib_uverbs_alloc_event_file
+ib_uverbs_unmarshall_recv
+icmp6_dst_alloc
+icmp_route_lookup
+icmpv6_route_lookup
+idle_thread_get
+id_map_alloc
+idr_replace
+ieee80211_add_iface
+ieee80211_key_alloc
+ieee80211_new_chanctx
+iget_xattr
+iio_channel_get_all
+iio_channel_get_all_cb
+iio_channel_get_sys
+ina209_update_device
+ina2xx_update_device
+inet_diag_lock_handler
+inet_frag_find
+inet_gso_segment
+inflate
+init_data_container
+init_desc
+init_inode_metadata
+init_ipath
+init_sdesc
+inotify_new_group
+input_devices_seq_start
+input_handlers_seq_start
+insert_with_overflow
+instance_create
+intel_framebuffer_create
+intel_framebuffer_create_for_mode
+intel_modeset_pipe_config
+intel_user_framebuffer_create
+internal_dev_create
+ioctx_alloc
+iommu_group_alloc
+ip6addrlbl_alloc
+ip6_dst_lookup_flow
+ip6mr_vif_seq_start
+ip6_sk_dst_lookup_flow
+ip6t_register_table
+ipath_alloc_devdata
+ipath_alloc_fmr
+ipath_alloc_pd
+ipath_alloc_ucontext
+ipath_create_ah
+ipath_create_cq
+ipath_create_qp
+ipath_create_srq
+ipath_get_dma_mr
+ipath_reg_phys_mr
+ipath_reg_user_mr
+ipcctl_pre_down_nolock
+ipc_lock
+ipc_lock_check
+ipc_obtain_object
+ipc_obtain_object_check
+ipddp_init
+ip_make_skb
+ipmr_mfc_seq_start
+ipmr_rt_fib_lookup
+ipmr_vif_seq_start
+ipoib_add_port
+ipoib_create_ah
+__ip_route_output_key
+ipt_register_table
+__ip_tunnel_create
+ipv6_add_addr
+ipv6_gso_segment
+ipv6_renew_options
+iscsi_iser_ep_connect
+iscsit_add_np
+iscsit_add_tiqn
+iscsit_tpg_add_network_portal
+isert_device_find_by_ib_dev
+isofs_export_get_parent
+isofs_export_iget
+isofs_iget
+isofs_lookup
+isp1760_register
+iwch_ah_create
+iwch_allocate_pd
+iwch_alloc_fast_reg_mr
+iwch_alloc_fastreg_pbl
+iwch_alloc_mw
+iwch_alloc_ucontext
+iwch_create_cq
+iwch_create_qp
+iwch_register_phys_mem
+iwch_reg_user_mr
+iw_create_cm_id
+iwl_drv_start
+jbd2__journal_start
+jc42_update_device
+jffs2_acl_from_medium
+jffs2_acl_to_medium
+jffs2_add_physical_node_ref
+jffs2_gc_fetch_inode
+jffs2_get_acl
+jffs2_iget
+jffs2_lookup
+jffs2_new_inode
+jffs2_setup_xattr_datum
+jffs2_write_dirent
+jffs2_write_dnode
+jfs_get_acl
+jfs_iget
+jfs_lookup
+jfs_nfs_get_inode
+journal_start
+kern_path_create
+kern_path_locked
+key_alloc
+key_create_or_update
+key_get_instantiation_authkey
+key_lookup
+keyring_alloc
+keyring_search
+keyring_search_aux
+__keyring_search_one
+key_type_lookup
+kmemleak_seq_start
+kvm_create_vm
+kvm_pfn_to_page
+l2cap_create_basic_pdu
+l2cap_create_connless_pdu
+l2cap_create_iframe_pdu
+l2cap_create_sframe_pdu
+l2cap_sock_alloc_skb_cb
+lbs_cfg_alloc
+__lbs_cmd_async
+__lbtf_cmd_async
+lcd_device_register
+lease_alloc
+lio_target_call_addnptotpg
+lio_target_call_coreaddtiqn
+lio_target_make_nodeacl
+lm75_update_device
+lm80_update_device
+load_msg
+lockd_create_svc
+lock_mount
+logfs_get_dd_page
+logfs_get_sb_device
+__logfs_iget
+logfs_mount
+logfs_new_inode
+logfs_new_meta_inode
+logfs_read_meta_inode
+lookup_bdev
+lookup_dcache
+__lookup_free_space_inode
+lookup_one_len
+lookup_real
+lookup_user_key
+lookup_vport
+lookup_znode
+loop_probe
+ltc4151_update_device
+ltc4261_update_device
+ltree_add_entry
+lzo_alloc_workspace
+lzo_init
+mac802154_add_iface
+macvtap_get_socket
+make_blackhole
+make_cluster
+make_comm
+make_netconsole_target
+make_node
+make_receive_sock
+_make_request
+make_send_sock
+make_space
+map_extent_mft_record
+map_mft_record_page
+matrix_keypad_parse_dt
+max1668_update_device
+max6639_update_device
+max6697_update_device
+max77686_get_regmap
+max77693_get_regmap
+max8998_i2c_parse_dt_pdata
+maybe_deliver
+__mb_cache_entry_find
+mca_cannibalize
+md_import_device
+mem_cgroup_css_alloc
+memdup_user
+mesh_path_add
+mgag200_user_framebuffer_create
+minix_iget
+minix_lookup
+__mkroute_output
+mlx4_alloc_cmd_mailbox
+mlx4_ib_alloc_fast_reg_mr
+mlx4_ib_alloc_fast_reg_page_list
+mlx4_ib_alloc_mw
+mlx4_ib_alloc_pd
+mlx4_ib_alloc_ucontext
+mlx4_ib_alloc_xrcd
+mlx4_ib_create_ah
+mlx4_ib_create_cq
+mlx4_ib_create_qp
+mlx4_ib_create_srq
+mlx4_ib_fmr_alloc
+mlx4_ib_get_dma_mr
+mlx4_ib_reg_user_mr
+mlx5_alloc_cmd_msg
+mlx5_ib_alloc_fast_reg_mr
+mlx5_ib_alloc_fast_reg_page_list
+mlx5_ib_alloc_pd
+mlx5_ib_alloc_ucontext
+mlx5_ib_alloc_xrcd
+mlx5_ib_create_ah
+mlx5_ib_create_cq
+mlx5_ib_create_qp
+mlx5_ib_create_srq
+mlx5_ib_get_dma_mr
+mlx5_ib_reg_user_mr
+mm_access
+mmc_alloc_card
+mmc_blk_alloc_req
+mmc_blk_ioctl_copy_from_user
+mon_text_read_wait
+mount_bdev
+mount_fs
+mount_mtd
+mount_mtd_aux
+mount_nodev
+mount_ns
+mount_pseudo
+mount_single
+mount_subtree
+mount_subvol
+mousedev_create
+mpls_gso_segment
+__mpol_dup
+mpol_new
+mqueue_get_inode
+mqueue_mount
+m_start
+mthca_ah_create
+mthca_alloc_fmr
+mthca_alloc_mailbox
+__mthca_alloc_mtt
+mthca_alloc_pd
+mthca_alloc_ucontext
+mthca_create_cq
+mthca_create_qp
+mthca_create_srq
+mthca_get_dma_mr
+mthca_init_user_db_tab
+mthca_reg_phys_mr
+mthca_reg_user_mr
+mwifiex_add_virtual_intf
+nand_get_flash_type
+nbd_find_request
+ncp_lookup
+__neigh_create
+nes_alloc_fast_reg_mr
+nes_alloc_fast_reg_page_list
+nes_alloc_mw
+nes_alloc_pd
+nes_alloc_ucontext
+nes_create_ah
+nes_create_cq
+nes_create_qp
+nes_reg_phys_mr
+nes_reg_user_mr
+net2272_probe_init
+netdev_create
+netlink_getsockbyfilp
+netlink_getsockbyportid
+new_mountpoint
+new_nbp
+new_node_page
+newpart
+new_read
+new_simple_dir
+new_vmap_block
+nfc_llcp_allocate_snl
+__nf_conntrack_alloc
+nfcsim_init_dev
+nfs3_get_cached_acl
+nfs3_proc_getacl
+_nfs41_free_stateid
+_nfs41_proc_sequence
+nfs4_acl_posix_to_nfsv4
+nfs4_alloc_client
+nfs4_alloc_slot
+nfs4_blk_decode_device
+nfs4_blk_get_deviceinfo
+nfs4blocklayout_register_sb
+nfs4_create_referral_server
+nfs4_create_sec_client
+nfs4_create_server
+nfs4_do_open
+nfs4_do_unlck
+nfs4_find_or_create_slot
+nfs4_init_client
+nfs4_insert_state_owner_locked
+nfs4_label_alloc
+_nfs4_opendata_reclaim_to_nfs4_state
+_nfs4_opendata_to_nfs4_state
+nfs4_open_recoverdata_alloc
+nfs4_pathname_string
+nfs4_proc_layoutget
+nfs4_proc_lookup_mountpoint
+nfs4_remote_referral_mount
+nfs4_state_find_open_context
+nfs4_try_open_cached
+nfs_alloc_client
+nfs_async_rename
+nfs_callback_create_svc
+nfs_clone_server
+nfs_create_request
+nfs_create_server
+nfsd4_cld_register_sb
+nfs_d_automount
+nfsd_get_posix_acl
+nfs_do_refmount
+nfs_do_root_mount
+nfs_do_submount
+nfs_find_and_lock_request
+nfs_follow_referral
+nfs_follow_remote_path
+nfs_found_client
+nfs_fs_mount
+nfs_get_lock_context
+nfs_get_root
+nfs_idmap_request_key
+nfs_init_client
+nfs_lookup
+nf_sockopt_find
+nfs_path
+nfs_readdir_get_array
+nfs_submount
+nfs_try_mount_request
+nfs_try_to_update_request
+nilfs_get_dentry
+nilfs_get_page
+nilfs_get_parent
+nilfs_iget
+nilfs_iget_for_gc
+nilfs_lookup
+nilfs_mount
+nilfs_new_inode
+nl80211_parse_connkeys
+__nlm_async_call
+nlmclnt_init
+nnode_lookup
+notifier_err_inject_init
+nouveau_connector_create
+nouveau_gem_prime_import_sg_table
+nouveau_gem_prime_vmap
+nouveau_user_framebuffer_create
+ntfs_attr_find_vcn_nolock
+ntfs_attr_iget
+ntfs_cluster_alloc
+ntfs_get_parent
+ntfs_iget
+ntfs_index_iget
+ntfs_lookup
+ntfs_map_page
+ntfs_mapping_pairs_decompress
+ntfs_mft_record_alloc
+ntfs_nfs_get_inode
+ntfs_rl_realloc
+ntfs_runlists_merge
+nv04_pm_clocks_pre
+nv40_pm_clocks_pre
+nv50_pm_clocks_pre
+nva3_pm_clocks_pre
+nvc0_pm_clocks_pre
+nvme_create_queue
+nvme_map_user_pages
+o2hb_heartbeat_group_make_item
+o2hb_setup_one_bio
+o2nm_cluster_group_make_group
+o2nm_node_group_make_item
+oaktrail_rfkill_new
+objlayout_alloc_lseg
+ocfs2_acl_from_xattr
+ocfs2_acl_to_xattr
+ocfs2_begin_quota_recovery
+ocfs2_extend_local_quota_file
+ocfs2_find_free_entry
+ocfs2_get_acl
+ocfs2_get_acl_nolock
+ocfs2_get_dentry
+ocfs2_get_parent
+ocfs2_iget
+ocfs2_iop_get_acl
+ocfs2_local_quota_add_chunk
+ocfs2_lookup
+ocfs2_start_trans
+ocfs2_zero_start_ordered_transaction
+ocrdma_alloc_lkey
+ocrdma_alloc_pd
+ocrdma_alloc_ucontext
+ocrdma_create_ah
+ocrdma_create_cq
+ocrdma_create_qp
+ocrdma_create_srq
+ocrdma_reg_user_mr
+of_clk_get_by_name
+of_get_fixed_voltage_config
+of_get_gpio_regulator_config
+of_node_to_pwmchip
+of_pwm_get
+of_pwm_simple_xlate
+of_pwm_xlate_with_flags
+__of_usb_find_phy
+ohci_allocate_iso_context
+omap_get_control_dev
+omfs_find_entry
+omfs_iget
+omfs_lookup
+omfs_new_inode
+omfs_scan_list
+open_exec
+open_mtd_by_chdev
+open_root_dentry
+open_ubi
+open_xa_dir
+open_xa_root
+opp_find_freq_ceil
+opp_find_freq_floor
+opp_get_notifier
+osdmap_apply_incremental
+osdmap_decode
+osduld_info_lookup
+osduld_path_lookup
+ovs_dp_cmd_build_info
+ovs_flow_actions_alloc
+ovs_flow_alloc
+ovs_flow_cmd_build_info
+ovs_vport_add
+ovs_vport_alloc
+ovs_vport_cmd_build_info
+oxu_create
+p9_client_attach
+p9_client_create
+p9_client_getattr_dotl
+p9_client_prepare_req
+p9_client_rpc
+p9_client_stat
+p9_client_walk
+p9_client_xattrwalk
+p9_client_zc_rpc
+p9_conn_create
+p9_fid_create
+p9_idpool_create
+p9_tag_alloc
+padata_get_next
+parse_acl_data
+parse_path
+parse_priority_group
+path_openat
+pciserial_init_ports
+pcpu_build_alloc_info
+pcrypt_alloc
+pcrypt_alloc_instance
+pem_update_device
+perf_cgroup_css_alloc
+perf_event_alloc
+perf_event_create_kernel_counter
+perf_init_event
+persistent_ram_new
+pfkey_msg2xfrm_state
+pfkey_xfrm_policy2msg_prep
+__pfkey_xfrm_state2msg
+phy_attach
+phy_connect
+platform_create_bundle
+platform_device_register_full
+pm_ctrl_init
+pn533_send_cmd_sync
+pnfs_layout_process
+pnode_lookup
+pool_create
+__pool_find
+posix_acl_from_disk
+posix_acl_from_mode
+posix_acl_from_xattr
+posix_acl_to_disk
+posix_state_to_acl
+process_lvol
+proc_lookup_de
+proc_lookupfd_common
+proc_map_files_lookup
+proc_mount
+proc_ns_dir_lookup
+proc_ns_fget
+proc_ns_follow_link
+proc_ns_get_dentry
+proc_pident_lookup
+proc_pid_follow_link
+proc_pid_lookup
+proc_sys_lookup
+proc_task_lookup
+proc_tgid_net_lookup
+psb_framebuffer_create
+psb_user_framebuffer_create
+pt1_alloc_adapter
+ptm_unix98_lookup
+ptp_clock_register
+ptrace_get_task_struct
+ptrace_register_breakpoint
+pts_unix98_lookup
+pwm_get
+pwm_request
+pwm_request_from_chip
+qdisc_alloc
+qdisc_get_stab
+qib_alloc_devdata
+qib_alloc_fast_reg_page_list
+qib_alloc_pd
+qib_alloc_ucontext
+qib_create_ah
+qib_create_cq
+qib_create_qp
+qib_create_qp0_ah
+qib_create_srq
+qib_init_iba6120_funcs
+qib_init_iba7220_funcs
+qib_init_iba7322_funcs
+qib_reg_user_mr
+qla1280_request_firmware
+qla4xxx_ep_connect
+qnx4_iget
+qnx6_iget
+qnx6_lookup
+quotactl_block
+r2hb_hb_group_make_item
+r2nm_cluster_group_make_group
+r2nm_node_group_make_item
+radeon_gem_prime_import_sg_table
+radeon_gem_prime_vmap
+radeon_user_framebuffer_create
+raid0_takeover
+raid0_takeover_raid1
+raid0_takeover_raid10
+raid0_takeover_raid45
+raid10_takeover
+raid10_takeover_raid0
+raid1_takeover
+raid45_takeover_raid0
+raid4_takeover
+raid5_takeover
+raid5_takeover_raid1
+raid5_takeover_raid6
+raid6_takeover
+rbd_client_create
+rbd_dev_v2_snap_name
+rb_move_tail
+rdma_alloc_frmr
+rdma_create_id
+__rds_conn_create
+rds_ib_alloc_fmr
+rds_ib_create_mr_pool
+rds_ib_get_mr
+rds_iw_alloc_mr
+rds_iw_create_mr_pool
+rds_iw_get_mr
+rds_iw_map_scatterlist
+rds_message_map_pages
+read_add_inode
+__read_cache_page
+read_link
+reg_copy_regd
+reg_create
+__register_chrdev_region
+_register_divider
+register_ip_vs_app
+register_session
+register_wide_hw_breakpoint
+regmap_field_alloc
+regmap_init
+regmap_mmio_gen_context
+_regulator_get
+regulator_register
+reg_umr
+reiserfs_get_acl
+reiserfs_get_page
+reiserfs_get_parent
+reiserfs_iget
+reiserfs_lookup
+remove_pmkid
+request_asymmetric_key
+request_key
+request_key_and_link
+request_key_auth_new
+request_key_with_auxdata
+reserve_sfa_size
+reset_control_get
+resolv_usage_page
+rndis_alloc
+rndis_alloc_inst
+romfs_iget
+romfs_lookup
+romfs_mount
+rom_init
+__root_device_register
+rpcauth_create
+rpcauth_lookup_credcache
+rpcb_create
+rpc_bind_new_program
+__rpc_clone_client
+rpc_create
+rpc_lookup
+__rpc_lookup_create_exclusive
+rpc_mkpipe_data
+rpc_new_client
+rpc_new_task
+rpcrdma_create_id
+rpc_verify_header
+rp_find_vq
+rqst_exp_find
+rqst_exp_get_by_name
+rtc_device_register
+rtl8139_init_board
+rtm_to_ifaddr
+rtnl_create_link
+rxrpc_accept_call
+rxrpc_alloc_client_call
+rxrpc_find_peer
+rxrpc_get_bundle
+rxrpc_get_client_call
+rxrpc_get_null_key
+rxrpc_get_peer
+rxrpc_get_transport
+rxrpc_incoming_call
+rxrpc_incoming_connection
+rxrpc_kernel_begin_call
+rxrpc_lookup_local
+rxrpc_name_to_transport
+sbp_get_lun_from_tpg
+sbp_make_nodeacl
+sbp_make_tpg
+sbp_make_tport
+sbp_management_agent_register
+sbp_session_create
+sbp_target_agent_register
+scan_for_dirty
+scan_for_leb_for_idx
+scan_get_nnode
+scan_get_pnode
+sch5627_update_device
+sch5636_update_device
+sched_create_group
+scrub_setup_ctx
+__scsi_add_device
+scsi_devinfo_lookup_by_key
+sctp_datamsg_from_user
+sdhci_alloc_host
+sdhci_pci_probe_slot
+sdhci_pltfm_init
+sdio_alloc_func
+search_process_keyrings
+securityfs_create_file
+select_bad_process
+select_one_root
+sel_make_dir
+sem_obtain_lock
+seqiv_alloc
+setup_conf
+setup_essiv_cpu
+setup_vq
+sfi_check_table
+sg_alloc
+sget
+sg_get_dev
+shmem_file_setup
+shmem_get_parent
+shmem_read_mapping_page_gfp
+simple_get_bytes
+simple_get_netobj
+simple_lookup
+simple_transaction_get
+__skb_gso_segment
+skb_mac_gso_segment
+skb_segment
+skb_udp_tunnel_segment
+skcipher_geniv_alloc
+smb2_setup_async_request
+smb2_setup_request
+sm_get_zone
+smm665_update_device
+sock_alloc_file
+solo_enc_alloc
+split
+split_token_from_name
+squashfs_decompressor_init
+squashfs_export_iget
+squashfs_iget
+squashfs_read_fragment_index_table
+squashfs_read_id_index_table
+squashfs_read_inode_lookup_table
+squashfs_read_table
+squashfs_read_xattr_id_table
+squashfs_xz_init
+srp_rport_add
+srpt_make_nodeacl
+srpt_make_tpg
+srpt_make_tport
+ssb_hcd_create_pdev
+ssc_request
+s_start
+start_transaction
+stmpe_keypad_of_probe
+strndup_user
+svc_bc_create_socket
+svc_create_socket
+svc_get_next_xprt
+svc_prepare_thread
+svc_rdma_create
+svc_setup_socket
+__svc_xpo_create
+svm_create_vcpu
+syscon_node_to_regmap
+syscon_regmap_lookup_by_compatible
+syscon_regmap_lookup_by_pdevname
+syscon_regmap_lookup_by_phandle
+sysctl_getname
+sysctl_head_grab
+sysfs_lookup
+sysfs_mount
+sysv_iget
+sysv_lookup
+sysv_new_inode
+t4_uld_add
+target_core_call_addhbatotarget
+target_core_make_subdev
+target_core_mappedlun_stat_mkdir
+target_core_port_stat_mkdir
+target_core_register_fabric
+target_core_stat_mkdir
+target_fabric_configfs_init
+target_fabric_make_lun
+target_fabric_make_mappedlun
+target_fabric_make_nodeacl
+target_fabric_make_np
+target_fabric_make_tpg
+target_fabric_make_wwn
+tca6507_led_dt_init
+tcf_action_get_1
+tcf_action_init
+tcf_action_init_1
+tcf_hash_create
+tcm_loop_make_naa_tpg
+tcm_loop_make_scsi_hba
+tcm_qla2xxx_make_lport
+tcm_qla2xxx_make_nodeacl
+tcm_qla2xxx_make_tpg
+tcm_qla2xxx_npiv_make_lport
+tcm_qla2xxx_npiv_make_tpg
+tcp_tso_segment
+textsearch_prepare
+tgfx_probe
+thermal_cooling_device_register
+thermal_zone_device_register
+thermal_zone_get_zone_by_name
+timers_start
+tipc_alloc_conn
+tmp401_update_device
+tomoyo_get_absolute_path
+tomoyo_get_dentry_path
+tomoyo_get_local_path
+tracepoint_entry_add_probe
+tracepoint_entry_remove_probe
+tracepoint_remove_probe
+__tracing_open
+transport_init_session
+try_get_usb_function_instance
+try_location
+ttm_dma_pool_init
+__tty_alloc_driver
+tty_init_dev
+tty_ldisc_get
+tty_lookup_driver
+tty_open_current_tty
+tty_register_device_attr
+tun_alloc_skb
+tun_get_socket
+ubi_early_get_peb
+ubifs_get_nnode
+ubifs_get_pnode
+ubifs_iget
+ubifs_load_znode
+ubifs_lookup
+ubifs_lpt_lookup
+ubifs_lpt_lookup_dirty
+ubifs_mount
+ubifs_new_inode
+ubifs_read_sb_node
+ubifs_recover_leb
+ubifs_recover_log_leb
+ubifs_scan
+ubifs_start_scan
+ubifs_tnc_next_ent
+ubi_open_volume
+ubi_open_volume_nm
+ubi_open_volume_path
+_ucma_find_context
+udf_get_parent
+udf_lookup
+udf_nfs_get_inode
+udl_fb_user_fb_create
+udl_gem_prime_import
+udp4_ufo_fragment
+udp6_ufo_fragment
+ufs_get_locked_page
+ufs_get_page
+ufs_get_parent
+ufs_iget
+ufs_lookup
+ufs_new_inode
+ufs_nfs_get_inode
+u_memcpya
+unix_gid_find
+__unlink_start_trans
+unpack_dfa
+unpack_profile
+unx_create_cred
+update_pmkid
+usb_cdc_wdm_register
+__usb_find_phy
+__usb_find_phy_dev
+usb_get_function_instance
+usb_gstrings_attach
+use_block_rsv
+user_path_parent
+uvesafb_vbe_state_save
+uwb_rc_neh_add
+V1_minix_iget
+V2_minix_iget
+v4l2_clk_find
+v4l2_clk_register
+v4l2_m2m_ctx_init
+v4l2_m2m_init
+v9fs_create
+v9fs_fid_lookup_with_uid
+__v9fs_get_acl
+v9fs_get_inode
+v9fs_mount
+v9fs_qid_iget
+v9fs_qid_iget_dotl
+v9fs_session_init
+v9fs_vfs_lookup
+v9fs_writeback_fid
+vb2_dc_alloc
+vb2_dc_attach_dmabuf
+vb2_dc_dmabuf_ops_map
+vb2_dc_get_userptr
+vb2_dma_contig_init_ctx
+vb2_vmalloc_attach_dmabuf
+verdict_instance_lookup
+vfat_lookup
+vfio_create_group
+vfio_group_create_device
+vfio_iommu_type1_open
+vfs_kern_mount
+vhost_net_ubuf_alloc
+video_output_register
+virtio_find_single_vq
+vma_to_resize
+vmci_ctx_create
+vm_setup_vq
+vmstat_start
+vmw_kms_fb_create
+vmx_create_vcpu
+vxfs_get_page
+__vxfs_iget
+vxfs_iget
+vxfs_lookup
+vxlan_socket_create
+wait_on_page_read
+wakelock_lookup_add
+wil_cfg80211_init
+wil_if_alloc
+wimax_gnl_re_state_change_alloc
+wimax_msg_alloc
+wl1251_alloc_hw
+wl12xx_get_platform_data
+wlcore_alloc_hw
+x509_cert_parse
+xattr_lookup
+xen_blkif_alloc
+xenbus_dev_request_and_reply
+xen_copy_pss_data
+xennet_create_dev
+xenvif_alloc
+xfrm6_dst_lookup
+xfrm_alloc_dst
+xfrm_bundle_lookup
+__xfrm_dst_lookup
+xfrm_lookup
+xfrm_policy_lookup_bytype
+xfrm_policy_netlink
+xfrm_resolve_and_create_bundle
+xfrm_sk_policy_lookup
+xfrm_state_netlink
+xfs_acl_from_disk
+xfs_fs_get_parent
+xfs_get_acl
+xfs_handle_to_dentry
+xfs_nfs_get_inode
+xfs_vn_ci_lookup
+xfs_vn_lookup
+xlog_alloc_log
+xpc_create_gru_mq_uv
+xprt_create_transport
+xprt_dynamic_alloc_slot
+xprt_setup_rdma
+xs_create_sock
+xs_setup_bc_tcp
+xs_setup_local
+xs_setup_tcp
+xs_setup_udp
+xs_setup_xprt
+xs_talkv
+xt_find_match
+xt_find_table_lock
+xt_find_target
+xt_hook_link
+xt_register_table
+zlib_alloc_workspace
+zlib_init
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.returns_err_ptr.remove b/usr/src/tools/smatch/src/smatch_data/kernel.returns_err_ptr.remove
new file mode 100644
index 0000000000..731bb079f6
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.returns_err_ptr.remove
@@ -0,0 +1,3 @@
+jedec_probe
+find_inode
+lookup_extent_mapping
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.returns_held_funcs b/usr/src/tools/smatch/src/smatch_data/kernel.returns_held_funcs
new file mode 100644
index 0000000000..749686ba79
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.returns_held_funcs
@@ -0,0 +1,23 @@
+// list of functions that return a held device.
+// generated by `gen_returns_held.sh`
+dev_get_by_index
+dev_get_by_macvtap_minor
+dev_get_by_name
+dev_to_net_device
+dn_dev_get_default
+find_lec_by_itfnum
+get_vlan
+ieee802154_get_dev
+ieee802154_nl_get_dev
+ip6mr_reg_vif
+__ip_dev_find
+ipmr_new_tunnel
+ipmr_reg_vif
+mac802154_add_iface
+nr_ax25_dev_get
+nr_dev_first
+nr_dev_get
+phonet_device_get
+phonet_route_output
+rose_dev_get
+x25_dev_get
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.rosenberg_funcs b/usr/src/tools/smatch/src/smatch_data/kernel.rosenberg_funcs
new file mode 100644
index 0000000000..858a30af97
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.rosenberg_funcs
@@ -0,0 +1,73 @@
+// list of copy_to_user function and buffer parameters.
+// generated by `gen_rosenberg_funcs.sh`
+bits_to_user 0
+cfs_trace_copyout_string 2
+compat_copy_entry_to_user 0
+compat_filldir 1
+compat_filldir64 1
+copy_gctl_to_user 2
+copy_msqid_to_user 1
+copy_semid_to_user 1
+copy_shmid_to_user 1
+copy_shminfo_to_user 1
+copy_to 1
+__copy_to_user 1
+copy_to_user 1
+crystalhd_user_data 1
+csum_partial_copy_to_user 1
+diva_os_copy_to_user 1
+diva_os_copy_to_user 2
+divas_maint_read 1
+divas_maint_write 1
+divas_um_idi_copy_to_user 1
+drm_copy_field 2
+echo_copyout_lsm 0
+fat_compat_ioctl_filldir 1
+fat_ioctl_filldir 1
+fd_copyout 1
+filldir 1
+filldir64 1
+gnet_stats_copy 2
+gnet_stats_copy_app 1
+gnet_stats_copy_queue 1
+gru_user_copy_handle 1
+ib_copy_to_udata 1
+kernel_termios_to_user_termios 1
+kernel_termios_to_user_termios_1 1
+kfifo_copy_to_user 1
+__kfifo_to_user 1
+libcfs_ioctl_popdata 1
+maint_read_write 0
+memcpy_toiovec 1
+memcpy_toiovecend 1
+mic_virtio_copy_to_user 1
+mic_vringh_copy 2
+nla_put 3
+nla_put_string 2
+nvme_trans_copy_to_user 1
+nvme_trans_supported_vpd_pages 2
+nvme_trans_unit_serial_page 2
+obd_ioctl_popdata 1
+putused_user 1
+put_v4l2_input32 0
+put_v4l2_pix_format 0
+put_v4l2_pix_format_mplane 0
+put_v4l2_sliced_vbi_format 0
+put_v4l2_vbi_format 0
+seq_copy_in_user 1
+set_arg 1
+set_fd_set 2
+str_to_user 0
+uinput_str_to_user 1
+__videobuf_copy_stream 1
+__videobuf_copy_to_user 1
+xdi_copy_to_user 1
+xdi_copy_to_user 2
+xfer_to_user 1
+xfrm_mark_put 1
+xfs_bulkstat_one_fmt 3
+xfs_getbmap_format 1
+xfs_getbmapx_format 1
+xfs_inumbers_fmt 1
+xt_compat_match_to_user 0
+xt_compat_target_to_user 0
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.silenced_functions b/usr/src/tools/smatch/src/smatch_data/kernel.silenced_functions
new file mode 100644
index 0000000000..e23ef2635f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.silenced_functions
@@ -0,0 +1,12 @@
+/* Don't print anything from these functions */
+atomic_dec_and_test
+atomic_inc_and_test
+atomic64_dec_and_test
+atomic_sub_and_test
+test_and_clear_bit
+test_and_set_bit
+__copy_to_user_nocheck
+__copy_from_user_nocheck
+arch_static_branch
+__static_cpu_has
+__read_once_size
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.sizeof_param b/usr/src/tools/smatch/src/smatch_data/kernel.sizeof_param
new file mode 100644
index 0000000000..80bb5b2cc3
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.sizeof_param
@@ -0,0 +1,472 @@
+// list of function parameters that are the size of a buffer.
+// generated by `gen_sizeof_param.sh`
+access_process_vm 3 2
+acpi_os_unmap_memory 1 0
+add_device_randomness 1 0
+add_numbered_child 4 3
+adpt_i2o_post_wait 2 1
+adpt_i2o_query_scalar 5 4
+adv7170_write_block 2 1
+adv7175_write_block 2 1
+af9013_write_ofsm_regs 3 2
+af9015_read_regs 3 2
+af9033_rd_regs 3 2
+anysee_ctrl_msg 2 1
+anysee_ctrl_msg 4 3
+asd_read_flash_seg 3 1
+asd_read_ocm_seg 3 1
+async_set_registers 2 3
+at76_get_mib 3 2
+ata_dev_config_ncq 2 1
+ata_exec_internal 5 4
+ata_id_c_string 3 1
+ath10k_dbg_dump 4 3
+ath10k_pci_diag_write_mem 3 2
+ath6kl_init_get_fwcaps 2 1
+ath6kl_wmi_add_wow_pattern_cmd 3 5
+ath9k_hw_name 2 1
+atmel_copy_to_card 3 2
+bch_bkey_to_text 1 0
+bch_btree_to_text 1 0
+be_roce_mcc_cmd 2 1
+be_wrb_cmd_hdr_prepare 3 0
+be_wrb_hdr_prepare 1 0
+bitmap_scnprintf 1 0
+blkg_path 2 1
+bluecard_read 3 2
+bnep_send 2 1
+bnx2fc_initiate_els 3 2
+brcmf_fil_bsscfg_data_set 3 2
+brcmf_fil_iovar_data_get 3 2
+bt819_write_block 2 1
+bt_get_result 2 1
+btrfs_insert_item 4 3
+bt_start_transaction 2 1
+__builtin_memset 2 0
+bulk_w 3 2
+calc_hmac 2 1
+calc_mic_tx_frag 2 1
+ceph_osdmap_state_str 1 0
+ceph_x_encrypt 4 3
+cfg80211_get_p2p_attr 4 3
+cfg80211_tx_mlme_mgmt 2 1
+ckhdid_printf 1 0
+__clear_user 1 0
+clear_user 1 0
+cmd_complete 5 4
+cmsghdr_from_user_compat_to_kern 3 2
+_config_request 5 4
+console_cont_flush 1 0
+__copy_from_user 2 0
+copy_from_user 2 0
+__copy_from_user_inatomic 2 0
+copy_from_user_nmi 2 0
+copy_in_user 2 0
+copy_in_user 2 1
+__copy_to_user 2 1
+copy_to_user 2 1
+cpulist_scnprintf 1 0
+cpumask_scnprintf 1 0
+create_syslog_header 2 1
+csio_enqueue_evt 3 2
+csio_hostname 1 0
+csio_osname 1 0
+csum_partial 1 0
+cx18_eeprom_dump 2 1
+cxd2820r_rd_regs 3 2
+cxusb_ctrl_msg 3 2
+cyapa_i2c_reg_write_block 2 3
+cyttsp4_adap_read 2 3
+dbg_chgconf 2 1
+dbg_chgstat 1 0
+dbg_command_buf 1 0
+dbg_intr_buf 1 0
+dbg_port_buf 1 0
+dbg_regstat 1 0
+dbg_status_buf 1 0
+derived_key_decrypt 2 1
+derived_key_encrypt 2 1
+dgrp_dpa 2 1
+dgrp_monitor 2 1
+__d_head 1 0
+digsig_verify_rsa 4 3
+DIVA_DIDD_Read 1 0
+dma_free_attrs 1 2
+dma_map_single_attrs 2 1
+dmi_format_ids 1 0
+domain_flush_cache 2 1
+d_path 2 1
+ds2780_battery_io 3 1
+ds2780_write 3 1
+ds2781_battery_io 3 1
+ds2781_write 3 1
+ds_recv_data 2 1
+ds_recv_status_nodump 3 2
+dst_put_ci 2 1
+dump_emit 2 1
+dvb_play_kernel 2 1
+early_iounmap 1 0
+ec_transaction 2 1
+edac_dimm_info_location 2 1
+edt_ft5x06_ts_readwrite 1 2
+edt_ft5x06_ts_readwrite 3 4
+efx_mcdi_rpc 3 2
+efx_mcdi_rpc 5 4
+efx_mcdi_rpc_finish 4 3
+enc28j60_mem_read 2 3
+evergreen_hdmi_update_avi_infoframe 2 1
+fast_mix 2 1
+fcoe_wwn_to_str 2 1
+fill_note 3 4
+frag_safe_skb_hp 2 3
+fw_csr_string 3 2
+garmin_write_bulk 2 1
+get_atrandom_bytes 1 0
+get_fw_name 2 1
+get_jack_mode_name 3 2
+get_modalias 2 1
+get_name 3 1
+get_random_bytes 1 0
+get_registers 2 3
+get_rhf_errstring 2 1
+gnet_stats_copy 3 2
+gru_get_cb_exception_detail_str 3 2
+gru_send_message_gpa 2 1
+gspca_frame_add 3 2
+h5_link_control 2 1
+__hci_cmd_sync 2 3
+hci_req_add 2 3
+hdmi_audio_infoframe_pack 2 1
+hdmi_avi_infoframe_pack 2 1
+hdmi_print_pcm_rates 2 1
+hex_dump_to_buffer 1 0
+hex_dump_to_buffer 5 4
+hfa384x_from_aux 2 3
+hfa384x_from_bap 3 2
+hfa384x_to_aux 2 3
+hp_wmi_perform_query 3 2
+__hw_addr_add 2 1
+i2400m_bm_cmd 2 1
+i2400m_msg_check_status 2 1
+i2400m_msg_to_dev 2 1
+__i2400mu_send_barker 2 1
+i2c_master_recv 2 1
+i2c_master_send 2 1
+i2c_read_demod_bytes 3 2
+i2c_read_eeprom 4 3
+i2c_smbus_read_i2c_block_data 2 3
+i2c_smbus_write_i2c_block_data 2 3
+i2c_w 3 2
+i2c_write_demod_bytes 2 1
+i2o_parm_issue 3 2
+i2o_parm_table_get 7 6
+ib_copy_to_udata 2 1
+ic_bootp_string 3 0
+init_cdrom_command 2 1
+input_bits_to_string 1 0
+intel_sdvo_get_value 3 2
+intel_sdvo_write_infoframe 4 3
+__iommu_flush_cache 2 1
+ipath_decode_err 2 1
+__ipr_format_res_path 2 1
+ipr_format_res_path 3 2
+ip_vs_dbg_addr 2 1
+ip_vs_dbg_callid 1 0
+ipw2100_get_fwversion 2 1
+ipw2100_get_ucodeversion 2 1
+ipw_send_cmd_pdu 2 3
+irnet_read_discovery_log 2 1
+iscsi_if_send_reply 6 5
+isdn_tty_getdial 2 1
+isl12022_read_regs 3 2
+it913x_io 7 6
+it913x_read_reg 3 2
+iwl_dvm_send_cmd_pdu 3 4
+iwl_mvm_send_cmd_pdu 3 4
+jdvbt90502_reg_read 3 2
+kdb_getstr 1 0
+key_get_type_from_user 2 0
+kmemcheck_mark_initialized 1 0
+kmemdup 1 0
+kmsg_dump_get_line_nolock 3 2
+ks8995_read 3 1
+kvm_read_guest_cached 3 2
+kvm_read_guest_page_mmu 5 3
+kvm_read_nested_guest_page 4 2
+l2cap_send_cmd 3 4
+ldm_get_vstr 2 1
+line6_read_data 3 2
+lme2510_usb_talk 2 1
+lme2510_usb_talk 4 1
+lme2510_usb_talk 4 3
+logfs_crc32 1 0
+logfs_inode_write 2 1
+lpfc_nlp_state_name 1 0
+match_strlcpy 2 0
+mce_async_out 2 1
+memchr 2 0
+memcmp 2 0
+memcmp 2 1
+memcpy 2 0
+memcpy 2 1
+memcpy_fromio 2 0
+memcpy_toio 2 1
+memdup_user 1 0
+memmove 2 0
+memmove 2 1
+memset 2 0
+memset_io 2 0
+mgmt_event 3 2
+mgmt_exec_nonemb_cmd 3 2
+mgmt_pending_add 4 3
+mlx5_cmd_exec 2 1
+mlx5_cmd_exec 4 3
+mlx5_core_create_mkey 3 2
+mlx5_core_eq_query 3 2
+mlx5_core_qp_modify 4 3
+mlx5_core_qp_query 3 2
+mma8450_read_block 3 2
+modecpy 2 1
+mpol_to_str 1 0
+msg_print_text 4 3
+mt2060_writeregs 2 1
+mt2131_writeregs 2 1
+mt2266_writeregs 2 1
+mt312_read 3 2
+mt312_write 3 2
+_mt352_write 2 1
+mt352_write 2 1
+musb_write_fifo 1 2
+mwifiex_copy_rates 3 2
+mwl8k_cmd_name 2 1
+mwl8k_send_fw_load_cmd 2 1
+__mxt_read_reg 2 3
+my_hd 1 0
+ncp_add_mem 2 1
+next_entry 2 0
+nf_nat_ftp_fmt_cmd 3 2
+nla_memcmp 2 1
+nla_put 2 3
+nla_strlcpy 2 0
+nlmsg_perm 3 2
+nouveau_pm_perflvl_info 2 1
+o2hb_debug_create 5 7
+o2hb_fill_node_map 1 0
+o2hb_fill_node_map_from_callback 1 0
+o2net_fill_node_map 1 0
+o2net_sendpage 2 1
+o2nm_configured_node_map 1 0
+ocfs2_sprintf_system_inode_name 1 0
+ocrdma_copy_cpu_to_le32 2 0
+ocrdma_le32_to_cpu 1 0
+or51132_writebuf 2 1
+orinoco_get_wpa_ie 1 0
+oz_get_next_device_name 2 1
+p54spi_spi_read 3 2
+PC4500_readrid 3 2
+PC4500_writerid 3 2
+pcan_usb_pro_send_req 4 3
+pci_free_consistent 1 2
+pci_map_single 2 1
+pci_read_vpd 2 3
+pdu_read 2 1
+pep_reply 4 3
+persistent_ram_decode_rs8 2 1
+picolcd_send_and_wait 3 2
+pidff_find_fields 3 1
+pidff_find_special_keys 3 2
+platform_device_add_data 2 1
+pn_raw_send 1 0
+print_hex_dump 6 5
+print_hex_dump_bytes 3 2
+printvalue 2 1
+proc_get_long 5 4
+psb_intel_sdvo_get_value 3 2
+put_frag 2 1
+pvr2_hdw_report_clients 2 1
+pvr2_hdw_report_unlocked 3 2
+pvr2_ioread_set_sync_key 2 1
+pvr2_std_id_to_str 1 0
+qlt_sched_sess_work 3 2
+ql_write_cfg 2 1
+queue_event 3 2
+qword_get 2 1
+r2hb_fill_node_map_from_callback 1 0
+r2net_sendpage 2 1
+r600_hdmi_update_audio_infoframe 2 1
+r600_hdmi_update_avi_infoframe 2 1
+r820t_read 3 2
+r820t_write 3 2
+rdcat 3 2
+read_rom 2 3
+_recv 2 1
+reg_w 3 2
+reg_wb 4 3
+reg_w_buf 2 1
+reg_w_ixbuf 3 2
+reg_w_var 3 2
+rndis_set_oid 3 2
+root_nfs_cat 2 0
+rpc_ntop 2 1
+rpc_ntop4 2 1
+rpc_ntop6_noscopeid 2 1
+rsxx_creg_read 2 3
+rtl8723ae_fill_h2c_cmd 2 3
+rtl88e_fill_h2c_cmd 2 3
+rtl92c_fill_h2c_cmd 2 3
+rtl92d_fill_h2c_cmd 2 3
+rtn_scope 1 0
+rtn_type 1 0
+s35390a_get_reg 3 2
+s35390a_set_reg 3 2
+saa7110_write_block 2 1
+saa712x_write_regs 3 1
+saa7185_write_block 2 1
+scnprintf 1 0
+scnprint_id 2 1
+scsi_execute_req 4 3
+scsi_mode_sense 4 3
+scsi_sg_copy_from_buffer 2 1
+sctp_addto_chunk 1 2
+sctp_sf_abort_violation 6 5
+_send 2 1
+send_bulk_static_data 2 1
+sendcmd_withirq 3 2
+seq_write 2 1
+set_registers 2 3
+sg_copy_from_buffer 3 2
+sg_copy_to_buffer 3 2
+sg_init_one 2 1
+sg_set_buf 2 1
+si476x_cmd_tune_seek_freq 3 2
+si476x_cmd_tune_seek_freq 5 4
+si476x_core_i2c_xfer 3 2
+simple_read_from_buffer 4 3
+sirdev_raw_write 2 1
+skb_copy_to_linear_data 2 1
+skb_header_pointer 2 3
+sky2_name 2 1
+smp_send_cmd 2 3
+snd_hda_get_pin_label 4 3
+snd_info_get_line 2 1
+snd_info_get_str 2 0
+snd_midi_event_decode 2 1
+snd_mixart_send_msg 2 3
+snd_pcm_debug_name 2 1
+snd_print_channel_allocation 2 1
+snd_print_pcm_bits 2 1
+snd_rawmidi_kernel_read 2 1
+snd_rawmidi_transmit_peek 2 1
+snd_seq_expand_var_event 1 2
+snd_task_name 2 1
+snd_usb_caiaq_send_command 3 2
+snd_usb_ctl_msg 7 6
+snprint_line 1 0
+snprint_time 1 0
+sock_kfree_s 2 1
+solo_p2m_dma 4 2
+sort 2 0
+spi_read 2 1
+spi_write 2 1
+spi_write_then_read 2 1
+spi_write_then_read 4 3
+sprint_oid 3 2
+squashfs_read_metadata 4 1
+string_get_size 3 2
+stringify_lockname 3 2
+strlcat 2 0
+strlcpy 2 0
+strncat 2 0
+strncmp 2 0
+strncmp 2 1
+strncpy 2 0
+strncpy_from_user 2 0
+__svc_print_addr 2 1
+svc_print_addr 2 1
+svc_print_xprts 1 0
+sw_3dp_id 2 1
+swap_dws 1 0
+__sym_mfree 2 1
+synaptics_rmi4_i2c_block_read 3 2
+t4_wr_mbox 3 2
+tcp_fastopen_reset_cipher 1 0
+tda1004x_write_buf 3 2
+tda18212_wr_regs 3 2
+tda8083_readregs 3 2
+textify_hooks 1 0
+tipc_media_addr_printf 1 0
+tomoyo_addprintf 1 0
+tomoyo_print_ip 1 0
+tomoyo_print_ipv4 1 0
+tomoyo_print_ipv6 1 0
+tomoyo_print_ulong 1 0
+to_shortname_char 2 1
+tpm_inf_send 2 1
+tps6586x_reads 2 3
+tps6586x_writes 2 3
+trace_brcms_txdesc 2 1
+trace_i915_reg_rw 3 2
+trace_note 4 3
+ttsp_write_block_data 2 3
+ttusb2_msg 5 4
+ttusb_cmd 2 1
+ttusb_dec_send_command 2 3
+ttusb_result 2 1
+tuner_i2c_xfer_send 2 1
+tveeprom_read 2 1
+tw_transfer_internal 3 2
+ubi_io_read 4 1
+unicode_to_ascii 1 0
+usb_bulk_msg 3 2
+usb_control_msg 7 6
+usb_fill_bulk_urb 4 3
+usb_get_descriptor 4 3
+usb_make_path 2 1
+usbnet_read_cmd 6 5
+usb_stor_set_xfer_buf 1 0
+usb_string 3 2
+uwb_dev_addr_print 1 0
+uwb_mac_addr_print 1 0
+uwb_rc_cmd 3 2
+uwb_rc_vcmd 3 2
+valid_stack_ptr 2 1
+vic_provinfo_add_tlv 2 3
+vpx3220_write_block 2 1
+vscnprintf 1 0
+w1_ds2760_write 3 1
+w1_write_block 2 1
+wbuf_read 2 3
+wiimote_cmd_write 3 2
+wiimote_queue 2 1
+wil_memcpy_fromio_32 2 0
+wimax_addr_scnprint 1 0
+wl1251_cmd_configure 3 2
+wl1251_cmd_interrogate 3 2
+wl1251_cmd_send 3 2
+wl1251_mem_read 3 2
+wl1251_read_eeprom 3 2
+wl1271_cmd_configure 3 2
+wl1271_cmd_interrogate 3 2
+wl1271_cmd_send 3 2
+wl1271_cmd_template_set 4 3
+wl1271_cmd_test 2 1
+wl3501_set_to_wla 3 2
+wlcore_cmd_configure_failsafe 3 2
+wlcore_read 3 2
+wlcore_write 3 2
+write_extent_buffer 3 1
+write_rom 2 3
+wsm_read_mib 3 2
+wsm_write_mib 3 2
+wusb_key_dump 1 0
+wusb_prf_256 1 0
+wusb_prf_256 6 5
+xc_send_i2c_data 2 1
+xfrm_dst_alloc_copy 2 1
+xor8_buf 1 0
+yealink_set_ringtone 2 1
+zl10036_write 2 1
+zl10039_write 3 2
+zl10353_write 2 1
+zr36050_pushit 2 3
+zr36060_pushit 2 3
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.sizeof_param.remove b/usr/src/tools/smatch/src/smatch_data/kernel.sizeof_param.remove
new file mode 100644
index 0000000000..a547b46148
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.sizeof_param.remove
@@ -0,0 +1,13 @@
+printk
+find_first_zero_bit
+dvb_usb_generic_rw
+__dynamic_pr_debug
+strncmp
+strncpy 2 1
+strlcpy 2 1
+strncat 2 1
+snprintf
+copy_from_user 2 1
+copy_to_user 2 0
+read_rom 2 3
+skb_pull 1 -1
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.unconstant_macros b/usr/src/tools/smatch/src/smatch_data/kernel.unconstant_macros
new file mode 100644
index 0000000000..bafb4d28d4
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.unconstant_macros
@@ -0,0 +1,10 @@
+X86_VM_MASK
+VM_GROWSUP
+VM_SOFTDIRTY
+UBIFS_BLOCKS_PER_PAGE
+DYNTICK_TASK_NEST_MASK
+ARCH_SHF_SMALL
+SLAB_NOTRACK
+FAULT_FLAG_TRANSHUGE
+_PAGE_NX
+MAP_UNINITIALIZED
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.unreachable.ignore b/usr/src/tools/smatch/src/smatch_data/kernel.unreachable.ignore
new file mode 100644
index 0000000000..f12b5b83d5
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.unreachable.ignore
@@ -0,0 +1,25 @@
+list_for_each
+list_for_each_entry
+list_for_each_entry_safe
+list_for_each_entry_rcu
+list_for_each_entry_continue
+list_for_each_entry_continue_rcu
+hlist_for_each_entry
+hlist_for_each_entry_safe
+ax25_uid_for_each
+inet_twsk_for_each_inmate
+udp_portaddr_for_each_entry_rcu
+hlist_for_each_safe
+hlist_for_each_entry_rcu
+snd_pcm_group_for_each_entry
+DLM_ASSERT
+ata_for_each_dev
+netlbl_af4list_foreach_rcu
+netlbl_af6list_foreach_rcu
+for_primary_ifa
+sk_nulls_for_each
+unreachable
+iterate_all_kinds
+netdev_for_each_lower_dev
+for_each_clear_bit_from
+idr_for_each_entry_continue
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.unreachable.turn_off b/usr/src/tools/smatch/src/smatch_data/kernel.unreachable.turn_off
new file mode 100644
index 0000000000..b9fce103bc
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.unreachable.turn_off
@@ -0,0 +1,4 @@
+BUG
+panic
+LBUG
+ASSERT
diff --git a/usr/src/tools/smatch/src/smatch_data/kernel.unwind_functions b/usr/src/tools/smatch/src/smatch_data/kernel.unwind_functions
new file mode 100644
index 0000000000..0d09cde738
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/kernel.unwind_functions
@@ -0,0 +1,632 @@
+// list of unwind functions.
+// generated by `gen_unwind_functions.sh`
+_aac_reset_adapter
+aac_sa_init
+__aac_shutdown
+ace_init_cleanup
+acpi_os_remove_interrupt_handler
+ad5421_probe
+ad5421_remove
+ad5504_probe
+ad5504_remove
+ad714x_remove
+ad7150_probe
+ad7150_remove
+ad7280_remove
+ad7291_probe
+ad7291_remove
+ad7606_probe
+ad7606_remove
+ad7816_probe
+ad7816_remove
+ad7877_probe
+ad7879_remove
+ad799x_probe
+ad799x_remove
+adapter_down
+adapter_init
+adapter_uninit
+adis_probe_trigger
+adis_remove_trigger
+adm8211_probe
+adm8211_remove
+adp5588_irq_teardown
+adp5588_probe
+adp5588_remove
+adp5589_probe
+adp5589_remove
+adpt_i2o_delete_hba
+ads7846_probe
+adt7x10_remove
+adv7180_remove
+adxl34x_remove
+aer_remove
+ahc_platform_free
+ahd_platform_free
+airo_close
+ali_ircc_close
+altera_jtaguart_shutdown
+altera_uart_shutdown
+amd8111e_close
+amd8111e_open
+apds990x_remove
+arcmsr_remove
+arcrimi_found
+arizona_free_irq
+arizona_irq_exit
+ark_pci_probe
+ark_pci_remove
+asd_pci_probe
+asd_pci_remove
+ast_driver_unload
+at86rf230_probe
+at86rf230_remove
+ath10k_pci_probe
+ath10k_pci_remove
+ath5k_deinit_ah
+ath5k_init_ah
+ath5k_pci_probe
+ath5k_pci_remove
+atl1c_free_irq
+atl1_down
+atl1e_free_irq
+atl1_probe
+atl1_remove
+atl2_free_irq
+atp870u_probe
+aty_disable_irq
+axnet_close
+azx_free
+b43legacy_wireless_core_stop
+b43_wireless_core_stop
+b44_close
+bcma_host_pci_probe
+bcma_host_pci_remove
+bdx_hw_stop
+beiscsi_quiesce
+be_unmap_pci_bars
+bfad_pci_uninit
+bfad_remove_intr
+bh1770_remove
+blogic_relres
+bma150_remove
+bnx2i_free_hba
+bnx2_init_board
+bnx2_init_one
+bnx2x_free_irq
+__bnx2x_remove
+brcmf_sdio_intr_unregister
+brcms_free
+bu21013_free_irq
+c2_probe
+c2_register_device
+c2_remove
+c2_unregister_device
+c4_add_dev
+ca91cx42_irq_exit
+cafe_nand_probe
+cafe_nand_remove
+cafe_pci_probe
+cafe_shutdown
+carm_init_one
+carm_remove_one
+cas_init_one
+cas_remove_one
+cb710_suspend
+cc770_close
+c_can_close
+c_can_pci_probe
+c_can_pci_remove
+chd_dec_disable_int
+cleanup_dev
+cma3000_exit
+cma3000_init
+cmos_do_probe
+com20020_found
+com90io_found
+cp_tm1217_probe
+cp_tm1217_remove
+cros_ec_register
+cros_ec_remove
+csio_intr_disable
+cw1200_sdio_irq_unsubscribe
+cw1200_spi_irq_subscribe
+cw1200_spi_irq_unsubscribe
+cx23885_finidev
+cx25821_finidev
+cx8800_finidev
+cx8800_initdev
+cx8802_fini_common
+cxgb_down
+cy8ctmg110_probe
+cy8ctmg110_remove
+cyttsp4_remove
+cyttsp_remove
+da9052_free_irq
+DAC960_DetectCleanup
+dc390_probe_one
+de4x5_close
+deassign_host_irq
+deinit_card
+denali_irq_cleanup
+device_irq_exit
+devm_free_irq
+__devm_release_region
+dfx_close
+dfx_open
+disable_igfx_irq
+diva_os_remove_irq
+dm1105_probe
+dm1105_remove
+dmfe_init_one
+ds1307_remove
+dt3155_probe
+dt3155_remove
+dw_spi_add_host
+dw_spi_remove_host
+e1000_free_irq
+e1000_test_msi_interrupt
+e100_down
+e100_probe
+e100_remove
+eata2x_release
+edt_ft5x06_ts_probe
+edt_ft5x06_ts_remove
+efx_nic_fini_interrupt
+ems_pcmcia_del_card
+enc28j60_probe
+enc28j60_remove
+enic_free_intr
+epic_init_one
+epic_remove_one
+ess_dsp_init
+ethoc_stop
+fcpcipnp_release
+fdomain_16x0_release
+fealnx_init_one
+fealnx_remove_one
+flexcop_pci_exit
+flexcop_pci_init
+fnic_free_intr
+fore200e_shutdown
+fpga_probe
+fpga_remove
+free_dmar_iommu
+free_irq_resources
+free_region
+fsa9480_probe
+fsa9480_remove
+gether_cleanup
+goku_remove
+gp2a_probe
+gp2a_remove
+gpio_remove_key
+hdlcdrv_unregister
+he_stop
+hostap_remove_interface
+hp100_close
+hpc_release_ctlr
+hpet_ioctl_common
+hpwdt_exit
+hpwdt_init_one
+hw_card_shutdown
+i2400m_release
+i2c_hid_probe
+i2c_hid_remove
+i2o_pci_irq_disable
+i740fb_probe
+i740fb_remove
+i801_probe
+i801_remove
+i82092aa_pci_probe
+i82092aa_pci_remove
+i915_driver_load
+i915_driver_unload
+ide_unregister
+if_cs_release
+if_spi_probe
+igb_free_irq
+iio_trigger_detach_poll_func
+il3945_pci_remove
+ili210x_i2c_probe
+ilo_map_device
+ilo_probe
+ilo_remove
+ilo_unmap_device
+init_card
+initio_probe_one
+initio_remove_one
+init_irq
+inv_mpu6050_remove_trigger
+ioh_gpio_probe
+ioh_gpio_remove
+ipath_ht_free_irq
+ipg_probe
+ipg_remove
+ipr_test_msi
+ipw2100_pci_init_one
+ipw2100_pci_remove_one
+ipw_pci_probe
+ipw_pci_remove
+ipw_prom_free
+isdn_net_realrm
+isl1208_probe
+isl1208_remove
+ixgb_down
+ixgbe_free_irq
+ixgbe_sfp_detection_subtask
+jme_free_irq
+ks8851_remove
+ks_net_stop
+kvaser_pci_init_one
+kxtj9_probe
+kxtj9_remove
+libertas_spi_remove
+lis3lv02d_joystick_disable
+lm8323_remove
+lm8333_probe
+lm8333_remove
+lmc_ifdown
+lola_free
+lp8727_release_irq
+lp8788_irq_exit
+lpfc_sli4_disable_intr
+lpfc_sli4_disable_msi
+lpfc_sli_disable_intr
+lpfc_sli_disable_msi
+marvell_pata_active
+matroxfb_disable_irq
+max11801_ts_probe
+max11801_ts_remove
+max17042_remove
+max732x_irq_teardown
+max7359_probe
+max7359_remove
+max77686_irq_exit
+max77693_irq_exit
+max8925_device_exit
+max8997_irq_exit
+max8998_irq_exit
+mc13xxx_common_cleanup
+mcs5000_ts_probe
+mcs5000_ts_remove
+mcs_touchkey_probe
+mcs_touchkey_remove
+megaraid_fini_mbox
+megaraid_init_mbox
+__megaraid_shutdown
+mei_me_probe
+mei_me_remove
+mga_vram_init
+mgsl_release_resources
+microread_i2c_probe
+microread_i2c_remove
+middma_shutdown
+mid_setup_dma
+mlx4_en_destroy_netdev
+mlx4_free_irqs
+mm_pci_remove
+mpr_touchkey_probe
+mpr_touchkey_remove
+mpt_adapter_dispose
+mpu3050_probe
+mpu3050_remove
+mrf24j40_remove
+mthca_free_irqs
+musb_free
+mvumi_unmap_pci_addr
+mwl8k_probe
+mwl8k_remove
+mxser_board_remove
+mxt_probe
+ne2k_pci_close
+nes_probe
+nes_remove
+net2272_probe_fin
+net2272_remove
+net2280_remove
+net_close
+netdev_close
+netdev_free
+ngene_start
+ngene_stop
+nj_release
+notifier_del_irq
+nozomi_card_exit
+ns83820_init_one
+nsc_ircc_close
+ns_init_card_error
+oaktrail_hdmi_i2c_exit
+ohci_stop
+orinoco_nortel_init_one
+orinoco_nortel_remove_one
+orinoco_pci_init_one
+orinoco_pci_remove_one
+orinoco_pci_suspend
+orinoco_plx_init_one
+orinoco_plx_remove_one
+orinoco_tmd_init_one
+orinoco_tmd_remove_one
+parport_pc_unregister_port
+pcan_free
+pcf50633_irq_free
+pcf8574_kp_probe
+pcf8574_kp_remove
+pcf857x_irq_domain_cleanup
+pch_can_probe
+pch_can_remove
+pch_dma_probe
+pch_dma_remove
+pch_gbe_free_irq
+pch_gpio_probe
+pch_gpio_remove
+pch_i2c_probe
+pch_i2c_remove
+pch_phub_probe
+pch_phub_remove
+pch_remove
+pch_udc_remove
+pch_vbus_gpio_free
+pcie_pme_remove
+pcim_iounmap
+pci_oxsemi_tornado_init
+pci_probe
+pci_remove
+pcmcia_disable_device
+pcmcia_release_window
+pcnet32_close
+pcnet32_open
+pcnet_close
+pcxhr_free
+pd6729_check_irq
+pd6729_pci_probe
+pd6729_pci_remove
+peak_pci_probe
+peak_pci_remove
+phantom_probe
+phantom_remove
+phy_stop_interrupts
+piix_disable_ahci
+pixcir_i2c_ts_probe
+pixcir_i2c_ts_remove
+pluto2_probe
+pluto2_remove
+plx_pci_del_card
+plx_pci_reset_marathon
+pn544_hci_i2c_probe
+pn544_hci_i2c_remove
+ppp_shutdown_interface
+prism54_remove
+probe
+pt1_probe
+pt1_remove
+pvscsi_release_resources
+pvscsi_shutdown_intr
+qib_6120_free_irq
+qib_7220_free_irq
+qib_7322_free_irq
+qla1280_probe_one
+qla1280_remove_one
+qla25xx_free_rsp_que
+qla4xxx_free_irqs
+ql_adapter_down
+ql_adapter_up
+ql_free_irq
+qt1070_probe
+qt1070_remove
+qt2160_probe
+qt2160_remove
+r6040_close
+r6040_init_one
+r6040_open
+r6040_remove_one
+r852_probe
+r852_remove
+radeon_device_fini
+rc5t583_irq_exit
+regmap_del_irq_chip
+release_and_free_resource
+release_card
+release_cis_mem
+release_io_space
+release_memory_resource
+release_resources
+remove_inta_isr
+reset_ivb_igd
+rhine_init_one
+rhine_remove_one
+rio_probe1
+rio_release_outb_dbell
+rio_remove1
+rr_init_one
+rr_remove_one
+rsxx_pci_probe
+rsxx_pci_remove
+rt2x00mmio_uninitialize
+rtl8180_remove
+rtl_pci_disconnect
+rtl_pci_probe
+rx8025_probe
+rx8025_remove
+s3_pci_probe
+s3_pci_remove
+saa7134_finidev
+saa7134_initdev
+saa7146_init_one
+saa7146_remove_one
+saa7164_finidev
+sb1000_close
+sbni_close
+sc92031_probe
+sc92031_remove
+sca3000_probe
+sca3000_remove
+sdhci_add_host
+sdhci_pci_remove_own_cd
+sdhci_remove_host
+sdhci_suspend_host
+sdricoh_init_mmc
+sep_probe
+ser12_close
+serial_hsu_remove
+serial_unlink_irq_chain
+setup_instance
+sh_eth_close
+sh_eth_open
+si4713_probe
+si4713_remove
+sirdev_put_instance
+sis900_probe
+sis900_remove
+sja1000_close
+skfp_close
+skge_remove
+sky2_remove
+slic_init_cleanup
+smb347_remove
+smsc_ircc_close
+snd_ad1889_free
+snd_ali_free
+snd_als300_free
+snd_atiixp_free
+snd_azf3328_free
+snd_bt87x_free
+snd_ca0106_free
+snd_cmipci_free
+snd_cs4281_free
+snd_cs46xx_free
+snd_cs5535audio_free
+snd_cx88_free
+snd_echo_free
+snd_emu10k1_free
+snd_emu10k1x_free
+snd_ensoniq_free
+snd_es1938_free
+snd_es1968_free
+snd_fm801_free
+snd_hdsp_free
+snd_hdspm_free
+snd_ice1712_free
+snd_intel8x0_free
+snd_intel8x0m_free
+snd_korg1212_free
+snd_lx6464es_create
+snd_lx6464es_free
+snd_m3_free
+snd_mixart_free
+snd_nm256_free
+snd_nm256_release_irq
+snd_riptide_free
+snd_rme9652_free
+snd_sbdsp_free
+snd_sonicvibes_free
+snd_trident_free
+snd_uart16550_free
+snd_via82xx_free
+snd_vt1724_free
+snd_vx222_free
+snd_ymfpci_free
+softing_card_shutdown
+softing_enable_irq
+ssb_iounmap
+std_irq_cleanup
+stmmac_dvr_remove
+stmmac_open
+stmmac_pci_remove
+stmmac_release
+stop_airo_card
+stop_atmel_card
+stop_ft1000_card
+sundance_probe1
+sundance_remove1
+sym_free_resources
+sym_iounmap_device
+synaptics_i2c_remove
+synaptics_rmi4_probe
+synaptics_rmi4_remove
+tifm_7xx1_probe
+tifm_7xx1_remove
+timbuart_shutdown
+tlan_close
+tpci200_unregister
+tps65010_remove
+tps6586x_i2c_probe
+tps6586x_i2c_remove
+tps65912_irq_exit
+tsc2005_probe
+tsi148_irq_exit
+tsl2563_probe
+tsl2563_remove
+tsl2x7x_probe
+tsl2x7x_remove
+tulip_init_one
+tulip_remove_one
+__twa_shutdown
+twl6030_init_irq
+__twl_shutdown
+__tw_shutdown
+typhoon_close
+typhoon_init_one
+typhoon_open
+typhoon_remove_one
+typhoon_test_mmio
+udc_pci_remove
+uio_unregister_device
+uli526x_init_one
+uli526x_remove_one
+ulite_shutdown
+unbind_from_irqhandler
+unload_mpu401
+unload_pas
+unload_uart6850
+unregister_candev
+unregister_networkdev
+unregister_wlandev
+usb_add_hcd
+usb_remove_hcd
+velocity_close
+via_sd_remove
+virtio_pci_probe
+virtio_pci_remove
+vlsi_close
+vlsi_open
+vmbus_bus_init
+vmxnet3_free_irqs
+vortex_close
+vortex_init_one
+vortex_open
+vortex_remove_one
+vt8623_pci_probe
+vt8623_pci_remove
+vxge_rem_isr
+w83977af_close
+w840_probe1
+w840_remove1
+wacom_i2c_probe
+wacom_i2c_remove
+wbsd_release_irq
+whci_n_caps
+whci_probe
+whci_remove
+wil6210_fini_irq
+wil6210_request_3msi
+wil_pcie_probe
+wil_pcie_remove
+wl3501_reset
+wm2200_i2c_remove
+wm5100_i2c_probe
+wm5100_i2c_remove
+wm831x_irq_exit
+wm8350_irq_exit
+wm8903_i2c_remove
+wm8993_i2c_probe
+wm8993_i2c_remove
+xenvif_disconnect
+xhci_try_enable_msi
+xircom_probe
+xircom_remove
+xpc_destroy_gru_mq_uv
+yam_close
+yellowfin_init_one
+yellowfin_remove_one
+yenta_probe_cb_irq
diff --git a/usr/src/tools/smatch/src/smatch_data/no_return_funcs b/usr/src/tools/smatch/src/smatch_data/no_return_funcs
new file mode 100644
index 0000000000..56fa52bb25
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/no_return_funcs
@@ -0,0 +1,3 @@
+__assert_fail
+exit
+__builtin_unreachable
diff --git a/usr/src/tools/smatch/src/smatch_data/no_return_funcs.remove b/usr/src/tools/smatch/src/smatch_data/no_return_funcs.remove
new file mode 100644
index 0000000000..4b30b66527
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/no_return_funcs.remove
@@ -0,0 +1,5 @@
+main
+reserve_bootmem
+reserve_bootmem_node
+smp_reboot_interrupt
+xfs_fs_alloc_inode
diff --git a/usr/src/tools/smatch/src/smatch_data/smatch.common_functions b/usr/src/tools/smatch/src/smatch_data/smatch.common_functions
new file mode 100644
index 0000000000..eb74587d3b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/smatch.common_functions
@@ -0,0 +1,17 @@
+get_type
+sm_prefix
+add_hook
+strcmp
+snprintf
+get_filename
+get_argument_from_call_expr
+printf
+INT_PTR
+get_function
+free_string
+print_implied_debug_msg
+strip_expr
+get_lineno
+add_function_hook
+is_silenced_function
+fprintf
diff --git a/usr/src/tools/smatch/src/smatch_data/smatch_generic.common_functions b/usr/src/tools/smatch/src/smatch_data/smatch_generic.common_functions
new file mode 100644
index 0000000000..f3be370b82
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/smatch_generic.common_functions
@@ -0,0 +1 @@
+printf
diff --git a/usr/src/tools/smatch/src/smatch_data/wine.bit_shifters b/usr/src/tools/smatch/src/smatch_data/wine.bit_shifters
new file mode 100644
index 0000000000..242374a3cb
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/wine.bit_shifters
@@ -0,0 +1,51 @@
+// list of macros used as shifters.
+// generated by `gen_bit_shifters.sh`
+BANDID_FORMATBAR 3
+BANDID_RULER 0
+BANDID_STATUSBAR 1
+BANDID_TOOLBAR 2
+BWRITERVS_SWIZZLE_SHIFT 16
+CANCEL_MSG_LINE 2
+CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT 16
+CPU_ARM64 4
+CPU_x86_64 1
+D3DFVF_TEXCOUNT_SHIFT 8
+D3DSI_INSTLENGTH_SHIFT 24
+D3DSP_DCL_USAGEINDEX_SHIFT 16
+D3DSP_DCL_USAGE_SHIFT 0
+D3DSP_DSTSHIFT_SHIFT 24
+D3DSP_REGTYPE_SHIFT 28
+D3DSP_REGTYPE_SHIFT2 8
+DIGIT_BIT 28
+HASHTABLE_FLAG_BITS 6
+INSTALLSTATE_LOCAL 3
+JSSTR_LENGTH_SHIFT 4
+MAX_TEXTURES 8
+NET_WM_STATE_ABOVE 1
+NET_WM_STATE_FULLSCREEN 0
+NET_WM_STATE_MAXIMIZED 2
+NET_WM_STATE_SKIP_PAGER 3
+NET_WM_STATE_SKIP_TASKBAR 4
+RESERVED_SHIFT 26
+WINED3D_FFP_ATTRIBS_COUNT 15
+WINED3D_FFP_BLENDINDICES 2
+WINED3D_FFP_BLENDWEIGHT 1
+WINED3D_FFP_DIFFUSE 5
+WINED3D_FFP_NORMAL 3
+WINED3D_FFP_POSITION 0
+WINED3D_FFP_PSIZE 4
+WINED3D_FFP_SPECULAR 6
+WINED3D_SHADER_TYPE_COMPUTE 5
+WINED3D_SHADER_TYPE_DOMAIN 4
+WINED3D_SHADER_TYPE_GEOMETRY 2
+WINED3D_SHADER_TYPE_HULL 3
+WINED3D_SHADER_TYPE_PIXEL 0
+WINED3D_SHADER_TYPE_VERTEX 1
+WINED3D_SM1_REGISTER_TYPE_SHIFT 28
+WINED3D_SM1_REGISTER_TYPE_SHIFT2 8
+WINED3D_SM1_SWIZZLE_SHIFT 16
+__WINE_DBCL_ERR 1
+__WINE_DBCL_FIXME 0
+__WINE_DBCL_INIT 7
+__WINE_DBCL_TRACE 3
+__WINE_DBCL_WARN 2
diff --git a/usr/src/tools/smatch/src/smatch_data/wine.ignored_macros b/usr/src/tools/smatch/src/smatch_data/wine.ignored_macros
new file mode 100644
index 0000000000..4a749eb29e
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/wine.ignored_macros
@@ -0,0 +1,5 @@
+/*
+ * These macros are actively misleading to smatch so
+ * it's best to ignore them.
+ */
+ok
diff --git a/usr/src/tools/smatch/src/smatch_data/wine.no_return_funcs b/usr/src/tools/smatch/src/smatch_data/wine.no_return_funcs
new file mode 100644
index 0000000000..153d384cef
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/wine.no_return_funcs
@@ -0,0 +1,91 @@
+// list of functions which don't return.
+// generated by `gen_no_return_funcs.sh`
+RaiseException
+__assert_fail
+exit
+__builtin_unreachable
+ExitProcess
+_beginthread_trampoline
+callback_exception
+call_thread_func
+close_socket_timeout
+coff_process_info
+collect_connections_proc
+collect_query_thread
+CorExitProcess
+_CxxThrowException
+debug_usage
+DelayLoadFailureHook
+do_sigsegv
+do_usage
+emfpathdrv_CreateDC
+error
+error_exit_fn
+error_loc
+error_loc_info
+event_client
+__ExceptionPtrRethrow
+exit_on_signal
+ExitProcess
+exit_thread
+fatal
+fatal_error
+fatal_perror
+fatal_string_error
+guiFatal
+internal_error
+iocp_poller
+main
+MSVCRT_abort
+MSVCRT__wassert
+nulldrv_CreateDC
+nulldrv_DeleteDC
+oob_client
+oob_server
+packet_kill
+parser_error
+pp_internal_error
+ProvStore_releaseContext
+PullPin_Thread_Main
+raise_status
+read_res16
+REGPROC_print_error
+relay_call_regs
+RpcRaiseException
+rpcrt4_ncacn_http_handoff
+RtlExitUserProcess
+__security_error_handler
+segvhandler
+select_server
+server_connect_error
+sigterm_callback
+sigterm_handler
+simple_client
+simple_mixed_client
+simple_server
+start_process
+start_thread
+stub_entry_point
+terminate_thread
+test_thread_func_ex
+textFatal
+throw_bad_alloc
+TIME_MMSysTimeThread
+unwind_frame
+unwind_target
+user_error_fn
+_vcomp_fork_worker
+__widl_unwind_target
+__wine_process_init
+__wine_rtl_unwind
+__wine_spec_exe_wentry
+__wine_spec_unimplemented_stub
+wine_switch_to_stack
+WINMM_DevicesThreadProc
+wmain
+wpp_default_error
+write_po_files
+write_pot_file
+wWinMain
+xyyerror
+yy_fatal_error
diff --git a/usr/src/tools/smatch/src/smatch_data/wine.no_return_funcs.add b/usr/src/tools/smatch/src/smatch_data/wine.no_return_funcs.add
new file mode 100644
index 0000000000..78ab8c7f0d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/wine.no_return_funcs.add
@@ -0,0 +1,2 @@
+ExitProcess
+RaiseException
diff --git a/usr/src/tools/smatch/src/smatch_data/wine.no_return_funcs.remove b/usr/src/tools/smatch/src/smatch_data/wine.no_return_funcs.remove
new file mode 100644
index 0000000000..15e6c9f055
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/wine.no_return_funcs.remove
@@ -0,0 +1 @@
+usage
diff --git a/usr/src/tools/smatch/src/smatch_data/wine.sizeof_param b/usr/src/tools/smatch/src/smatch_data/wine.sizeof_param
new file mode 100644
index 0000000000..96d05fc733
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data/wine.sizeof_param
@@ -0,0 +1,445 @@
+// list of function parameters that are the size of a buffer.
+// generated by `gen_sizeof_param.sh`
+AddJobW 3 2
+alloc_utf8_text 1 0
+append 2 1
+BCryptFinishHash 2 1
+BCryptGenRandom 2 1
+BCryptGetProperty 3 2
+bsearch 3 1
+call_minidriver 5 4
+CertAddEncodedCertificateToStore 3 2
+CertAddEncodedCRLToStore 3 2
+CertAddEncodedCTLToStore 3 2
+CertAddSerializedElementToStore 2 1
+CertCreateCertificateContext 2 1
+CertCreateCRLContext 2 1
+CertCreateCTLContext 2 1
+CertGetIntendedKeyUsage 3 2
+CertNameToStrA 4 3
+CertRDNValueToStrA 3 2
+checkCRLHash 1 0
+checkHash 1 0
+check_index_buffer_ 4 2
+check_param 4 3
+CommitUrlCacheEntryW 6 5
+compare_emf_bits 2 1
+compare_file_data 2 1
+compare_mf_bits 2 1
+compare_mf_disk_bits 2 1
+compareStore 3 2
+CompareStringA 3 2
+CompareStringA 5 2
+convert_old_args 5 4
+convert_str 1 4
+copy_param 3 2
+create_buffer_ 3 4
+create_decoder 1 0
+create_file 2 1
+create_source_file 2 1
+create_source_fileA 2 1
+create_source_fileW 2 1
+create_stream 1 0
+create_stream_on_data 1 0
+create_test_icon 6 5
+CryptEncrypt 6 4
+CryptEncryptMessage 4 3
+CryptGenRandom 1 2
+CryptGetMessageSignerCount 2 1
+CryptHashCertificate 4 3
+CryptHashData 2 1
+CryptHashToBeSigned 3 2
+CryptImportKey 2 1
+CryptMsgUpdate 2 1
+CryptVerifyDetachedMessageHash 2 1
+CryptVerifyDetachedMessageSignature 3 2
+CryptVerifyMessageHash 2 1
+CryptVerifyMessageSignature 3 2
+CryptVerifySignatureA 2 1
+cstr_length 1 0
+D3DXCreateCubeTextureFromFileInMemory 2 1
+D3DXCreateCubeTextureFromFileInMemoryEx 2 1
+D3DXCreateEffect 2 1
+D3DXCreateEffectCompiler 1 0
+D3DXCreateTextureFromFileInMemory 2 1
+D3DXCreateTextureFromFileInMemoryEx 2 1
+D3DXCreateVolumeTextureFromFileInMemory 2 1
+D3DXGetImageInfoFromFileInMemory 1 0
+D3DXLoadSurfaceFromFileInMemory 4 3
+D3DXLoadSurfaceFromMemory 5 3
+D3DXLoadVolumeFromFileInMemory 4 3
+D3DXLoadVolumeFromMemory 6 3
+dbg_read_memory 2 1
+DdeCreateDataHandle 2 1
+DeviceIoControl 3 2
+DeviceIoControl 5 4
+DIALOG_BrowsePrograms 2 1
+DIALOG_BrowseSymbols 2 1
+dns_ns_name_uncompress 4 3
+dns_ns_name_unpack 4 3
+doit 5 4
+DragQueryFileA 3 2
+DRIVER_GetLibName 3 2
+ExpandEnvironmentStringsA 2 1
+ExtEscape 2 3
+ExtEscape 4 5
+fgets 1 0
+fill_sym_lvalue 4 3
+format_exception_msg 2 1
+format_hash 1 0
+FormatMessageA 5 4
+fread 1 0
+fread 2 0
+func_ptr 4 1
+func_ptr 4 3
+fwrite 1 0
+fwrite 2 0
+get_alsa_name_by_guid 2 1
+GetAtomNameA 2 1
+GetBitmapBits 1 2
+get_buffer 1 0
+get_builtin_path 3 2
+GetClassNameA 2 1
+GetClipboardFormatNameA 2 1
+get_commands 3 2
+get_config_key 4 3
+GetCurrentDirectoryA 0 1
+GetCurrentThemeName 1 0
+GetCurrentThemeName 3 0
+GetCurrentThemeName 5 4
+GetDateFormatA 5 4
+get_display_device_reg_key 1 0
+GetDlgItemTextA 3 2
+GetEnvironmentVariableA 2 1
+GetFontData 4 3
+GetFullPathNameA 1 2
+GetGlyphOutlineA 4 5
+GetGlyphOutlineW 4 5
+gethostname 1 0
+GetKeyNameTextA 2 1
+get_line 1 0
+GetLocaleInfoA 3 2
+get_long_path_name 2 1
+GetLongPathNameA 2 0
+GetLongPathNameA 2 1
+GetMetaFileBitsEx 1 2
+GetModuleFileNameA 2 1
+getnameinfo 3 2
+getnameinfo 5 4
+GetObjectA 1 2
+GetObjectW 1 2
+GetPrivateProfileSectionA 2 1
+GetPrivateProfileStringA 4 3
+get_process_info 2 1
+GetProfileStringA 4 3
+get_reg_value 4 3
+GetRoleTextA 2 1
+GetShortPathNameA 2 0
+GetShortPathNameA 2 1
+GetSystemDirectoryA 1 0
+get_system_proxy_autoconfig_url 1 0
+GetTempPathA 0 1
+GetTextExtentExPointA 2 1
+GetTextExtentPoint32A 2 1
+GetTextFaceA 1 2
+get_thread_info 3 2
+GetTimeFormatA 5 4
+GetTokenInformation 3 2
+get_ttf_nametable_entry 3 2
+GetUserObjectInformationA 3 2
+GetUserObjectInformationW 3 2
+GetWindowsDirectoryA 1 0
+GetWindowTextA 2 1
+GlobalGetAtomNameA 2 1
+HCR_GetExecuteCommandW 4 3
+HTTPREQ_Read 2 1
+HttpSendRequestA 4 3
+_hwrite 2 1
+IContextMenu_GetCommandString 5 4
+ID2D1Bitmap_CopyFromMemory 3 2
+ID3D10Device_CreateGeometryShader 2 1
+ID3D10Device_CreateInputLayout 4 3
+ID3D10Device_CreatePixelShader 2 1
+ID3D10Device_CreateVertexShader 2 1
+ID3D10Device_UpdateSubresource 5 4
+ID3D11DeviceContext_UpdateSubresource 5 4
+ID3D11Device_CreateGeometryShader 2 1
+ID3D11Device_CreateInputLayout 4 3
+ID3D11Device_CreatePixelShader 2 1
+ID3D11Device_CreateVertexShader 2 1
+IDataConvert_DataConvert 3 5
+IDataConvert_DataConvert 7 6
+IDWriteGlyphRunAnalysis_CreateAlphaTexture 4 3
+IHtmlLoadOptions_SetOption 3 2
+IInternetProtocolEx_Read 2 1
+IInternetProtocolInfo_QueryInfo 5 4
+IInternetProtocol_Read 2 1
+ILockBytes_ReadAt 3 2
+ImmGetCompositionStringA 3 2
+ImmSetCompositionStringA 3 2
+ImmSetCompositionStringW 3 2
+inet_ntop 3 2
+initFileFromData 2 1
+input_read_line 2 1
+InternetReadFile 2 1
+InternetSetOptionA 3 2
+InternetTimeFromSystemTimeW 3 2
+IoBuildDeviceIoControlRequest 5 4
+IROTData_GetComparisonData 2 1
+IsBadReadPtr 1 0
+IsBadWritePtr 1 0
+ISequentialStream_Read 2 1
+IShellLinkA_GetArguments 2 1
+IShellLinkA_GetDescription 2 1
+IShellLinkA_GetIconLocation 2 1
+IShellLinkA_GetPath 2 1
+IShellLinkA_GetWorkingDirectory 2 1
+IStream_Read 2 1
+IStream_Write 2 1
+IWICBitmapClipper_CopyPixels 3 4
+IWICBitmap_CopyPixels 3 4
+IWICBitmapFrameDecode_CopyPixels 3 4
+IWICImagingFactory_CreateBitmapFromMemory 5 6
+IWICStream_InitializeFromMemory 2 1
+IWICStream_Write 2 1
+LCMapStringA 5 2
+LCMapStringA 5 4
+load_entry 2 1
+load_face 4 3
+load_image 1 0
+load_stream 2 1
+LoadStringA 3 2
+_lwrite 2 1
+MCI_GetDevTypeFromFileName 2 1
+mciGetErrorStringA 2 1
+mciSendStringA 2 1
+memcmp 2 0
+memcmp 2 1
+memcpy 2 0
+memcpy 2 1
+memory_get_string 5 4
+memory_read_value 1 2
+memset 2 0
+mmioRead 2 1
+MSFT_ReadLEWords 1 0
+MSVCRT_asctime_s 1 0
+MSVCRT__fwrite_nolock 1 0
+MSVCRT__snwprintf 1 0
+MultiByteToWideChar 3 2
+NdrCorrelationInitialize 2 1
+NetBTNameReq 5 4
+NETCON_recv 2 1
+NLS_RegEnumValue 3 2
+NLS_RegEnumValue 5 4
+NTDLL__vsnprintf 1 0
+NtEnumerateKey 4 3
+NtEnumerateValueKey 4 3
+NtQueryDirectoryFile 6 5
+NtQueryInformationProcess 3 2
+NtQueryInformationThread 3 2
+NtQueryKey 3 2
+NtQueryValueKey 4 3
+NtReadFile 6 5
+NtSetInformationThread 3 2
+NtSetValueKey 5 4
+output 2 1
+pBCryptHash 6 5
+pCertNameToStrA 4 3
+pCertRDNValueToStrA 3 2
+pCertRDNValueToStrW 3 2
+pCoInternetQueryInfo 4 3
+pCryptDecodeObjectEx 3 2
+pCryptFormatObject 6 5
+pCryptVerifySignatureW 2 1
+PeekNamedPipe 2 1
+p_fgets 1 0
+p_fread_s 1 0
+pGetCalendarInfoA 4 3
+pGetCalendarInfoW 4 3
+pGetFileInformationByHandleEx 3 2
+pGetFontFileData 4 3
+pGetLongPathNameA 2 0
+pGetLongPathNameA 2 1
+pGetMappedFileNameA 3 2
+pGetModuleBaseNameA 3 2
+pGetModuleFileNameExA 3 2
+pGetProcessImageFileNameA 2 1
+pGetProcessImageFileNameW 2 1
+pGetShortPathNameA 2 1
+pGetSystemWow64DirectoryA 1 0
+pGetVolumeNameForVolumeMountPointA 2 1
+pGetVolumePathNamesForVolumeNameA 2 1
+pGetVolumePathNamesForVolumeNameW 2 1
+pGetWindowModuleFileNameA 2 1
+pGetWsChanges 2 1
+pHexFromBin 1 0
+pIcmpSendEcho 3 2
+pIdnToAscii 4 3
+pIdnToUnicode 4 3
+pInetNtop 3 2
+pInternetGetConnectedStateExA 2 1
+pInternetTimeFromSystemTimeA 3 2
+pInternetTimeFromSystemTimeW 3 2
+p_itoa_s 2 1
+pK32GetProcessImageFileNameA 2 1
+pLcidToRfc1766A 2 1
+p_mbscat_s 1 0
+p__mbscpy_s 1 0
+p_mbslwr_s 1 0
+p_mbsnbcat_s 1 0
+p_mbsnbcat_s 3 2
+p_mbsnbcpy_s 1 0
+p_mbsnbcpy_s 3 2
+p_mbsupr_s 1 0
+pNtNotifyChangeDirectoryFile 6 5
+pNtQueryDirectoryFile 6 5
+pNtQueryInformationFile 3 2
+pNtQueryInformationProcess 3 2
+pNtQueryKey 3 2
+pNtQueryLicenseValue 3 2
+pNtQueryObject 3 2
+pNtQueryVolumeInformationFile 3 2
+pNtReadFile 6 5
+pNtWriteFile 6 5
+pPathUnExpandEnvStringsA 2 1
+pQueryInformationJobObject 3 2
+pReadDirectoryChangesW 2 1
+pRegSetKeyValueW 5 4
+printBytes 2 1
+pRtlCompressBuffer 2 1
+pRtlCompressBuffer 4 3
+pRtlDecompressBuffer 2 1
+pRtlDecompressFragment 2 1
+pRtlIsTextUnicode 1 0
+pRtlMultiByteToUnicodeN 1 0
+pRtlUnicodeToUTF8N 1 0
+pRtlUTF8ToUnicodeN 1 0
+pSetupDiGetDeviceInstanceIdA 3 2
+pSetupEnumInfSectionsA 3 2
+pSetupGetFileCompressionInfoExA 2 1
+pSHFormatDateTimeA 3 2
+pSHGetIniStringW 3 2
+pSHLWAPI_184 2 1
+pSHLWAPI_212 2 1
+pstrcat_s 1 0
+pstrcpy_s 1 0
+pstrerror_s 1 0
+pStringTableLookUpStringEx 4 3
+p_strlwr_s 1 0
+p__strnset_s 1 0
+p_ultoa_s 2 1
+push_data 2 1
+put_data 1 0
+pXcvDataPort 5 4
+qsort 2 0
+QueryDosDeviceA 2 1
+_read 2 1
+read 2 1
+read_bytes 1 0
+read_bytes 2 1
+ReadCharMetrics 2 1
+read_data 2 1
+ReadFile 2 1
+ReadFileEx 2 1
+ReadFontMetrics 2 1
+read_func 2 1
+ReadProcessMemory 3 2
+read_stream 3 2
+ReadString 2 1
+RealGetWindowClassA 2 1
+_receive_simple_request 3 2
+recv 2 1
+recvfrom 2 1
+RegEnumKeyA 3 2
+RegSetValueA 4 3
+RegSetValueExA 5 4
+RegSetValueExW 5 1
+RegSetValueW 4 3
+__res_query 4 3
+reverse_lookup 2 1
+rpcrt4_http_async_read 4 3
+RtlGetCurrentDirectory_U 0 1
+RtlMultiByteToUnicodeN 1 0
+r_verify_reg_binary 5 4
+SearchPathA 3 4
+send 2 1
+sendto 2 1
+SetEnhMetaFileBits 0 1
+SetMetaFileBitsEx 0 1
+set_profile_device_key 2 1
+SetupGetFileCompressionInfoExA 2 1
+SetupGetLineTextA 5 4
+SetupGetSourceFileLocationA 5 4
+SetupGetSourceInfoA 4 3
+SetupGetStringFieldA 3 2
+SetupGetTargetPathA 4 3
+setvbuf 3 1
+SHELL_FindExecutableByVerb 4 3
+snprintf 1 0
+sock_recv 2 1
+stab_strcpy 1 0
+strftime 1 0
+_Strftime 1 0
+strncmp 2 0
+strncmp 2 1
+strncpyWtoA 2 0
+sw_read_mem 3 2
+SysAllocStringByteLen 1 0
+SystemFunction036 1 0
+test_add_certificate 1 0
+test_buffer_object 2 1
+test_font_metrics 5 4
+_test_hkey_main_Value_A 3 2
+_test_hkey_main_Value_W 3 2
+test_LoadImageFile 2 1
+test_LoadMeshFromX_ 9 7
+test_moniker 3 2
+test_moniker 5 4
+test_moniker 7 6
+test_output 3 2
+test_persist_save_data 3 2
+test_persist_save_data 5 2
+test_persist_save_data 5 4
+test_pic 1 0
+test_preshader_op 2 1
+unicode_expect_ 4 3
+UpdateResourceA 5 4
+UrlMkSetSessionOption 2 1
+utf8_expect_ 4 3
+VarTokenizeFormatString 2 1
+vsnprintf 1 0
+vsnprintfW 1 0
+_vsprintf_p_wrapper 1 0
+vsprintf_wrapper 2 1
+vswprintf_wrapper 2 1
+waveInAddBuffer 2 1
+waveInGetErrorTextA 2 1
+waveInPrepareHeader 2 1
+waveInUnprepareHeader 2 1
+waveOutGetErrorTextA 2 1
+waveOutPrepareHeader 2 1
+waveOutUnprepareHeader 2 1
+waveOutWrite 2 1
+WideCharToMultiByte 5 4
+WINECON_GetConsoleTitle 2 1
+wined3d_private_store_set_private_data 3 2
+wine_dll_load 2 1
+wine_dlopen 3 2
+wine_dlsym 3 2
+wine_init 3 2
+wine_server_set_reply 2 1
+WinHttpReadData 2 1
+wld_read 2 1
+_write 2 1
+write 2 1
+write_file 2 1
+WriteFile 2 1
+WriteFileEx 2 1
+WriteProcessMemory 3 2
+write_stream_data 3 2
+WSAIoctl 3 2
+WS_inet_ntop 3 2
+WsWriteType 6 5
+X11DRV_XDND_DescribeClipboardFormat 2 1
+XLookupString 2 1
+XmbLookupString 3 2
diff --git a/usr/src/tools/smatch/src/smatch_data_source.c b/usr/src/tools/smatch/src/smatch_data_source.c
new file mode 100644
index 0000000000..7ada921cdb
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_data_source.c
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static char *get_source_parameter(struct expression *expr)
+{
+	struct expression *tmp;
+	struct symbol *sym;
+	char *name;
+	int param;
+	char *ret = NULL;
+	char buf[32];
+	int cnt = 0;
+
+	tmp = expr;
+	while ((tmp = get_assigned_expr(tmp))) {
+		expr = tmp;
+		if (cnt++ > 3)
+			break;
+	}
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_SYMBOL)
+		return NULL;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	param = get_param_num_from_sym(sym);
+	if (param < 0)
+		goto free;
+	if (param_was_set(expr))
+		goto free;
+
+	snprintf(buf, sizeof(buf), "p %d", param);
+	ret = alloc_string(buf);
+
+free:
+	free_string(name);
+	return ret;
+}
+
+static char *get_source_assignment(struct expression *expr)
+{
+	struct expression *right;
+	char *name;
+	char buf[64];
+	char *ret;
+
+	right = get_assigned_expr(expr);
+	right = strip_expr(right);
+	if (!right)
+		return NULL;
+	if (right->type != EXPR_CALL || right->fn->type != EXPR_SYMBOL)
+		return NULL;
+	if (is_fake_call(right))
+		return NULL;
+	name = expr_to_str(right->fn);
+	if (!name)
+		return NULL;
+	snprintf(buf, sizeof(buf), "r %s", name);
+	ret = alloc_string(buf);
+	free_string(name);
+	return ret;
+}
+
+static char *get_source_str(struct expression *arg)
+{
+	char *source;
+
+	source = get_source_parameter(arg);
+	if (source)
+		return source;
+	return get_source_assignment(arg);
+}
+
+static void match_caller_info(struct expression *expr)
+{
+	struct expression *arg;
+	char *source;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+		source = get_source_str(arg);
+		if (!source)
+			continue;
+		sql_insert_caller_info(expr, DATA_SOURCE, i, "$", source);
+		free_string(source);
+	} END_FOR_EACH_PTR(arg);
+}
+
+void register_data_source(int id)
+{
+//	if (!option_info)
+//		return;
+	my_id = id;
+	add_hook(&match_caller_info, FUNCTION_CALL_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_db.c b/usr/src/tools/smatch/src/smatch_db.c
new file mode 100644
index 0000000000..e9e1eab24b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_db.c
@@ -0,0 +1,2586 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <ctype.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+struct sqlite3 *smatch_db;
+struct sqlite3 *mem_db;
+struct sqlite3 *cache_db;
+
+static int return_id;
+
+#define SQLITE_CACHE_PAGES 1000
+
+struct def_callback {
+	int hook_type;
+	void (*callback)(const char *name, struct symbol *sym, char *key, char *value);
+};
+ALLOCATOR(def_callback, "definition db hook callbacks");
+DECLARE_PTR_LIST(callback_list, struct def_callback);
+static struct callback_list *select_caller_info_callbacks;
+
+struct member_info_callback {
+	int owner;
+	void (*callback)(struct expression *call, int param, char *printed_name, struct sm_state *sm);
+};
+ALLOCATOR(member_info_callback, "caller_info callbacks");
+DECLARE_PTR_LIST(member_info_cb_list, struct member_info_callback);
+static struct member_info_cb_list *member_callbacks;
+
+struct returned_state_callback {
+	void (*callback)(int return_id, char *return_ranges, struct expression *return_expr);
+};
+ALLOCATOR(returned_state_callback, "returned state callbacks");
+DECLARE_PTR_LIST(returned_state_cb_list, struct returned_state_callback);
+static struct returned_state_cb_list *returned_state_callbacks;
+
+struct returned_member_callback {
+	int owner;
+	void (*callback)(int return_id, char *return_ranges, struct expression *expr, char *printed_name, struct smatch_state *state);
+};
+ALLOCATOR(returned_member_callback, "returned member callbacks");
+DECLARE_PTR_LIST(returned_member_cb_list, struct returned_member_callback);
+static struct returned_member_cb_list *returned_member_callbacks;
+
+struct db_implies_callback {
+	int type;
+	void (*callback)(struct expression *call, struct expression *arg, char *key, char *value);
+};
+ALLOCATOR(db_implies_callback, "return_implies callbacks");
+DECLARE_PTR_LIST(db_implies_cb_list, struct db_implies_callback);
+static struct db_implies_cb_list *return_implies_cb_list;
+static struct db_implies_cb_list *call_implies_cb_list;
+
+/* silently truncates if needed. */
+char *escape_newlines(const char *str)
+{
+	char buf[1024] = "";
+	bool found = false;
+	int i, j;
+
+	for (i = 0, j = 0; str[i] != '\0' && j != sizeof(buf); i++, j++) {
+		if (str[i] != '\n') {
+			buf[j] = str[i];
+			continue;
+		}
+
+		found = true;
+		buf[j++] = '\\';
+		if (j == sizeof(buf))
+			 break;
+		buf[j] = 'n';
+	}
+
+	if (!found)
+		return alloc_sname(str);
+
+	if (j == sizeof(buf))
+		buf[j - 1] = '\0';
+	return alloc_sname(buf);
+}
+
+static int print_sql_output(void *unused, int argc, char **argv, char **azColName)
+{
+	int i;
+
+	for (i = 0; i < argc; i++) {
+		if (i != 0)
+			printf(", ");
+		sm_printf("%s", argv[i]);
+	}
+	sm_printf("\n");
+	return 0;
+}
+
+void sql_exec(struct sqlite3 *db, int (*callback)(void*, int, char**, char**), void *data, const char *sql)
+{
+	char *err = NULL;
+	int rc;
+
+	if (!db)
+		return;
+
+	if (option_debug) {
+		sm_msg("%s", sql);
+		if (strncasecmp(sql, "select", strlen("select")) == 0)
+			sqlite3_exec(db, sql, print_sql_output, NULL, NULL);
+	}
+
+	rc = sqlite3_exec(db, sql, callback, data, &err);
+	if (rc != SQLITE_OK && !parse_error) {
+		sm_ierror("%s:%d SQL error #2: %s\n", get_filename(), get_lineno(), err);
+		sm_ierror("%s:%d SQL: '%s'\n", get_filename(), get_lineno(), sql);
+		parse_error = 1;
+	}
+}
+
+static int replace_count;
+static char **replace_table;
+static const char *replace_return_ranges(const char *return_ranges)
+{
+	int i;
+
+	if (!get_function()) {
+		/* I have no idea why EXPORT_SYMBOL() is here */
+		return return_ranges;
+	}
+	for (i = 0; i < replace_count; i += 3) {
+		if (strcmp(replace_table[i + 0], get_function()) == 0) {
+			if (strcmp(replace_table[i + 1], return_ranges) == 0)
+				return replace_table[i + 2];
+		}
+	}
+	return return_ranges;
+}
+
+
+static char *use_states;
+static int get_db_state_count(void)
+{
+	struct sm_state *sm;
+	int count = 0;
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (sm->owner == USHRT_MAX)
+			continue;
+		if (use_states[sm->owner])
+			count++;
+	} END_FOR_EACH_SM(sm);
+	return count;
+}
+
+void db_ignore_states(int id)
+{
+	use_states[id] = 0;
+}
+
+void sql_insert_return_states(int return_id, const char *return_ranges,
+		int type, int param, const char *key, const char *value)
+{
+	if (key && strlen(key) >= 80)
+		return;
+	return_ranges = replace_return_ranges(return_ranges);
+	sql_insert(return_states, "'%s', '%s', %lu, %d, '%s', %d, %d, %d, '%s', '%s'",
+		   get_base_file(), get_function(), (unsigned long)__inline_fn,
+		   return_id, return_ranges, fn_static(), type, param, key, value);
+}
+
+static struct string_list *common_funcs;
+static int is_common_function(const char *fn)
+{
+	char *tmp;
+
+	if (!fn)
+		return 0;
+
+	if (strncmp(fn, "__builtin_", 10) == 0)
+		return 1;
+
+	FOR_EACH_PTR(common_funcs, tmp) {
+		if (strcmp(tmp, fn) == 0)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static char *function_signature(void)
+{
+	return type_to_str(get_real_base_type(cur_func_sym));
+}
+
+void sql_insert_caller_info(struct expression *call, int type,
+		int param, const char *key, const char *value)
+{
+	FILE *tmp_fd = sm_outfd;
+	char *fn;
+
+	if (!option_info && !__inline_call)
+		return;
+
+	if (key && strlen(key) >= 80)
+		return;
+
+	fn = get_fnptr_name(call->fn);
+	if (!fn)
+		return;
+
+	if (__inline_call) {
+		mem_sql(NULL, NULL,
+			"insert into caller_info values ('%s', '%s', '%s', %lu, %d, %d, %d, '%s', '%s');",
+			get_base_file(), get_function(), fn, (unsigned long)call,
+			is_static(call->fn), type, param, key, value);
+	}
+
+	if (!option_info)
+		return;
+
+	if (strncmp(fn, "__builtin_", 10) == 0)
+		return;
+	if (type != INTERNAL && is_common_function(fn))
+		return;
+
+	sm_outfd = caller_info_fd;
+	sm_msg("SQL_caller_info: insert into caller_info values ("
+	       "'%s', '%s', '%s', %%CALL_ID%%, %d, %d, %d, '%s', '%s');",
+	       get_base_file(), get_function(), fn, is_static(call->fn),
+	       type, param, key, value);
+	sm_outfd = tmp_fd;
+
+	free_string(fn);
+}
+
+void sql_insert_function_ptr(const char *fn, const char *struct_name)
+{
+	sql_insert(function_ptr, "'%s', '%s', '%s', 0", get_base_file(), fn,
+		   struct_name);
+}
+
+void sql_insert_return_implies(int type, int param, const char *key, const char *value)
+{
+	sql_insert_or_ignore(return_implies, "'%s', '%s', %lu, %d, %d, %d, '%s', '%s'",
+		get_base_file(), get_function(), (unsigned long)__inline_fn,
+		fn_static(), type, param, key, value);
+}
+
+void sql_insert_call_implies(int type, int param, const char *key, const char *value)
+{
+	sql_insert_or_ignore(call_implies, "'%s', '%s', %lu, %d, %d, %d, '%s', '%s'",
+		get_base_file(), get_function(), (unsigned long)__inline_fn,
+		fn_static(), type, param, key, value);
+}
+
+void sql_insert_function_type_size(const char *member, const char *ranges)
+{
+	sql_insert(function_type_size, "'%s', '%s', '%s', '%s'", get_base_file(), get_function(), member, ranges);
+}
+
+void sql_insert_function_type_info(int type, const char *struct_type, const char *member, const char *value)
+{
+	sql_insert(function_type_info, "'%s', '%s', %d, '%s', '%s', '%s'", get_base_file(), get_function(), type, struct_type, member, value);
+}
+
+void sql_insert_type_info(int type, const char *member, const char *value)
+{
+	sql_insert_cache(type_info, "'%s', %d, '%s', '%s'", get_base_file(), type, member, value);
+}
+
+void sql_insert_local_values(const char *name, const char *value)
+{
+	sql_insert(local_values, "'%s', '%s', '%s'", get_base_file(), name, value);
+}
+
+void sql_insert_function_type_value(const char *type, const char *value)
+{
+	sql_insert(function_type_value, "'%s', '%s', '%s', '%s'", get_base_file(), get_function(), type, value);
+}
+
+void sql_insert_function_type(int param, const char *value)
+{
+	sql_insert(function_type, "'%s', '%s', %d, %d, '%s'",
+		   get_base_file(), get_function(), fn_static(), param, value);
+}
+
+void sql_insert_parameter_name(int param, const char *value)
+{
+	sql_insert(parameter_name, "'%s', '%s', %d, %d, '%s'",
+		   get_base_file(), get_function(), fn_static(), param, value);
+}
+
+void sql_insert_data_info(struct expression *data, int type, const char *value)
+{
+	char *data_name;
+
+	data_name = get_data_info_name(data);
+	if (!data_name)
+		return;
+	sql_insert(data_info, "'%s', '%s', %d, '%s'",
+		   is_static(data) ? get_base_file() : "extern",
+		   data_name, type, value);
+}
+
+void sql_insert_data_info_var_sym(const char *var, struct symbol *sym, int type, const char *value)
+{
+	sql_insert(data_info, "'%s', '%s', %d, '%s'",
+		   (sym->ctype.modifiers & MOD_STATIC) ? get_base_file() : "extern",
+		   var, type, value);
+}
+
+void sql_save_constraint(const char *con)
+{
+	if (!option_info)
+		return;
+
+        sm_msg("SQL: insert or ignore into constraints (str) values('%s');", con);
+}
+
+void sql_save_constraint_required(const char *data, int op, const char *limit)
+{
+	sql_insert_or_ignore(constraints_required, "'%s', '%s', '%s'", data, show_special(op), limit);
+}
+
+void sql_copy_constraint_required(const char *new_limit, const char *old_limit)
+{
+	if (!option_info)
+		return;
+
+	sm_msg("SQL_late: insert or ignore into constraints_required (data, op, bound) "
+		"select constraints_required.data, constraints_required.op, '%s' from "
+		"constraints_required where bound = '%s';", new_limit, old_limit);
+}
+
+void sql_insert_fn_ptr_data_link(const char *ptr, const char *data)
+{
+	sql_insert_or_ignore(fn_ptr_data_link, "'%s', '%s'", ptr, data);
+}
+
+void sql_insert_fn_data_link(struct expression *fn, int type, int param, const char *key, const char *value)
+{
+	if (fn->type != EXPR_SYMBOL || !fn->symbol->ident)
+		return;
+
+	sql_insert(fn_data_link, "'%s', '%s', %d, %d, %d, '%s', '%s'",
+		   (fn->symbol->ctype.modifiers & MOD_STATIC) ? get_base_file() : "extern",
+		   fn->symbol->ident->name,
+		   !!(fn->symbol->ctype.modifiers & MOD_STATIC),
+		   type, param, key, value);
+}
+
+void sql_insert_mtag_about(mtag_t tag, const char *left_name, const char *right_name)
+{
+	sql_insert(mtag_about, "%lld, '%s', '%s', %d, '%s', '%s'",
+		   tag, get_filename(), get_function(), get_lineno(), left_name, right_name);
+}
+
+void sql_insert_mtag_data(mtag_t tag, const char *var, int offset, int type, const char *value)
+{
+	sql_insert(mtag_data, "%lld, '%s', %d, %d, '%s'", tag, var, offset, type, value);
+}
+
+void sql_insert_mtag_map(mtag_t tag, int offset, mtag_t container)
+{
+	sql_insert(mtag_map, "%lld, %d, %lld", tag, offset, container);
+}
+
+void sql_insert_mtag_alias(mtag_t orig, mtag_t alias)
+{
+	sql_insert(mtag_alias, "%lld, %lld", orig, alias);
+}
+
+static int save_mtag(void *_tag, int argc, char **argv, char **azColName)
+{
+	mtag_t *saved_tag = _tag;
+	mtag_t new_tag;
+
+	new_tag = strtoll(argv[0], NULL, 10);
+
+	if (!*saved_tag)
+		*saved_tag = new_tag;
+	else if (*saved_tag != new_tag)
+		*saved_tag = -1ULL;
+
+	return 0;
+}
+
+int mtag_map_select_container(mtag_t tag, int offset, mtag_t *container)
+{
+	mtag_t tmp = 0;
+
+	run_sql(save_mtag, &tmp,
+		"select container from mtag_map where tag = %lld and offset = %d;",
+		tag, offset);
+
+	if (tmp == 0 || tmp == -1ULL)
+		return 0;
+	*container = tmp;
+	return 1;
+}
+
+int mtag_map_select_tag(mtag_t container, int offset, mtag_t *tag)
+{
+	mtag_t tmp = 0;
+
+	run_sql(save_mtag, &tmp,
+		"select tag from mtag_map where container = %lld and offset = %d;",
+		container, offset);
+
+	if (tmp == 0 || tmp == -1ULL)
+		return 0;
+	*tag = tmp;
+	return 1;
+}
+
+char *get_static_filter(struct symbol *sym)
+{
+	static char sql_filter[1024];
+
+	/* This can only happen on buggy code.  Return invalid SQL. */
+	if (!sym) {
+		sql_filter[0] = '\0';
+		return sql_filter;
+	}
+
+	if (sym->ctype.modifiers & MOD_STATIC) {
+		snprintf(sql_filter, sizeof(sql_filter),
+			 "file = '%s' and function = '%s' and static = '1'",
+			 get_base_file(), sym->ident->name);
+	} else {
+		snprintf(sql_filter, sizeof(sql_filter),
+			 "function = '%s' and static = '0'", sym->ident->name);
+	}
+
+	return sql_filter;
+}
+
+static int get_row_count(void *_row_count, int argc, char **argv, char **azColName)
+{
+	int *row_count = _row_count;
+
+	*row_count = 0;
+	if (argc != 1)
+		return 0;
+	*row_count = atoi(argv[0]);
+	return 0;
+}
+
+static void mark_call_params_untracked(struct expression *call)
+{
+	struct expression *arg;
+	int i = 0;
+
+	FOR_EACH_PTR(call->args, arg) {
+		mark_untracked(call, i++, "$", NULL);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void sql_select_return_states_pointer(const char *cols,
+	struct expression *call, int (*callback)(void*, int, char**, char**), void *info)
+{
+	char *ptr;
+	int return_count = 0;
+
+	ptr = get_fnptr_name(call->fn);
+	if (!ptr)
+		return;
+
+	run_sql(get_row_count, &return_count,
+		"select count(*) from return_states join function_ptr "
+		"where return_states.function == function_ptr.function and "
+		"ptr = '%s' and searchable = 1 and type = %d;", ptr, INTERNAL);
+	/* The magic number 100 is just from testing on the kernel. */
+	if (return_count > 100) {
+		mark_call_params_untracked(call);
+		return;
+	}
+
+	run_sql(callback, info,
+		"select %s from return_states join function_ptr where "
+		"return_states.function == function_ptr.function and ptr = '%s' "
+		"and searchable = 1 "
+		"order by function_ptr.file, return_states.file, return_id, type;",
+		cols, ptr);
+}
+
+static int is_local_symbol(struct expression *expr)
+{
+	if (expr->type != EXPR_SYMBOL)
+		return 0;
+	if (expr->symbol->ctype.modifiers & (MOD_NONLOCAL | MOD_STATIC | MOD_ADDRESSABLE))
+		return 0;
+	return 1;
+}
+
+void sql_select_return_states(const char *cols, struct expression *call,
+	int (*callback)(void*, int, char**, char**), void *info)
+{
+	int row_count = 0;
+
+	if (is_fake_call(call))
+		return;
+
+	if (call->fn->type != EXPR_SYMBOL || !call->fn->symbol || is_local_symbol(call->fn)) {
+		sql_select_return_states_pointer(cols, call, callback, info);
+		return;
+	}
+
+	if (inlinable(call->fn)) {
+		mem_sql(callback, info,
+			"select %s from return_states where call_id = '%lu' order by return_id, type;",
+			cols, (unsigned long)call);
+		return;
+	}
+
+	run_sql(get_row_count, &row_count, "select count(*) from return_states where %s;",
+		get_static_filter(call->fn->symbol));
+	if (row_count > 3000)
+		return;
+
+	run_sql(callback, info, "select %s from return_states where %s order by file, return_id, type;",
+		cols, get_static_filter(call->fn->symbol));
+}
+
+#define CALL_IMPLIES 0
+#define RETURN_IMPLIES 1
+
+struct implies_info {
+	int type;
+	struct db_implies_cb_list *cb_list;
+	struct expression *expr;
+	struct symbol *sym;
+};
+
+void sql_select_implies(const char *cols, struct implies_info *info,
+	int (*callback)(void*, int, char**, char**))
+{
+	if (info->type == RETURN_IMPLIES && inlinable(info->expr->fn)) {
+		mem_sql(callback, info,
+			"select %s from return_implies where call_id = '%lu';",
+			cols, (unsigned long)info->expr);
+		return;
+	}
+
+	run_sql(callback, info, "select %s from %s_implies where %s;",
+		cols,
+		info->type == CALL_IMPLIES ? "call" : "return",
+		get_static_filter(info->sym));
+}
+
+struct select_caller_info_data {
+	struct stree *final_states;
+	struct timeval start_time;
+	int prev_func_id;
+	int ignore;
+	int results;
+};
+
+static int caller_info_callback(void *_data, int argc, char **argv, char **azColName);
+
+static void sql_select_caller_info(struct select_caller_info_data *data,
+	const char *cols, struct symbol *sym)
+{
+	if (__inline_fn) {
+		mem_sql(caller_info_callback, data,
+			"select %s from caller_info where call_id = %lu;",
+			cols, (unsigned long)__inline_fn);
+		return;
+	}
+
+	if (sym->ident->name && is_common_function(sym->ident->name))
+		return;
+	run_sql(caller_info_callback, data,
+		"select %s from common_caller_info where %s order by call_id;",
+		cols, get_static_filter(sym));
+	if (data->results)
+		return;
+
+	run_sql(caller_info_callback, data,
+		"select %s from caller_info where %s order by call_id;",
+		cols, get_static_filter(sym));
+}
+
+void select_caller_info_hook(void (*callback)(const char *name, struct symbol *sym, char *key, char *value), int type)
+{
+	struct def_callback *def_callback = __alloc_def_callback(0);
+
+	def_callback->hook_type = type;
+	def_callback->callback = callback;
+	add_ptr_list(&select_caller_info_callbacks, def_callback);
+}
+
+/*
+ * These call backs are used when the --info option is turned on to print struct
+ * member information.  For example foo->bar could have a state in
+ * smatch_extra.c and also check_user.c.
+ */
+void add_member_info_callback(int owner, void (*callback)(struct expression *call, int param, char *printed_name, struct sm_state *sm))
+{
+	struct member_info_callback *member_callback = __alloc_member_info_callback(0);
+
+	member_callback->owner = owner;
+	member_callback->callback = callback;
+	add_ptr_list(&member_callbacks, member_callback);
+}
+
+void add_split_return_callback(void (*fn)(int return_id, char *return_ranges, struct expression *returned_expr))
+{
+	struct returned_state_callback *callback = __alloc_returned_state_callback(0);
+
+	callback->callback = fn;
+	add_ptr_list(&returned_state_callbacks, callback);
+}
+
+void add_returned_member_callback(int owner, void (*callback)(int return_id, char *return_ranges, struct expression *expr, char *printed_name, struct smatch_state *state))
+{
+	struct returned_member_callback *member_callback = __alloc_returned_member_callback(0);
+
+	member_callback->owner = owner;
+	member_callback->callback = callback;
+	add_ptr_list(&returned_member_callbacks, member_callback);
+}
+
+void select_call_implies_hook(int type, void (*callback)(struct expression *call, struct expression *arg, char *key, char *value))
+{
+	struct db_implies_callback *cb = __alloc_db_implies_callback(0);
+
+	cb->type = type;
+	cb->callback = callback;
+	add_ptr_list(&call_implies_cb_list, cb);
+}
+
+void select_return_implies_hook(int type, void (*callback)(struct expression *call, struct expression *arg, char *key, char *value))
+{
+	struct db_implies_callback *cb = __alloc_db_implies_callback(0);
+
+	cb->type = type;
+	cb->callback = callback;
+	add_ptr_list(&return_implies_cb_list, cb);
+}
+
+struct return_info {
+	struct expression *static_returns_call;
+	struct symbol *return_type;
+	struct range_list *return_range_list;
+};
+
+static int db_return_callback(void *_ret_info, int argc, char **argv, char **azColName)
+{
+	struct return_info *ret_info = _ret_info;
+	struct range_list *rl;
+	struct expression *call_expr = ret_info->static_returns_call;
+
+	if (argc != 1)
+		return 0;
+	call_results_to_rl(call_expr, ret_info->return_type, argv[0], &rl);
+	ret_info->return_range_list = rl_union(ret_info->return_range_list, rl);
+	return 0;
+}
+
+struct range_list *db_return_vals(struct expression *expr)
+{
+	struct return_info ret_info = {};
+	char buf[64];
+	struct sm_state *sm;
+
+	if (is_fake_call(expr))
+		return NULL;
+
+	snprintf(buf, sizeof(buf), "return %p", expr);
+	sm = get_sm_state(SMATCH_EXTRA, buf, NULL);
+	if (sm)
+		return clone_rl(estate_rl(sm->state));
+	ret_info.static_returns_call = expr;
+	ret_info.return_type = get_type(expr);
+	if (!ret_info.return_type)
+		return NULL;
+
+	if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol)
+		return NULL;
+
+	ret_info.return_range_list = NULL;
+	if (inlinable(expr->fn)) {
+		mem_sql(db_return_callback, &ret_info,
+			"select distinct return from return_states where call_id = '%lu';",
+			(unsigned long)expr);
+	} else {
+		run_sql(db_return_callback, &ret_info,
+			"select distinct return from return_states where %s;",
+			get_static_filter(expr->fn->symbol));
+	}
+	return ret_info.return_range_list;
+}
+
+struct range_list *db_return_vals_from_str(const char *fn_name)
+{
+	struct return_info ret_info;
+
+	ret_info.static_returns_call = NULL;
+	ret_info.return_type = &llong_ctype;
+	ret_info.return_range_list = NULL;
+
+	run_sql(db_return_callback, &ret_info,
+		"select distinct return from return_states where function = '%s';",
+		fn_name);
+	return ret_info.return_range_list;
+}
+
+static void match_call_marker(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr->fn);
+	if (type && type->type == SYM_PTR)
+		type = get_real_base_type(type);
+
+	/*
+	 * we just want to record something in the database so that if we have
+	 * two calls like:  frob(4); frob(some_unkown); then on the receiving
+	 * side we know that sometimes frob is called with unknown parameters.
+	 */
+
+	sql_insert_caller_info(expr, INTERNAL, -1, "%call_marker%", type_to_str(type));
+}
+
+static char *show_offset(int offset)
+{
+	static char buf[64];
+
+	buf[0] = '\0';
+	if (offset != -1)
+		snprintf(buf, sizeof(buf), "(-%d)", offset);
+	return buf;
+}
+
+static void print_struct_members(struct expression *call, struct expression *expr, int param, int offset, struct stree *stree,
+	void (*callback)(struct expression *call, int param, char *printed_name, struct sm_state *sm))
+{
+	struct sm_state *sm;
+	char *name;
+	struct symbol *sym;
+	int len;
+	char printed_name[256];
+	int is_address = 0;
+	struct symbol *type;
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return;
+	if (expr->type == EXPR_PREOP && expr->op == '&') {
+		expr = strip_expr(expr->unop);
+		is_address = 1;
+	}
+
+	type = get_type(expr);
+	if (type && type_bits(type) < type_bits(&ulong_ctype))
+		return;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+
+	len = strlen(name);
+	FOR_EACH_SM(stree, sm) {
+		if (sm->sym != sym)
+			continue;
+		if (strcmp(name, sm->name) == 0) {
+			if (is_address)
+				snprintf(printed_name, sizeof(printed_name), "*$%s", show_offset(offset));
+			else /* these are already handled. fixme: handle them here */
+				continue;
+		} else if (sm->name[0] == '*' && strcmp(name, sm->name + 1) == 0) {
+			snprintf(printed_name, sizeof(printed_name), "*$%s", show_offset(offset));
+		} else if (strncmp(name, sm->name, len) == 0) {
+			if (isalnum(sm->name[len]))
+				continue;
+			if (is_address)
+				snprintf(printed_name, sizeof(printed_name), "$%s->%s", show_offset(offset), sm->name + len + 1);
+			else
+				snprintf(printed_name, sizeof(printed_name), "$%s%s", show_offset(offset), sm->name + len);
+		} else {
+			continue;
+		}
+		callback(call, param, printed_name, sm);
+	} END_FOR_EACH_SM(sm);
+free:
+	free_string(name);
+}
+
+static int param_used_callback(void *_container, int argc, char **argv, char **azColName)
+{
+	char **container = _container;
+	static char buf[256];
+
+	snprintf(buf, sizeof(buf), "%s", argv[0]);
+	*container = buf;
+	return 0;
+}
+
+static void print_container_struct_members(struct expression *call, struct expression *expr, int param, struct stree *stree,
+	void (*callback)(struct expression *call, int param, char *printed_name, struct sm_state *sm))
+{
+	struct expression *tmp;
+	char *container = NULL;
+	int offset;
+	int holder_offset;
+	char *p;
+
+	if (!call->fn || call->fn->type != EXPR_SYMBOL || !call->fn->symbol)
+		return;
+
+	/*
+	 * We can't use the in-mem DB because we have to parse the function
+	 * first, then we know if it takes a container, then we know to pass it
+	 * the container data.
+	 *
+	 */
+	run_sql(&param_used_callback, &container,
+		"select key from return_implies where %s and type = %d and key like '%%$(%%' and parameter = %d limit 1;",
+		get_static_filter(call->fn->symbol), CONTAINER, param);
+	if (!container)
+		return;
+
+	p = strchr(container, '-');
+	if (!p)
+		return;
+	offset = atoi(p);
+	p = strchr(p, ')');
+	if (!p)
+		return;
+	p++;
+
+	tmp = get_assigned_expr(expr);
+	if (tmp)
+		expr = tmp;
+
+	if (expr->type != EXPR_PREOP || expr->op != '&')
+		return;
+	expr = strip_expr(expr->unop);
+	holder_offset = get_member_offset_from_deref(expr);
+	if (-holder_offset != offset)
+		return;
+
+	expr = strip_expr(expr->deref);
+	if (expr->type == EXPR_PREOP && expr->op == '*')
+		expr = strip_expr(expr->unop);
+
+	print_struct_members(call, expr, param, holder_offset, stree, callback);
+}
+
+static void match_call_info(struct expression *call)
+{
+	struct member_info_callback *cb;
+	struct expression *arg;
+	struct stree *stree;
+	char *name;
+	int i;
+
+	name = get_fnptr_name(call->fn);
+	if (!name)
+		return;
+
+	FOR_EACH_PTR(member_callbacks, cb) {
+		stree = get_all_states_stree(cb->owner);
+		i = 0;
+		FOR_EACH_PTR(call->args, arg) {
+			print_struct_members(call, arg, i, -1, stree, cb->callback);
+			print_container_struct_members(call, arg, i, stree, cb->callback);
+			i++;
+		} END_FOR_EACH_PTR(arg);
+		free_stree(&stree);
+	} END_FOR_EACH_PTR(cb);
+
+	free_string(name);
+}
+
+static int get_param(int param, char **name, struct symbol **sym)
+{
+	struct symbol *arg;
+	int i;
+
+	i = 0;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
+		/*
+		 * this is a temporary hack to work around a bug (I think in sparse?)
+		 * 2.6.37-rc1:fs/reiserfs/journal.o
+		 * If there is a function definition without parameter name found
+		 * after a function implementation then it causes a crash.
+		 * int foo() {}
+		 * int bar(char *);
+		 */
+		if (arg->ident->name < (char *)100)
+			continue;
+		if (i == param) {
+			*name = arg->ident->name;
+			*sym = arg;
+			return TRUE;
+		}
+		i++;
+	} END_FOR_EACH_PTR(arg);
+
+	return FALSE;
+}
+
+static int function_signature_matches(const char *sig)
+{
+	char *my_sig;
+
+	my_sig = function_signature();
+	if (!sig || !my_sig)
+		return 1;  /* default to matching */
+	if (strcmp(my_sig, sig) == 0)
+		  return 1;
+	return 0;
+}
+
+static int caller_info_callback(void *_data, int argc, char **argv, char **azColName)
+{
+	struct select_caller_info_data *data = _data;
+	int func_id;
+	long type;
+	long param;
+	char *key;
+	char *value;
+	char *name = NULL;
+	struct symbol *sym = NULL;
+	struct def_callback *def_callback;
+	struct stree *stree;
+	struct timeval cur_time;
+
+	data->results = 1;
+
+	if (argc != 5)
+		return 0;
+
+	gettimeofday(&cur_time, NULL);
+	if (cur_time.tv_sec - data->start_time.tv_sec > 10)
+		return 0;
+
+	func_id = atoi(argv[0]);
+	errno = 0;
+	type = strtol(argv[1], NULL, 10);
+	param = strtol(argv[2], NULL, 10);
+	if (errno)
+		return 0;
+	key = argv[3];
+	value = argv[4];
+
+	if (data->prev_func_id == -1)
+		data->prev_func_id = func_id;
+	if (func_id != data->prev_func_id) {
+		stree = __pop_fake_cur_stree();
+		if (!data->ignore)
+			merge_stree(&data->final_states, stree);
+		free_stree(&stree);
+		__push_fake_cur_stree();
+		__unnullify_path();
+		data->prev_func_id = func_id;
+		data->ignore = 0;
+	}
+
+	if (data->ignore)
+		return 0;
+	if (type == INTERNAL &&
+	    !function_signature_matches(value)) {
+		data->ignore = 1;
+		return 0;
+	}
+
+	if (param >= 0 && !get_param(param, &name, &sym))
+		return 0;
+
+	FOR_EACH_PTR(select_caller_info_callbacks, def_callback) {
+		if (def_callback->hook_type == type)
+			def_callback->callback(name, sym, key, value);
+	} END_FOR_EACH_PTR(def_callback);
+
+	return 0;
+}
+
+static struct string_list *ptr_names_done;
+static struct string_list *ptr_names;
+
+static int get_ptr_name(void *unused, int argc, char **argv, char **azColName)
+{
+	insert_string(&ptr_names, alloc_string(argv[0]));
+	return 0;
+}
+
+static char *get_next_ptr_name(void)
+{
+	char *ptr;
+
+	FOR_EACH_PTR(ptr_names, ptr) {
+		if (list_has_string(ptr_names_done, ptr))
+			continue;
+		insert_string(&ptr_names_done, ptr);
+		return ptr;
+	} END_FOR_EACH_PTR(ptr);
+	return NULL;
+}
+
+static void get_ptr_names(const char *file, const char *name)
+{
+	char sql_filter[1024];
+	int before, after;
+
+	if (file) {
+		snprintf(sql_filter, 1024, "file = '%s' and function = '%s';",
+			 file, name);
+	} else {
+		snprintf(sql_filter, 1024, "function = '%s';", name);
+	}
+
+	before = ptr_list_size((struct ptr_list *)ptr_names);
+
+	run_sql(get_ptr_name, NULL,
+		"select distinct ptr from function_ptr where %s",
+		sql_filter);
+
+	after = ptr_list_size((struct ptr_list *)ptr_names);
+	if (before == after)
+		return;
+
+	while ((name = get_next_ptr_name()))
+		get_ptr_names(NULL, name);
+}
+
+static void match_data_from_db(struct symbol *sym)
+{
+	struct select_caller_info_data data = { .prev_func_id = -1 };
+	struct sm_state *sm;
+	struct stree *stree;
+	struct timeval end_time;
+
+	if (!sym || !sym->ident)
+		return;
+
+	gettimeofday(&data.start_time, NULL);
+
+	__push_fake_cur_stree();
+	__unnullify_path();
+
+	if (!__inline_fn) {
+		char *ptr;
+
+		if (sym->ctype.modifiers & MOD_STATIC)
+			get_ptr_names(get_base_file(), sym->ident->name);
+		else
+			get_ptr_names(NULL, sym->ident->name);
+
+		if (ptr_list_size((struct ptr_list *)ptr_names) > 20) {
+			__free_ptr_list((struct ptr_list **)&ptr_names);
+			__free_ptr_list((struct ptr_list **)&ptr_names_done);
+			stree = __pop_fake_cur_stree();
+			free_stree(&stree);
+			return;
+		}
+
+		sql_select_caller_info(&data,
+				       "call_id, type, parameter, key, value",
+				       sym);
+
+
+		stree = __pop_fake_cur_stree();
+		if (!data.ignore)
+			merge_stree(&data.final_states, stree);
+		free_stree(&stree);
+		__push_fake_cur_stree();
+		__unnullify_path();
+		data.prev_func_id = -1;
+		data.ignore = 0;
+
+		FOR_EACH_PTR(ptr_names, ptr) {
+			run_sql(caller_info_callback, &data,
+				"select call_id, type, parameter, key, value"
+				" from common_caller_info where function = '%s' order by call_id",
+				ptr);
+		} END_FOR_EACH_PTR(ptr);
+
+		if (data.results) {
+			FOR_EACH_PTR(ptr_names, ptr) {
+				free_string(ptr);
+			} END_FOR_EACH_PTR(ptr);
+			goto free_ptr_names;
+		}
+
+		FOR_EACH_PTR(ptr_names, ptr) {
+			run_sql(caller_info_callback, &data,
+				"select call_id, type, parameter, key, value"
+				" from caller_info where function = '%s' order by call_id",
+				ptr);
+			free_string(ptr);
+		} END_FOR_EACH_PTR(ptr);
+
+free_ptr_names:
+		__free_ptr_list((struct ptr_list **)&ptr_names);
+		__free_ptr_list((struct ptr_list **)&ptr_names_done);
+	} else {
+		sql_select_caller_info(&data,
+				       "call_id, type, parameter, key, value",
+				       sym);
+	}
+
+	stree = __pop_fake_cur_stree();
+	if (!data.ignore)
+		merge_stree(&data.final_states, stree);
+	free_stree(&stree);
+
+	gettimeofday(&end_time, NULL);
+	if (end_time.tv_sec - data.start_time.tv_sec <= 10) {
+		FOR_EACH_SM(data.final_states, sm) {
+			__set_sm(sm);
+		} END_FOR_EACH_SM(sm);
+	}
+
+	free_stree(&data.final_states);
+}
+
+static int return_implies_callbacks(void *_info, int argc, char **argv, char **azColName)
+{
+	struct implies_info *info = _info;
+	struct db_implies_callback *cb;
+	struct expression *arg = NULL;
+	int type;
+	int param;
+
+	if (argc != 5)
+		return 0;
+
+	type = atoi(argv[1]);
+	param = atoi(argv[2]);
+
+	FOR_EACH_PTR(info->cb_list, cb) {
+		if (cb->type != type)
+			continue;
+		if (param != -1) {
+			arg = get_argument_from_call_expr(info->expr->args, param);
+			if (!arg)
+				continue;
+		}
+		cb->callback(info->expr, arg, argv[3], argv[4]);
+	} END_FOR_EACH_PTR(cb);
+
+	return 0;
+}
+
+static int call_implies_callbacks(void *_info, int argc, char **argv, char **azColName)
+{
+	struct implies_info *info = _info;
+	struct db_implies_callback *cb;
+	struct expression *arg;
+	struct symbol *sym;
+	char *name;
+	int type;
+	int param;
+
+	if (argc != 5)
+		return 0;
+
+	type = atoi(argv[1]);
+	param = atoi(argv[2]);
+
+	if (!get_param(param, &name, &sym))
+		return 0;
+	arg = symbol_expression(sym);
+	if (!arg)
+		return 0;
+
+	FOR_EACH_PTR(info->cb_list, cb) {
+		if (cb->type != type)
+			continue;
+		cb->callback(info->expr, arg, argv[3], argv[4]);
+	} END_FOR_EACH_PTR(cb);
+
+	return 0;
+}
+
+static void match_return_implies(struct expression *expr)
+{
+	struct implies_info info = {
+		.type = RETURN_IMPLIES,
+		.cb_list = return_implies_cb_list,
+	};
+
+	if (expr->fn->type != EXPR_SYMBOL ||
+	    !expr->fn->symbol)
+		return;
+	info.expr = expr;
+	info.sym = expr->fn->symbol;
+	sql_select_implies("function, type, parameter, key, value", &info,
+			   return_implies_callbacks);
+}
+
+static void match_call_implies(struct symbol *sym)
+{
+	struct implies_info info = {
+		.type = CALL_IMPLIES,
+		.cb_list = call_implies_cb_list,
+	};
+
+	if (!sym || !sym->ident)
+		return;
+
+	info.sym = sym;
+	sql_select_implies("function, type, parameter, key, value", &info,
+			   call_implies_callbacks);
+}
+
+static void print_initializer_list(struct expression_list *expr_list,
+		struct symbol *struct_type)
+{
+	struct expression *expr;
+	struct symbol *base_type;
+	char struct_name[256];
+
+	FOR_EACH_PTR(expr_list, expr) {
+		if (expr->type == EXPR_INDEX && expr->idx_expression && expr->idx_expression->type == EXPR_INITIALIZER) {
+			print_initializer_list(expr->idx_expression->expr_list, struct_type);
+			continue;
+		}
+		if (expr->type != EXPR_IDENTIFIER)
+			continue;
+		if (!expr->expr_ident)
+			continue;
+		if (!expr->ident_expression || !expr->ident_expression->symbol_name)
+			continue;
+		base_type = get_type(expr->ident_expression);
+		if (!base_type || base_type->type != SYM_FN)
+			continue;
+		snprintf(struct_name, sizeof(struct_name), "(struct %s)->%s",
+			 struct_type->ident->name, expr->expr_ident->name);
+		sql_insert_function_ptr(expr->ident_expression->symbol_name->name,
+				        struct_name);
+	} END_FOR_EACH_PTR(expr);
+}
+
+static void global_variable(struct symbol *sym)
+{
+	struct symbol *struct_type;
+
+	if (!sym->ident)
+		return;
+	if (!sym->initializer || sym->initializer->type != EXPR_INITIALIZER)
+		return;
+	struct_type = get_base_type(sym);
+	if (!struct_type)
+		return;
+	if (struct_type->type == SYM_ARRAY) {
+		struct_type = get_base_type(struct_type);
+		if (!struct_type)
+			return;
+	}
+	if (struct_type->type != SYM_STRUCT || !struct_type->ident)
+		return;
+	print_initializer_list(sym->initializer->expr_list, struct_type);
+}
+
+static void match_return_info(int return_id, char *return_ranges, struct expression *expr)
+{
+	sql_insert_return_states(return_id, return_ranges, INTERNAL, -1, "", function_signature());
+}
+
+static void call_return_state_hooks_conditional(struct expression *expr)
+{
+	struct returned_state_callback *cb;
+	struct range_list *rl;
+	char *return_ranges;
+	int final_pass_orig = final_pass;
+
+	__push_fake_cur_stree();
+
+	final_pass = 0;
+	__split_whole_condition(expr->conditional);
+	final_pass = final_pass_orig;
+
+	if (get_implied_rl(expr->cond_true, &rl))
+		rl = cast_rl(cur_func_return_type(), rl);
+	else
+		rl = cast_rl(cur_func_return_type(), alloc_whole_rl(get_type(expr->cond_true)));
+	return_ranges = show_rl(rl);
+	set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(rl));
+
+	return_id++;
+	FOR_EACH_PTR(returned_state_callbacks, cb) {
+		cb->callback(return_id, return_ranges, expr->cond_true);
+	} END_FOR_EACH_PTR(cb);
+
+	__push_true_states();
+	__use_false_states();
+
+	if (get_implied_rl(expr->cond_false, &rl))
+		rl = cast_rl(cur_func_return_type(), rl);
+	else
+		rl = cast_rl(cur_func_return_type(), alloc_whole_rl(get_type(expr->cond_false)));
+	return_ranges = show_rl(rl);
+	set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(rl));
+
+	return_id++;
+	FOR_EACH_PTR(returned_state_callbacks, cb) {
+		cb->callback(return_id, return_ranges, expr->cond_false);
+	} END_FOR_EACH_PTR(cb);
+
+	__merge_true_states();
+	__free_fake_cur_stree();
+}
+
+static void call_return_state_hooks_compare(struct expression *expr)
+{
+	struct returned_state_callback *cb;
+	char *return_ranges;
+	int final_pass_orig = final_pass;
+	sval_t sval = { .type = &int_ctype };
+	sval_t ret;
+
+	if (!get_implied_value(expr, &ret))
+		ret.value = -1;
+
+	__push_fake_cur_stree();
+
+	final_pass = 0;
+	__split_whole_condition(expr);
+	final_pass = final_pass_orig;
+
+	if (ret.value != 0) {
+		return_ranges = alloc_sname("1");
+		sval.value = 1;
+		set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_sval(sval));
+
+		return_id++;
+		FOR_EACH_PTR(returned_state_callbacks, cb) {
+			cb->callback(return_id, return_ranges, expr);
+		} END_FOR_EACH_PTR(cb);
+	}
+
+	__push_true_states();
+	__use_false_states();
+
+	if (ret.value != 1) {
+		return_ranges = alloc_sname("0");
+		sval.value = 0;
+		set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_sval(sval));
+
+		return_id++;
+		FOR_EACH_PTR(returned_state_callbacks, cb) {
+			cb->callback(return_id, return_ranges, expr);
+		} END_FOR_EACH_PTR(cb);
+	}
+
+	__merge_true_states();
+	__free_fake_cur_stree();
+}
+
+static int ptr_in_list(struct sm_state *sm, struct state_list *slist)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(slist, tmp) {
+		if (strcmp(tmp->state->name, sm->state->name) == 0)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static char *get_return_compare_str(struct expression *expr)
+{
+	char *compare_str;
+	char *var;
+	char buf[256];
+	int comparison;
+	int param;
+
+	compare_str = expr_lte_to_param(expr, -1);
+	if (compare_str)
+		return compare_str;
+	param = get_param_num(expr);
+	if (param < 0)
+		return NULL;
+
+	var = expr_to_var(expr);
+	if (!var)
+		return NULL;
+	snprintf(buf, sizeof(buf), "%s orig", var);
+	comparison = get_comparison_strings(var, buf);
+	free_string(var);
+
+	if (!comparison)
+		return NULL;
+
+	snprintf(buf, sizeof(buf), "[%s$%d]", show_special(comparison), param);
+	return alloc_sname(buf);
+}
+
+static int split_possible_helper(struct sm_state *sm, struct expression *expr)
+{
+	struct returned_state_callback *cb;
+	struct range_list *rl;
+	char *return_ranges;
+	struct sm_state *tmp;
+	int ret = 0;
+	int nr_possible, nr_states;
+	char *compare_str = NULL;
+	char buf[128];
+	struct state_list *already_handled = NULL;
+
+	if (!sm || !sm->merged)
+		return 0;
+
+	if (too_many_possible(sm))
+		return 0;
+
+	/* bail if it gets too complicated */
+	nr_possible = ptr_list_size((struct ptr_list *)sm->possible);
+	nr_states = get_db_state_count();
+	if (nr_states * nr_possible >= 2000)
+		return 0;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->merged)
+			continue;
+		if (ptr_in_list(tmp, already_handled))
+			continue;
+		add_ptr_list(&already_handled, tmp);
+
+		ret = 1;
+		__push_fake_cur_stree();
+
+		overwrite_states_using_pool(sm, tmp);
+
+		rl = cast_rl(cur_func_return_type(), estate_rl(tmp->state));
+		return_ranges = show_rl(rl);
+		set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(clone_rl(rl)));
+		compare_str = get_return_compare_str(expr);
+		if (compare_str) {
+			snprintf(buf, sizeof(buf), "%s%s", return_ranges, compare_str);
+			return_ranges = alloc_sname(buf);
+		}
+
+		return_id++;
+		FOR_EACH_PTR(returned_state_callbacks, cb) {
+			cb->callback(return_id, return_ranges, expr);
+		} END_FOR_EACH_PTR(cb);
+
+		__free_fake_cur_stree();
+	} END_FOR_EACH_PTR(tmp);
+
+	free_slist(&already_handled);
+
+	return ret;
+}
+
+static int call_return_state_hooks_split_possible(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	if (!expr || expr_equal_to_param(expr, -1))
+		return 0;
+
+	sm = get_sm_state_expr(SMATCH_EXTRA, expr);
+	return split_possible_helper(sm, expr);
+}
+
+static const char *get_return_ranges_str(struct expression *expr, struct range_list **rl_p)
+{
+	struct range_list *rl;
+	char *return_ranges;
+	sval_t sval;
+	char *compare_str;
+	char *math_str;
+	char buf[128];
+
+	*rl_p = NULL;
+
+	if (!expr)
+		return alloc_sname("");
+
+	if (get_implied_value(expr, &sval)) {
+		sval = sval_cast(cur_func_return_type(), sval);
+		*rl_p = alloc_rl(sval, sval);
+		return sval_to_str(sval);
+	}
+
+	compare_str = expr_equal_to_param(expr, -1);
+	math_str = get_value_in_terms_of_parameter_math(expr);
+
+	if (get_implied_rl(expr, &rl)) {
+		rl = cast_rl(cur_func_return_type(), rl);
+		return_ranges = show_rl(rl);
+	} else if (get_imaginary_absolute(expr, &rl)){
+		rl = cast_rl(cur_func_return_type(), rl);
+		return alloc_sname(show_rl(rl));
+	} else {
+		rl = cast_rl(cur_func_return_type(), alloc_whole_rl(get_type(expr)));
+		return_ranges = show_rl(rl);
+	}
+	*rl_p = rl;
+
+	if (compare_str) {
+		snprintf(buf, sizeof(buf), "%s%s", return_ranges, compare_str);
+		return alloc_sname(buf);
+	}
+	if (math_str) {
+		snprintf(buf, sizeof(buf), "%s[%s]", return_ranges, math_str);
+		return alloc_sname(buf);
+	}
+	compare_str = get_return_compare_str(expr);
+	if (compare_str) {
+		snprintf(buf, sizeof(buf), "%s%s", return_ranges, compare_str);
+		return alloc_sname(buf);
+	}
+
+	return return_ranges;
+}
+
+static bool has_possible_negative(struct sm_state *sm)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (!estate_rl(tmp->state))
+			continue;
+		if (sval_is_negative(estate_min(tmp->state)) &&
+		    sval_is_negative(estate_max(tmp->state)))
+			return true;
+	} END_FOR_EACH_PTR(tmp);
+
+	return false;
+}
+
+static bool has_possible_zero_null(struct sm_state *sm)
+{
+	struct sm_state *tmp;
+	sval_t sval;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (!estate_get_single_value(tmp->state, &sval))
+			continue;
+		if (sval.value == 0)
+			return true;
+	} END_FOR_EACH_PTR(tmp);
+
+	return false;
+}
+
+static int split_positive_from_negative(struct expression *expr)
+{
+	struct sm_state *sm;
+	struct returned_state_callback *cb;
+	struct range_list *rl;
+	const char *return_ranges;
+	struct range_list *ret_rl;
+	int undo;
+
+	/* We're going to print the states 3 times */
+	if (get_db_state_count() > 10000 / 3)
+		return 0;
+
+	if (!get_implied_rl(expr, &rl) || !rl)
+		return 0;
+	if (is_whole_rl(rl) || is_whole_rl_non_zero(rl))
+		return 0;
+	/* Forget about INT_MAX and larger */
+	if (rl_max(rl).value <= 0)
+		return 0;
+	if (!sval_is_negative(rl_min(rl)))
+		return 0;
+
+	sm = get_sm_state_expr(SMATCH_EXTRA, expr);
+	if (!sm)
+		return 0;
+	if (!has_possible_negative(sm))
+		return 0;
+
+	if (!assume(compare_expression(expr, '>', zero_expr())))
+		return 0;
+
+	return_id++;
+	return_ranges = get_return_ranges_str(expr, &ret_rl);
+	set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(ret_rl));
+	FOR_EACH_PTR(returned_state_callbacks, cb) {
+		cb->callback(return_id, (char *)return_ranges, expr);
+	} END_FOR_EACH_PTR(cb);
+
+	end_assume();
+
+	if (rl_has_sval(rl, sval_type_val(rl_type(rl), 0))) {
+		undo = assume(compare_expression(expr, SPECIAL_EQUAL, zero_expr()));
+
+		return_id++;
+		return_ranges = get_return_ranges_str(expr, &ret_rl);
+		set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(ret_rl));
+		FOR_EACH_PTR(returned_state_callbacks, cb) {
+			cb->callback(return_id, (char *)return_ranges, expr);
+		} END_FOR_EACH_PTR(cb);
+
+		if (undo)
+			end_assume();
+	}
+
+	undo = assume(compare_expression(expr, '<', zero_expr()));
+
+	return_id++;
+	return_ranges = get_return_ranges_str(expr, &ret_rl);
+	set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(ret_rl));
+	FOR_EACH_PTR(returned_state_callbacks, cb) {
+		cb->callback(return_id, (char *)return_ranges, expr);
+	} END_FOR_EACH_PTR(cb);
+
+	if (undo)
+		end_assume();
+
+	return 1;
+}
+
+static int call_return_state_hooks_split_null_non_null(struct expression *expr)
+{
+	struct returned_state_callback *cb;
+	struct range_list *rl;
+	struct range_list *nonnull_rl;
+	sval_t null_sval;
+	struct range_list *null_rl = NULL;
+	char *return_ranges;
+	struct sm_state *sm;
+	struct smatch_state *state;
+	int nr_states;
+	int final_pass_orig = final_pass;
+
+	if (!expr || expr_equal_to_param(expr, -1))
+		return 0;
+	if (expr->type == EXPR_CALL)
+		return 0;
+	if (!is_pointer(expr))
+		return 0;
+
+	sm = get_sm_state_expr(SMATCH_EXTRA, expr);
+	if (!sm)
+		return 0;
+	if (ptr_list_size((struct ptr_list *)sm->possible) == 1)
+		return 0;
+	state = sm->state;
+	if (!estate_rl(state))
+		return 0;
+	if (estate_min(state).value == 0 && estate_max(state).value == 0)
+		return 0;
+	if (!has_possible_zero_null(sm))
+		return 0;
+
+	nr_states = get_db_state_count();
+	if (option_info && nr_states >= 1500)
+		return 0;
+
+	rl = estate_rl(state);
+
+	__push_fake_cur_stree();
+
+	final_pass = 0;
+	__split_whole_condition(expr);
+	final_pass = final_pass_orig;
+
+	nonnull_rl = rl_filter(rl, rl_zero());
+	return_ranges = show_rl(nonnull_rl);
+	set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(nonnull_rl));
+
+	return_id++;
+	FOR_EACH_PTR(returned_state_callbacks, cb) {
+		cb->callback(return_id, return_ranges, expr);
+	} END_FOR_EACH_PTR(cb);
+
+	__push_true_states();
+	__use_false_states();
+
+	return_ranges = alloc_sname("0");
+	null_sval = sval_type_val(rl_type(rl), 0);
+	add_range(&null_rl, null_sval, null_sval);
+	set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(null_rl));
+	return_id++;
+	FOR_EACH_PTR(returned_state_callbacks, cb) {
+		cb->callback(return_id, return_ranges, expr);
+	} END_FOR_EACH_PTR(cb);
+
+	__merge_true_states();
+	__free_fake_cur_stree();
+
+	return 1;
+}
+
+static int call_return_state_hooks_split_success_fail(struct expression *expr)
+{
+	struct sm_state *sm;
+	struct range_list *rl;
+	struct range_list *nonzero_rl;
+	sval_t zero_sval;
+	struct range_list *zero_rl = NULL;
+	int nr_states;
+	struct returned_state_callback *cb;
+	char *return_ranges;
+	int final_pass_orig = final_pass;
+
+	if (option_project != PROJ_KERNEL)
+		return 0;
+
+	nr_states = get_db_state_count();
+	if (nr_states > 1500)
+		return 0;
+
+	sm = get_sm_state_expr(SMATCH_EXTRA, expr);
+	if (!sm)
+		return 0;
+	if (ptr_list_size((struct ptr_list *)sm->possible) == 1)
+		return 0;
+
+	rl = estate_rl(sm->state);
+	if (!rl)
+		return 0;
+
+	if (rl_min(rl).value < -4095 || rl_min(rl).value >= 0)
+		return 0;
+	if (rl_max(rl).value != 0)
+		return 0;
+	if (!has_possible_zero_null(sm))
+		return 0;
+
+	__push_fake_cur_stree();
+
+	final_pass = 0;
+	__split_whole_condition(expr);
+	final_pass = final_pass_orig;
+
+	nonzero_rl = rl_filter(rl, rl_zero());
+	nonzero_rl = cast_rl(cur_func_return_type(), nonzero_rl);
+	return_ranges = show_rl(nonzero_rl);
+	set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(nonzero_rl));
+
+	return_id++;
+	FOR_EACH_PTR(returned_state_callbacks, cb) {
+		cb->callback(return_id, return_ranges, expr);
+	} END_FOR_EACH_PTR(cb);
+
+	__push_true_states();
+	__use_false_states();
+
+	return_ranges = alloc_sname("0");
+	zero_sval = sval_type_val(rl_type(rl), 0);
+	add_range(&zero_rl, zero_sval, zero_sval);
+	set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(zero_rl));
+	return_id++;
+	FOR_EACH_PTR(returned_state_callbacks, cb) {
+		cb->callback(return_id, return_ranges, expr);
+	} END_FOR_EACH_PTR(cb);
+
+	__merge_true_states();
+	__free_fake_cur_stree();
+
+	return 1;
+}
+
+static int is_boolean(struct expression *expr)
+{
+	struct range_list *rl;
+
+	if (!get_implied_rl(expr, &rl))
+		return 0;
+	if (rl_min(rl).value == 0 && rl_max(rl).value == 1)
+		return 1;
+	return 0;
+}
+
+static int is_conditional(struct expression *expr)
+{
+	if (!expr)
+		return 0;
+	if (expr->type == EXPR_CONDITIONAL || expr->type == EXPR_SELECT)
+		return 1;
+	return 0;
+}
+
+static int splitable_function_call(struct expression *expr)
+{
+	struct sm_state *sm;
+	char buf[64];
+
+	if (!expr || expr->type != EXPR_CALL)
+		return 0;
+	snprintf(buf, sizeof(buf), "return %p", expr);
+	sm = get_sm_state(SMATCH_EXTRA, buf, NULL);
+	return split_possible_helper(sm, expr);
+}
+
+static struct sm_state *find_bool_param(void)
+{
+	struct stree *start_states;
+	struct symbol *arg;
+	struct sm_state *sm, *tmp;
+	sval_t sval;
+
+	start_states = get_start_states();
+
+	FOR_EACH_PTR_REVERSE(cur_func_sym->ctype.base_type->arguments, arg) {
+		if (!arg->ident)
+			continue;
+		sm = get_sm_state_stree(start_states, SMATCH_EXTRA, arg->ident->name, arg);
+		if (!sm)
+			continue;
+		if (rl_min(estate_rl(sm->state)).value != 0 ||
+		    rl_max(estate_rl(sm->state)).value != 1)
+			continue;
+		goto found;
+	} END_FOR_EACH_PTR_REVERSE(arg);
+
+	return NULL;
+
+found:
+	/*
+	 * Check if it's splitable.  If not, then splitting it up is likely not
+	 * useful for the callers.
+	 */
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (is_merged(tmp))
+			continue;
+		if (!estate_get_single_value(tmp->state, &sval))
+			return NULL;
+	} END_FOR_EACH_PTR(tmp);
+
+	return sm;
+}
+
+static int split_on_bool_sm(struct sm_state *sm, struct expression *expr)
+{
+	struct returned_state_callback *cb;
+	struct range_list *ret_rl;
+	const char *return_ranges;
+	struct sm_state *tmp;
+	int ret = 0;
+	int nr_possible, nr_states;
+	char *compare_str = NULL;
+	char buf[128];
+	struct state_list *already_handled = NULL;
+
+	if (!sm || !sm->merged)
+		return 0;
+
+	if (too_many_possible(sm))
+		return 0;
+
+	/* bail if it gets too complicated */
+	nr_possible = ptr_list_size((struct ptr_list *)sm->possible);
+	nr_states = get_db_state_count();
+	if (nr_states * nr_possible >= 2000)
+		return 0;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->merged)
+			continue;
+		if (ptr_in_list(tmp, already_handled))
+			continue;
+		add_ptr_list(&already_handled, tmp);
+
+		ret = 1;
+		__push_fake_cur_stree();
+
+		overwrite_states_using_pool(sm, tmp);
+
+		return_ranges = get_return_ranges_str(expr, &ret_rl);
+		set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(ret_rl));
+		compare_str = get_return_compare_str(expr);
+		if (compare_str) {
+			snprintf(buf, sizeof(buf), "%s%s", return_ranges, compare_str);
+			return_ranges = alloc_sname(buf);
+		}
+
+		return_id++;
+		FOR_EACH_PTR(returned_state_callbacks, cb) {
+			cb->callback(return_id, (char *)return_ranges, expr);
+		} END_FOR_EACH_PTR(cb);
+
+		__free_fake_cur_stree();
+	} END_FOR_EACH_PTR(tmp);
+
+	free_slist(&already_handled);
+
+	return ret;
+}
+
+static int split_by_bool_param(struct expression *expr)
+{
+	struct sm_state *start_sm, *sm;
+	sval_t sval;
+
+	start_sm = find_bool_param();
+	if (!start_sm)
+		return 0;
+	sm = get_sm_state(SMATCH_EXTRA, start_sm->name, start_sm->sym);
+	if (!sm || estate_get_single_value(sm->state, &sval))
+		return 0;
+	return split_on_bool_sm(sm, expr);
+}
+
+static int split_by_null_nonnull_param(struct expression *expr)
+{
+	struct symbol *arg;
+	struct sm_state *sm;
+	sval_t zero = {
+		.type = &ulong_ctype,
+	};
+
+	/* function must only take one pointer */
+	if (ptr_list_size((struct ptr_list *)cur_func_sym->ctype.base_type->arguments) != 1)
+		return 0;
+	arg = first_ptr_list((struct ptr_list *)cur_func_sym->ctype.base_type->arguments);
+	if (!arg->ident)
+		return 0;
+	if (get_real_base_type(arg)->type != SYM_PTR)
+		return 0;
+
+	if (param_was_set_var_sym(arg->ident->name, arg))
+		return 0;
+	sm = get_sm_state(SMATCH_EXTRA, arg->ident->name, arg);
+	if (!sm)
+		return 0;
+
+	if (!rl_has_sval(estate_rl(sm->state), zero))
+		return 0;
+
+	return split_on_bool_sm(sm, expr);
+}
+
+struct expression *strip_expr_statement(struct expression *expr)
+{
+	struct expression *orig = expr;
+	struct statement *stmt, *last_stmt;
+
+	if (!expr)
+		return NULL;
+	if (expr->type == EXPR_PREOP && expr->op == '(')
+		expr = expr->unop;
+	if (expr->type != EXPR_STATEMENT)
+		return orig;
+	stmt = expr->statement;
+	if (!stmt || stmt->type != STMT_COMPOUND)
+		return orig;
+
+	last_stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
+	if (!last_stmt || last_stmt->type == STMT_LABEL)
+		last_stmt = last_stmt->label_statement;
+	if (!last_stmt || last_stmt->type != STMT_EXPRESSION)
+		return orig;
+	return strip_expr(last_stmt->expression);
+}
+
+static void call_return_state_hooks(struct expression *expr)
+{
+	struct returned_state_callback *cb;
+	struct range_list *ret_rl;
+	const char *return_ranges;
+	int nr_states;
+	sval_t sval;
+
+	if (__path_is_null())
+		return;
+
+	expr = strip_expr(expr);
+	expr = strip_expr_statement(expr);
+
+	if (is_impossible_path())
+		goto vanilla;
+
+	if (expr && (expr->type == EXPR_COMPARE ||
+		     !get_implied_value(expr, &sval)) &&
+	    (is_condition(expr) || is_boolean(expr))) {
+		call_return_state_hooks_compare(expr);
+		return;
+	} else if (is_conditional(expr)) {
+		call_return_state_hooks_conditional(expr);
+		return;
+	} else if (call_return_state_hooks_split_possible(expr)) {
+		return;
+	} else if (call_return_state_hooks_split_null_non_null(expr)) {
+		return;
+	} else if (call_return_state_hooks_split_success_fail(expr)) {
+		return;
+	} else if (splitable_function_call(expr)) {
+		return;
+	} else if (split_positive_from_negative(expr)) {
+		return;
+	} else if (split_by_bool_param(expr)) {
+	} else if (split_by_null_nonnull_param(expr)) {
+		return;
+	}
+
+vanilla:
+	return_ranges = get_return_ranges_str(expr, &ret_rl);
+	set_state(RETURN_ID, "return_ranges", NULL, alloc_estate_rl(ret_rl));
+
+	return_id++;
+	nr_states = get_db_state_count();
+	if (nr_states >= 10000) {
+		match_return_info(return_id, (char *)return_ranges, expr);
+		mark_all_params_untracked(return_id, (char *)return_ranges, expr);
+		return;
+	}
+	FOR_EACH_PTR(returned_state_callbacks, cb) {
+		cb->callback(return_id, (char *)return_ranges, expr);
+	} END_FOR_EACH_PTR(cb);
+}
+
+static void print_returned_struct_members(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct returned_member_callback *cb;
+	struct stree *stree;
+	struct sm_state *sm;
+	struct symbol *type;
+	char *name;
+	char member_name[256];
+	int len;
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_PTR)
+		return;
+	name = expr_to_var(expr);
+	if (!name)
+		return;
+
+	member_name[sizeof(member_name) - 1] = '\0';
+	strcpy(member_name, "$");
+
+	len = strlen(name);
+	FOR_EACH_PTR(returned_member_callbacks, cb) {
+		stree = __get_cur_stree();
+		FOR_EACH_MY_SM(cb->owner, stree, sm) {
+			if (sm->name[0] == '*' && strcmp(sm->name + 1, name) == 0) {
+				strcpy(member_name, "*$");
+				cb->callback(return_id, return_ranges, expr, member_name, sm->state);
+				continue;
+			}
+			if (strncmp(sm->name, name, len) != 0)
+				continue;
+			if (strncmp(sm->name + len, "->", 2) != 0)
+				continue;
+			snprintf(member_name, sizeof(member_name), "$%s", sm->name + len);
+			cb->callback(return_id, return_ranges, expr, member_name, sm->state);
+		} END_FOR_EACH_SM(sm);
+	} END_FOR_EACH_PTR(cb);
+
+	free_string(name);
+}
+
+static void reset_memdb(struct symbol *sym)
+{
+	mem_sql(NULL, NULL, "delete from caller_info;");
+	mem_sql(NULL, NULL, "delete from return_states;");
+	mem_sql(NULL, NULL, "delete from call_implies;");
+	mem_sql(NULL, NULL, "delete from return_implies;");
+}
+
+static void match_end_func_info(struct symbol *sym)
+{
+	if (__path_is_null())
+		return;
+	call_return_state_hooks(NULL);
+}
+
+static void match_after_func(struct symbol *sym)
+{
+	if (!__inline_fn)
+		reset_memdb(sym);
+}
+
+static void init_memdb(void)
+{
+	char *err = NULL;
+	int rc;
+	const char *schema_files[] = {
+		"db/db.schema",
+		"db/caller_info.schema",
+		"db/common_caller_info.schema",
+		"db/return_states.schema",
+		"db/function_type_size.schema",
+		"db/type_size.schema",
+		"db/function_type_info.schema",
+		"db/type_info.schema",
+		"db/call_implies.schema",
+		"db/return_implies.schema",
+		"db/function_ptr.schema",
+		"db/local_values.schema",
+		"db/function_type_value.schema",
+		"db/type_value.schema",
+		"db/function_type.schema",
+		"db/data_info.schema",
+		"db/parameter_name.schema",
+		"db/constraints.schema",
+		"db/constraints_required.schema",
+		"db/fn_ptr_data_link.schema",
+		"db/fn_data_link.schema",
+		"db/mtag_about.schema",
+		"db/mtag_map.schema",
+		"db/mtag_data.schema",
+		"db/mtag_alias.schema",
+	};
+	static char buf[4096];
+	int fd;
+	int ret;
+	int i;
+
+	rc = sqlite3_open(":memory:", &mem_db);
+	if (rc != SQLITE_OK) {
+		sm_ierror("starting In-Memory database.");
+		return;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(schema_files); i++) {
+		fd = open_schema_file(schema_files[i]);
+		if (fd < 0)
+			continue;
+		ret = read(fd, buf, sizeof(buf));
+		if (ret < 0) {
+			sm_ierror("failed to read: %s", schema_files[i]);
+			continue;
+		}
+		close(fd);
+		if (ret == sizeof(buf)) {
+			sm_ierror("Schema file too large:  %s (limit %zd bytes)",
+			       schema_files[i], sizeof(buf));
+			continue;
+		}
+		buf[ret] = '\0';
+		rc = sqlite3_exec(mem_db, buf, NULL, NULL, &err);
+		if (rc != SQLITE_OK) {
+			sm_ierror("SQL error #2: %s", err);
+			sm_ierror("%s", buf);
+		}
+	}
+}
+
+static void init_cachedb(void)
+{
+	char *err = NULL;
+	int rc;
+	const char *schema_files[] = {
+		"db/call_implies.schema",
+		"db/return_implies.schema",
+		"db/type_info.schema",
+		"db/mtag_data.schema",
+		"db/sink_info.schema",
+	};
+	static char buf[4096];
+	int fd;
+	int ret;
+	int i;
+
+	rc = sqlite3_open(":memory:", &cache_db);
+	if (rc != SQLITE_OK) {
+		sm_ierror("starting In-Memory database.");
+		return;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(schema_files); i++) {
+		fd = open_schema_file(schema_files[i]);
+		if (fd < 0)
+			continue;
+		ret = read(fd, buf, sizeof(buf));
+		if (ret < 0) {
+			sm_ierror("failed to read: %s", schema_files[i]);
+			continue;
+		}
+		close(fd);
+		if (ret == sizeof(buf)) {
+			sm_ierror("Schema file too large:  %s (limit %zd bytes)",
+			       schema_files[i], sizeof(buf));
+			continue;
+		}
+		buf[ret] = '\0';
+		rc = sqlite3_exec(cache_db, buf, NULL, NULL, &err);
+		if (rc != SQLITE_OK) {
+			sm_ierror("SQL error #2: %s", err);
+			sm_ierror("%s", buf);
+		}
+	}
+}
+
+static int save_cache_data(void *_table, int argc, char **argv, char **azColName)
+{
+	static char buf[4096];
+	char tmp[256];
+	char *p = buf;
+	char *table = _table;
+	int i;
+
+
+	p += snprintf(p, 4096 - (p - buf), "insert or ignore into %s values (", table);
+	for (i = 0; i < argc; i++) {
+		if (i)
+			p += snprintf(p, 4096 - (p - buf), ", ");
+		sqlite3_snprintf(sizeof(tmp), tmp, "%q", argv[i]);
+		p += snprintf(p, 4096 - (p - buf), "'%s'", tmp);
+
+	}
+	p += snprintf(p, 4096 - (p - buf), ");");
+	if (p - buf > 4096)
+		return 0;
+
+	sm_msg("SQL: %s", buf);
+	return 0;
+}
+
+static void dump_cache(struct symbol_list *sym_list)
+{
+	if (!option_info)
+		return;
+	cache_sql(&save_cache_data, (char *)"type_info", "select * from type_info;");
+	cache_sql(&save_cache_data, (char *)"return_implies", "select * from return_implies;");
+	cache_sql(&save_cache_data, (char *)"call_implies", "select * from call_implies;");
+	cache_sql(&save_cache_data, (char *)"mtag_data", "select * from mtag_data;");
+	cache_sql(&save_cache_data, (char *)"sink_info", "select * from sink_info;");
+}
+
+void open_smatch_db(char *db_file)
+{
+	int rc;
+
+	if (option_no_db)
+		return;
+
+	use_states = malloc(num_checks + 1);
+	memset(use_states, 0xff, num_checks + 1);
+
+	init_memdb();
+	init_cachedb();
+
+	rc = sqlite3_open_v2(db_file, &smatch_db, SQLITE_OPEN_READONLY, NULL);
+	if (rc != SQLITE_OK) {
+		option_no_db = 1;
+		return;
+	}
+	run_sql(NULL, NULL,
+		"PRAGMA cache_size = %d;", SQLITE_CACHE_PAGES);
+	return;
+}
+
+static void register_common_funcs(void)
+{
+	struct token *token;
+	char *func;
+	char filename[256];
+
+	if (option_project == PROJ_NONE)
+		strcpy(filename, "common_functions");
+	else
+		snprintf(filename, 256, "%s.common_functions", option_project_str);
+
+	token = get_tokens_file(filename);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = alloc_string(show_ident(token->ident));
+		add_ptr_list(&common_funcs, func);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static char *get_next_string(char **str)
+{
+	static char string[256];
+	char *start;
+	char *p = *str;
+	int len;
+
+	if (*p == '\0')
+		return NULL;
+	start = p;
+
+	while (*p != '\0' && *p != ' ' && *p != '\n')
+		p++;
+
+	len = p - start;
+	if (len > 256) {
+		memcpy(string, start, 255);
+		string[255] = '\0';
+		sm_ierror("return_fix: '%s' too long", string);
+		**str = '\0';
+		return NULL;
+	}
+	memcpy(string, start, len);
+	string[len] = '\0';
+	if (*p != '\0')
+		p++;
+	*str = p;
+	return string;
+}
+
+static void register_return_replacements(void)
+{
+	char *func, *orig, *new;
+	char filename[256];
+	char buf[4096];
+	int fd, ret, i;
+	char *p;
+
+	snprintf(filename, 256, "db/%s.return_fixes", option_project_str);
+	fd = open_schema_file(filename);
+	if (fd < 0)
+		return;
+	ret = read(fd, buf, sizeof(buf));
+	close(fd);
+	if (ret < 0)
+		return;
+	if (ret == sizeof(buf)) {
+		sm_ierror("file too large:  %s (limit %zd bytes)",
+		       filename, sizeof(buf));
+		return;
+	}
+	buf[ret] = '\0';
+
+	p = buf;
+	while (*p) {
+		get_next_string(&p);
+		replace_count++;
+	}
+	if (replace_count == 0 || replace_count % 3 != 0) {
+		replace_count = 0;
+		return;
+	}
+	replace_table = malloc(replace_count * sizeof(char *));
+
+	p = buf;
+	i = 0;
+	while (*p) {
+		func = alloc_string(get_next_string(&p));
+		orig = alloc_string(get_next_string(&p));
+		new  = alloc_string(get_next_string(&p));
+
+		replace_table[i++] = func;
+		replace_table[i++] = orig;
+		replace_table[i++] = new;
+	}
+}
+
+void register_definition_db_callbacks(int id)
+{
+	add_hook(&match_call_info, FUNCTION_CALL_HOOK);
+	add_hook(&global_variable, BASE_HOOK);
+	add_hook(&global_variable, DECLARATION_HOOK);
+	add_split_return_callback(match_return_info);
+	add_split_return_callback(print_returned_struct_members);
+	add_hook(&call_return_state_hooks, RETURN_HOOK);
+	add_hook(&match_end_func_info, END_FUNC_HOOK);
+	add_hook(&match_after_func, AFTER_FUNC_HOOK);
+
+	add_hook(&match_data_from_db, FUNC_DEF_HOOK);
+	add_hook(&match_call_implies, FUNC_DEF_HOOK);
+	add_hook(&match_return_implies, CALL_HOOK_AFTER_INLINE);
+
+	register_common_funcs();
+	register_return_replacements();
+
+	add_hook(&dump_cache, END_FILE_HOOK);
+}
+
+void register_db_call_marker(int id)
+{
+	add_hook(&match_call_marker, FUNCTION_CALL_HOOK);
+}
+
+char *return_state_to_var_sym(struct expression *expr, int param, const char *key, struct symbol **sym)
+{
+	struct expression *arg;
+	char *name = NULL;
+	char member_name[256];
+
+	*sym = NULL;
+
+	if (param == -1) {
+		const char *star = "";
+
+		if (expr->type != EXPR_ASSIGNMENT)
+			return NULL;
+		name = expr_to_var_sym(expr->left, sym);
+		if (!name)
+			return NULL;
+		if (key[0] == '*') {
+			star = "*";
+			key++;
+		}
+		if (strncmp(key, "$", 1) != 0)
+			return name;
+		snprintf(member_name, sizeof(member_name), "%s%s%s", star, name, key + 1);
+		free_string(name);
+		return alloc_string(member_name);
+	}
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return NULL;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return NULL;
+
+	return get_variable_from_key(arg, key, sym);
+}
+
+char *get_variable_from_key(struct expression *arg, const char *key, struct symbol **sym)
+{
+	char buf[256];
+	char *tmp;
+
+	if (!arg)
+		return NULL;
+
+	arg = strip_expr(arg);
+
+	if (strcmp(key, "$") == 0)
+		return expr_to_var_sym(arg, sym);
+
+	if (strcmp(key, "*$") == 0) {
+		if (arg->type == EXPR_PREOP && arg->op == '&') {
+			arg = strip_expr(arg->unop);
+			return expr_to_var_sym(arg, sym);
+		} else {
+			tmp = expr_to_var_sym(arg, sym);
+			if (!tmp)
+				return NULL;
+			snprintf(buf, sizeof(buf), "*%s", tmp);
+			free_string(tmp);
+			return alloc_string(buf);
+		}
+	}
+
+	if (arg->type == EXPR_PREOP && arg->op == '&') {
+		arg = strip_expr(arg->unop);
+		tmp = expr_to_var_sym(arg, sym);
+		if (!tmp)
+			return NULL;
+		snprintf(buf, sizeof(buf), "%s.%s", tmp, key + 3);
+		return alloc_string(buf);
+	}
+
+	tmp = expr_to_var_sym(arg, sym);
+	if (!tmp)
+		return NULL;
+	snprintf(buf, sizeof(buf), "%s%s", tmp, key + 1);
+	free_string(tmp);
+	return alloc_string(buf);
+}
+
+char *get_chunk_from_key(struct expression *arg, char *key, struct symbol **sym, struct var_sym_list **vsl)
+{
+	*vsl = NULL;
+
+	if (strcmp("$", key) == 0)
+		return expr_to_chunk_sym_vsl(arg, sym, vsl);
+	return get_variable_from_key(arg, key, sym);
+}
+
+const char *state_name_to_param_name(const char *state_name, const char *param_name)
+{
+	int name_len;
+	static char buf[256];
+
+	name_len = strlen(param_name);
+
+	if (strcmp(state_name, param_name) == 0) {
+		return "$";
+	} else if (state_name[name_len] == '-' && /* check for '-' from "->" */
+	    strncmp(state_name, param_name, name_len) == 0) {
+		snprintf(buf, sizeof(buf), "$%s", state_name + name_len);
+		return buf;
+	} else if (state_name[0] == '*' && strcmp(state_name + 1, param_name) == 0) {
+		return "*$";
+	}
+	return NULL;
+}
+
+const char *get_param_name_var_sym(const char *name, struct symbol *sym)
+{
+	if (!sym || !sym->ident)
+		return NULL;
+
+	return state_name_to_param_name(name, sym->ident->name);
+}
+
+const char *get_mtag_name_var_sym(const char *state_name, struct symbol *sym)
+{
+	struct symbol *type;
+	const char *sym_name;
+	int name_len;
+	static char buf[256];
+
+	/*
+	 * mtag_name is different from param_name because mtags can be a struct
+	 * instead of a struct pointer.  But we want to treat it like a pointer
+	 * because really an mtag is a pointer.  Or in other words, if you pass
+	 * a struct foo then you want to talk about foo.bar but with an mtag
+	 * you want to refer to it as foo->bar.
+	 *
+	 */
+
+	if (!sym || !sym->ident)
+		return NULL;
+
+	type = get_real_base_type(sym);
+	if (type && type->type == SYM_BASETYPE)
+		return "*$";
+
+	sym_name = sym->ident->name;
+	name_len = strlen(sym_name);
+
+	if (state_name[name_len] == '.' && /* check for '-' from "->" */
+	    strncmp(state_name, sym_name, name_len) == 0) {
+		snprintf(buf, sizeof(buf), "$->%s", state_name + name_len + 1);
+		return buf;
+	}
+
+	return state_name_to_param_name(state_name, sym_name);
+}
+
+const char *get_mtag_name_expr(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	const char *ret = NULL;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+
+	ret = get_mtag_name_var_sym(name, sym);
+free:
+	free_string(name);
+	return ret;
+}
+
+const char *get_param_name(struct sm_state *sm)
+{
+	return get_param_name_var_sym(sm->name, sm->sym);
+}
+
+char *get_data_info_name(struct expression *expr)
+{
+	struct symbol *sym;
+	char *name;
+	char buf[256];
+	char *ret = NULL;
+
+	expr = strip_expr(expr);
+	name = get_member_name(expr);
+	if (name)
+		return name;
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	if (!(sym->ctype.modifiers & MOD_TOPLEVEL))
+		goto free;
+	if (sym->ctype.modifiers & MOD_STATIC)
+		snprintf(buf, sizeof(buf), "static %s", name);
+	else
+		snprintf(buf, sizeof(buf), "global %s", name);
+	ret = alloc_sname(buf);
+free:
+	free_string(name);
+	return ret;
+}
diff --git a/usr/src/tools/smatch/src/smatch_equiv.c b/usr/src/tools/smatch/src/smatch_equiv.c
new file mode 100644
index 0000000000..e00b6f2a6a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_equiv.c
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * smatch_equiv.c is for tracking how variables are the same
+ *
+ * if (a == b) {
+ * Or
+ * x = y;
+ *
+ * When a variable gets modified all the old relationships are
+ * deleted.  remove_equiv(expr);
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+ALLOCATOR(relation, "related variables");
+
+static struct relation *alloc_relation(const char *name, struct symbol *sym)
+{
+	struct relation *tmp;
+
+	tmp = __alloc_relation(0);
+	tmp->name = alloc_string(name);
+	tmp->sym = sym;
+	return tmp;
+}
+
+struct related_list *clone_related_list(struct related_list *related)
+{
+	struct relation *rel;
+	struct related_list *to_list = NULL;
+
+	FOR_EACH_PTR(related, rel) {
+		add_ptr_list(&to_list, rel);
+	} END_FOR_EACH_PTR(rel);
+
+	return to_list;
+}
+
+static int cmp_relation(struct relation *a, struct relation *b)
+{
+	int ret;
+
+	if (a == b)
+		return 0;
+
+	if (a->sym > b->sym)
+		return -1;
+	if (a->sym < b->sym)
+		return 1;
+
+	ret = strcmp(a->name, b->name);
+	if (ret)
+		return ret;
+
+	return 0;
+}
+
+struct related_list *get_shared_relations(struct related_list *one,
+					      struct related_list *two)
+{
+	struct related_list *ret = NULL;
+	struct relation *one_rel;
+	struct relation *two_rel;
+
+	PREPARE_PTR_LIST(one, one_rel);
+	PREPARE_PTR_LIST(two, two_rel);
+	for (;;) {
+		if (!one_rel || !two_rel)
+			break;
+		if (cmp_relation(one_rel, two_rel) < 0) {
+			NEXT_PTR_LIST(one_rel);
+		} else if (cmp_relation(one_rel, two_rel) == 0) {
+			add_ptr_list(&ret, one_rel);
+			NEXT_PTR_LIST(one_rel);
+			NEXT_PTR_LIST(two_rel);
+		} else {
+			NEXT_PTR_LIST(two_rel);
+		}
+	}
+	FINISH_PTR_LIST(two_rel);
+	FINISH_PTR_LIST(one_rel);
+
+	return ret;
+}
+
+static void debug_addition(struct related_list *rlist, const char *name)
+{
+	struct relation *tmp;
+
+	if (!option_debug_related)
+		return;
+
+	sm_prefix();
+	sm_printf("(");
+	FOR_EACH_PTR(rlist, tmp) {
+		sm_printf("%s ", tmp->name);
+	} END_FOR_EACH_PTR(tmp);
+	sm_printf(") <-- %s\n", name);
+}
+
+static void add_related(struct related_list **rlist, const char *name, struct symbol *sym)
+{
+	struct relation *rel;
+	struct relation *new;
+	struct relation tmp = {
+		.name = (char *)name,
+		.sym = sym
+	};
+
+	debug_addition(*rlist, name);
+
+	FOR_EACH_PTR(*rlist, rel) {
+		if (cmp_relation(rel, &tmp) < 0)
+			continue;
+		if (cmp_relation(rel, &tmp) == 0)
+			return;
+		new = alloc_relation(name, sym);
+		INSERT_CURRENT(new, rel);
+		return;
+	} END_FOR_EACH_PTR(rel);
+	new = alloc_relation(name, sym);
+	add_ptr_list(rlist, new);
+}
+
+static struct related_list *del_related(struct smatch_state *state, const char *name, struct symbol *sym)
+{
+	struct relation *tmp;
+	struct relation remove = {
+		.name = (char *)name,
+		.sym = sym,
+	};
+	struct related_list *ret = NULL;
+
+	FOR_EACH_PTR(estate_related(state), tmp) {
+		if (cmp_relation(tmp, &remove) != 0)
+			add_ptr_list(&ret, tmp);
+	} END_FOR_EACH_PTR(tmp);
+
+	return ret;
+}
+
+void remove_from_equiv(const char *name, struct symbol *sym)
+{
+	struct sm_state *orig_sm;
+	struct relation *rel;
+	struct smatch_state *state;
+	struct related_list *to_update;
+
+	orig_sm = get_sm_state(SMATCH_EXTRA, name, sym);
+	if (!orig_sm || !get_dinfo(orig_sm->state)->related)
+		return;
+
+	state = clone_estate(orig_sm->state);
+	to_update = del_related(state, name, sym);
+
+	FOR_EACH_PTR(to_update, rel) {
+		struct sm_state *old_sm, *new_sm;
+
+		old_sm = get_sm_state(SMATCH_EXTRA, rel->name, rel->sym);
+		if (!old_sm)
+			continue;
+
+		new_sm = clone_sm(old_sm);
+		get_dinfo(new_sm->state)->related = to_update;
+		__set_sm(new_sm);
+	} END_FOR_EACH_PTR(rel);
+}
+
+void remove_from_equiv_expr(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	remove_from_equiv(name, sym);
+free:
+	free_string(name);
+}
+
+void set_related(struct smatch_state *estate, struct related_list *rlist)
+{
+	if (!estate_related(estate) && !rlist)
+		return;
+	get_dinfo(estate)->related = rlist;
+}
+
+/*
+ * set_equiv() is only used for assignments where we set one variable
+ * equal to the other.  a = b;.  It's not used for if conditions where
+ * a == b.
+ */
+void set_equiv(struct expression *left, struct expression *right)
+{
+	struct sm_state *right_sm, *left_sm;
+	struct relation *rel;
+	char *left_name;
+	struct symbol *left_sym;
+	struct related_list *rlist;
+
+	left_name = expr_to_var_sym(left, &left_sym);
+	if (!left_name || !left_sym)
+		goto free;
+
+	right_sm = get_sm_state_expr(SMATCH_EXTRA, right);
+	if (!right_sm)
+		right_sm = set_state_expr(SMATCH_EXTRA, right, alloc_estate_whole(get_type(right)));
+	if (!right_sm)
+		goto free;
+
+	/* This block is because we want to preserve the implications. */
+	left_sm = clone_sm(right_sm);
+	left_sm->name = alloc_string(left_name);
+	left_sm->sym = left_sym;
+	left_sm->state = clone_estate_cast(get_type(left), right_sm->state);
+	set_extra_mod_helper(left_name, left_sym, left, left_sm->state);
+	__set_sm(left_sm);
+
+	rlist = clone_related_list(estate_related(right_sm->state));
+	add_related(&rlist, right_sm->name, right_sm->sym);
+	add_related(&rlist, left_name, left_sym);
+
+	FOR_EACH_PTR(rlist, rel) {
+		struct sm_state *old_sm, *new_sm;
+
+		old_sm = get_sm_state(SMATCH_EXTRA, rel->name, rel->sym);
+		if (!old_sm)  /* shouldn't happen */
+			continue;
+		new_sm = clone_sm(old_sm);
+		new_sm->state = clone_estate(old_sm->state);
+		get_dinfo(new_sm->state)->related = rlist;
+		__set_sm(new_sm);
+	} END_FOR_EACH_PTR(rel);
+free:
+	free_string(left_name);
+}
+
+void set_equiv_state_expr(int id, struct expression *expr, struct smatch_state *state)
+{
+	struct relation *rel;
+	struct smatch_state *estate;
+
+	estate = get_state_expr(SMATCH_EXTRA, expr);
+
+	if (!estate)
+		return;
+
+	FOR_EACH_PTR(get_dinfo(estate)->related, rel) {
+		set_state(id, rel->name, rel->sym, state);
+	} END_FOR_EACH_PTR(rel);
+}
diff --git a/usr/src/tools/smatch/src/smatch_estate.c b/usr/src/tools/smatch/src/smatch_estate.c
new file mode 100644
index 0000000000..61a8fd347a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_estate.c
@@ -0,0 +1,418 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * smatch_dinfo.c has helper functions for handling data_info structs
+ *
+ */
+
+#include <stdlib.h>
+#ifndef __USE_ISOC99
+#define __USE_ISOC99
+#endif
+#include <limits.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+struct smatch_state *merge_estates(struct smatch_state *s1, struct smatch_state *s2)
+{
+	struct smatch_state *tmp;
+	struct range_list *value_ranges;
+	struct related_list *rlist;
+
+	if (estates_equiv(s1, s2))
+		return s1;
+
+	value_ranges = rl_union(estate_rl(s1), estate_rl(s2));
+	tmp = alloc_estate_rl(value_ranges);
+	rlist = get_shared_relations(estate_related(s1), estate_related(s2));
+	set_related(tmp, rlist);
+	if (estate_has_hard_max(s1) && estate_has_hard_max(s2))
+		estate_set_hard_max(tmp);
+
+	estate_set_fuzzy_max(tmp, sval_max(estate_get_fuzzy_max(s1), estate_get_fuzzy_max(s2)));
+
+	return tmp;
+}
+
+struct data_info *get_dinfo(struct smatch_state *state)
+{
+	if (!state)
+		return NULL;
+	return (struct data_info *)state->data;
+}
+
+struct range_list *estate_rl(struct smatch_state *state)
+{
+	if (!state)
+		return NULL;
+	return get_dinfo(state)->value_ranges;
+}
+
+struct related_list *estate_related(struct smatch_state *state)
+{
+	if (!state)
+		return NULL;
+	return get_dinfo(state)->related;
+}
+
+sval_t estate_get_fuzzy_max(struct smatch_state *state)
+{
+	sval_t empty = {};
+
+	if (!state || !get_dinfo(state))
+		return empty;
+	return get_dinfo(state)->fuzzy_max;
+}
+
+int estate_has_fuzzy_max(struct smatch_state *state)
+{
+	if (estate_get_fuzzy_max(state).type)
+		return 1;
+	return 0;
+}
+
+void estate_set_fuzzy_max(struct smatch_state *state, sval_t fuzzy_max)
+{
+	if (!rl_has_sval(estate_rl(state), fuzzy_max))
+		return;
+	get_dinfo(state)->fuzzy_max = fuzzy_max;
+}
+
+void estate_copy_fuzzy_max(struct smatch_state *new, struct smatch_state *old)
+{
+	if (!estate_has_fuzzy_max(old))
+		return;
+	estate_set_fuzzy_max(new, estate_get_fuzzy_max(old));
+}
+
+void estate_clear_fuzzy_max(struct smatch_state *state)
+{
+	sval_t empty = {};
+
+	get_dinfo(state)->fuzzy_max = empty;
+}
+
+int estate_has_hard_max(struct smatch_state *state)
+{
+	if (!state)
+		return 0;
+	return get_dinfo(state)->hard_max;
+}
+
+void estate_set_hard_max(struct smatch_state *state)
+{
+	get_dinfo(state)->hard_max = 1;
+}
+
+void estate_clear_hard_max(struct smatch_state *state)
+{
+	get_dinfo(state)->hard_max = 0;
+}
+
+int estate_get_hard_max(struct smatch_state *state, sval_t *sval)
+{
+	if (!state || !get_dinfo(state)->hard_max || !estate_rl(state))
+		return 0;
+	*sval = rl_max(estate_rl(state));
+	return 1;
+}
+
+sval_t estate_min(struct smatch_state *state)
+{
+	return rl_min(estate_rl(state));
+}
+
+sval_t estate_max(struct smatch_state *state)
+{
+	return rl_max(estate_rl(state));
+}
+
+struct symbol *estate_type(struct smatch_state *state)
+{
+	return rl_max(estate_rl(state)).type;
+}
+
+static int rlists_equiv(struct related_list *one, struct related_list *two)
+{
+	struct relation *one_rel;
+	struct relation *two_rel;
+
+	PREPARE_PTR_LIST(one, one_rel);
+	PREPARE_PTR_LIST(two, two_rel);
+	for (;;) {
+		if (!one_rel && !two_rel)
+			return 1;
+		if (!one_rel || !two_rel)
+			return 0;
+		if (one_rel->sym != two_rel->sym)
+			return 0;
+		if (strcmp(one_rel->name, two_rel->name))
+			return 0;
+		NEXT_PTR_LIST(one_rel);
+		NEXT_PTR_LIST(two_rel);
+	}
+	FINISH_PTR_LIST(two_rel);
+	FINISH_PTR_LIST(one_rel);
+
+	return 1;
+}
+
+int estates_equiv(struct smatch_state *one, struct smatch_state *two)
+{
+	if (!one || !two)
+		return 0;
+	if (one == two)
+		return 1;
+	if (!rlists_equiv(estate_related(one), estate_related(two)))
+		return 0;
+	if (strcmp(one->name, two->name) == 0)
+		return 1;
+	return 0;
+}
+
+int estate_is_whole(struct smatch_state *state)
+{
+	return is_whole_rl(estate_rl(state));
+}
+
+int estate_is_empty(struct smatch_state *state)
+{
+	return state && !estate_rl(state);
+}
+
+int estate_is_unknown(struct smatch_state *state)
+{
+	if (!estate_is_whole(state))
+		return 0;
+	if (estate_related(state))
+		return 0;
+	if (estate_has_fuzzy_max(state))
+		return 0;
+	return 1;
+}
+
+int estate_get_single_value(struct smatch_state *state, sval_t *sval)
+{
+	sval_t min, max;
+
+	min = rl_min(estate_rl(state));
+	max = rl_max(estate_rl(state));
+	if (sval_cmp(min, max) != 0)
+		return 0;
+	*sval = min;
+	return 1;
+}
+
+static struct data_info *alloc_dinfo(void)
+{
+	struct data_info *ret;
+
+	ret = __alloc_data_info(0);
+	memset(ret, 0, sizeof(*ret));
+	return ret;
+}
+
+static struct data_info *alloc_dinfo_range(sval_t min, sval_t max)
+{
+	struct data_info *ret;
+
+	ret = alloc_dinfo();
+	add_range(&ret->value_ranges, min, max);
+	return ret;
+}
+
+static struct data_info *alloc_dinfo_range_list(struct range_list *rl)
+{
+	struct data_info *ret;
+
+	ret = alloc_dinfo();
+	ret->value_ranges = rl;
+	return ret;
+}
+
+static struct data_info *clone_dinfo(struct data_info *dinfo)
+{
+	struct data_info *ret;
+
+	ret = alloc_dinfo();
+	ret->related = clone_related_list(dinfo->related);
+	ret->value_ranges = clone_rl(dinfo->value_ranges);
+	ret->hard_max = dinfo->hard_max;
+	ret->fuzzy_max = dinfo->fuzzy_max;
+	return ret;
+}
+
+struct smatch_state *clone_estate(struct smatch_state *state)
+{
+	struct smatch_state *ret;
+
+	if (!state)
+		return NULL;
+
+	ret = __alloc_smatch_state(0);
+	ret->name = state->name;
+	ret->data = clone_dinfo(get_dinfo(state));
+	return ret;
+}
+
+struct smatch_state *alloc_estate_empty(void)
+{
+	struct smatch_state *state;
+	struct data_info *dinfo;
+
+	dinfo = alloc_dinfo();
+	state = __alloc_smatch_state(0);
+	state->data = dinfo;
+	state->name = "";
+	return state;
+}
+
+struct smatch_state *alloc_estate_whole(struct symbol *type)
+{
+	return alloc_estate_rl(alloc_whole_rl(type));
+}
+
+struct smatch_state *extra_empty(void)
+{
+	struct smatch_state *ret;
+
+	ret = __alloc_smatch_state(0);
+	ret->name = "empty";
+	ret->data = alloc_dinfo();
+	return ret;
+}
+
+struct smatch_state *alloc_estate_sval(sval_t sval)
+{
+	struct smatch_state *state;
+
+	state = __alloc_smatch_state(0);
+	state->data = alloc_dinfo_range(sval, sval);
+	state->name = show_rl(get_dinfo(state)->value_ranges);
+	estate_set_hard_max(state);
+	estate_set_fuzzy_max(state, sval);
+	return state;
+}
+
+struct smatch_state *alloc_estate_range(sval_t min, sval_t max)
+{
+	struct smatch_state *state;
+
+	state = __alloc_smatch_state(0);
+	state->data = alloc_dinfo_range(min, max);
+	state->name = show_rl(get_dinfo(state)->value_ranges);
+	return state;
+}
+
+struct smatch_state *alloc_estate_rl(struct range_list *rl)
+{
+	struct smatch_state *state;
+
+	if (!rl)
+		return extra_empty();
+
+	state = __alloc_smatch_state(0);
+	state->data = alloc_dinfo_range_list(rl);
+	state->name = show_rl(rl);
+	return state;
+}
+
+struct smatch_state *clone_estate_cast(struct symbol *type, struct smatch_state *state)
+{
+	struct smatch_state *ret;
+	struct data_info *dinfo;
+
+	if (!state)
+		return NULL;
+
+	dinfo = alloc_dinfo();
+	dinfo->value_ranges = clone_rl(cast_rl(type, estate_rl(state)));
+
+	ret = __alloc_smatch_state(0);
+	ret->name = show_rl(dinfo->value_ranges);
+	ret->data = dinfo;
+
+	return ret;
+}
+
+struct smatch_state *get_implied_estate(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct range_list *rl;
+
+	state = get_state_expr(SMATCH_EXTRA, expr);
+	if (state)
+		return state;
+	if (!get_implied_rl(expr, &rl))
+		rl = alloc_whole_rl(get_type(expr));
+	return alloc_estate_rl(rl);
+}
+
+struct smatch_state *estate_filter_range(struct smatch_state *orig,
+				 sval_t filter_min, sval_t filter_max)
+{
+	struct range_list *rl;
+	struct smatch_state *state;
+
+	if (!orig)
+		orig = alloc_estate_whole(filter_min.type);
+
+	rl = remove_range(estate_rl(orig), filter_min, filter_max);
+	state = alloc_estate_rl(rl);
+	if (estate_has_hard_max(orig))
+		estate_set_hard_max(state);
+	if (estate_has_fuzzy_max(orig))
+		estate_set_fuzzy_max(state, estate_get_fuzzy_max(orig));
+	return state;
+}
+
+struct smatch_state *estate_filter_sval(struct smatch_state *orig, sval_t sval)
+{
+	return estate_filter_range(orig, sval, sval);
+}
+
+/*
+ * One of the complications is that smatch tries to free a bunch of data at the
+ * end of every function.
+ */
+struct data_info *clone_dinfo_perm(struct data_info *dinfo)
+{
+	struct data_info *ret;
+
+	ret = malloc(sizeof(*ret));
+	memset(ret, 0, sizeof(*ret));
+	ret->related = NULL;
+	ret->value_ranges = clone_rl_permanent(dinfo->value_ranges);
+	ret->hard_max = 0;
+	ret->fuzzy_max = dinfo->fuzzy_max;
+	return ret;
+}
+
+struct smatch_state *clone_estate_perm(struct smatch_state *state)
+{
+	struct smatch_state *ret;
+
+	ret = malloc(sizeof(*ret));
+	ret->name = alloc_string(state->name);
+	ret->data = clone_dinfo_perm(get_dinfo(state));
+	return ret;
+}
+
+
diff --git a/usr/src/tools/smatch/src/smatch_expression_stacks.c b/usr/src/tools/smatch/src/smatch_expression_stacks.c
new file mode 100644
index 0000000000..0b01b658e1
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_expression_stacks.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_expression_stacks.h"
+
+void push_expression(struct expression_list **estack, struct expression *expr)
+{
+	add_ptr_list(estack, expr);
+}
+
+struct expression *pop_expression(struct expression_list **estack)
+{
+	struct expression *expr;
+
+	expr = last_ptr_list((struct ptr_list *)*estack);
+	delete_ptr_list_last((struct ptr_list **)estack);
+	return expr;
+}
+
+struct expression *top_expression(struct expression_list *estack)
+{
+	struct expression *expr;
+
+	expr = last_ptr_list((struct ptr_list *)estack);
+	return expr;
+}
+
+void free_expression_stack(struct expression_list **estack)
+{
+	__free_ptr_list((struct ptr_list **)estack);
+}
diff --git a/usr/src/tools/smatch/src/smatch_expression_stacks.h b/usr/src/tools/smatch/src/smatch_expression_stacks.h
new file mode 100644
index 0000000000..1f26476a88
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_expression_stacks.h
@@ -0,0 +1,4 @@
+void push_expression(struct expression_list **estack, struct expression *expr);
+struct expression *pop_expression(struct expression_list **estack);
+struct expression *top_expression(struct expression_list *estack);
+void free_expression_stack(struct expression_list **estack);
diff --git a/usr/src/tools/smatch/src/smatch_expressions.c b/usr/src/tools/smatch/src/smatch_expressions.c
new file mode 100644
index 0000000000..9900342b89
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_expressions.c
@@ -0,0 +1,241 @@
+#include "smatch.h"
+#include "smatch_extra.h"
+
+DECLARE_ALLOCATOR(sname);
+__ALLOCATOR(struct expression, "temporary expr", tmp_expression);
+
+static struct position get_cur_pos(void)
+{
+	static struct position pos;
+	static struct position none;
+	struct expression *expr;
+	struct statement *stmt;
+
+	expr = last_ptr_list((struct ptr_list *)big_expression_stack);
+	stmt = last_ptr_list((struct ptr_list *)big_statement_stack);
+	if (expr)
+		pos = expr->pos;
+	else if (stmt)
+		pos = stmt->pos;
+	else
+		pos = none;
+	return pos;
+}
+
+struct expression *alloc_tmp_expression(struct position pos, int type)
+{
+	struct expression *expr;
+
+	expr = __alloc_tmp_expression(0);
+	expr->smatch_flags |= Fake;
+	expr->type = type;
+	expr->pos = pos;
+	return expr;
+}
+
+void free_tmp_expressions(void)
+{
+	clear_tmp_expression_alloc();
+}
+
+struct expression *zero_expr(void)
+{
+	struct expression *zero;
+
+	zero = alloc_tmp_expression(get_cur_pos(), EXPR_VALUE);
+	zero->value = 0;
+	zero->ctype = &int_ctype;
+	return zero;
+}
+
+struct expression *value_expr(long long val)
+{
+	struct expression *expr;
+
+	if (!val)
+		return zero_expr();
+
+	expr = alloc_tmp_expression(get_cur_pos(), EXPR_VALUE);
+	expr->value = val;
+	expr->ctype = &llong_ctype;
+	return expr;
+}
+
+struct expression *member_expression(struct expression *deref, int op, struct ident *member)
+{
+	struct expression *expr;
+
+	expr = alloc_tmp_expression(deref->pos, EXPR_DEREF);
+	expr->op = op;
+	expr->deref = deref;
+	expr->member = member;
+	expr->member_offset = -1;
+	return expr;
+}
+
+struct expression *preop_expression(struct expression *expr, int op)
+{
+	struct expression *preop;
+
+	preop = alloc_tmp_expression(expr->pos, EXPR_PREOP);
+	preop->unop = expr;
+	preop->op = op;
+	return preop;
+}
+
+struct expression *deref_expression(struct expression *expr)
+{
+	return preop_expression(expr, '*');
+}
+
+struct expression *assign_expression(struct expression *left, int op, struct expression *right)
+{
+	struct expression *expr;
+
+	if (!right)
+		return NULL;
+
+	/* FIXME: make this a tmp expression. */
+	expr = alloc_expression(right->pos, EXPR_ASSIGNMENT);
+	expr->op = op;
+	expr->left = left;
+	expr->right = right;
+	return expr;
+}
+
+struct expression *binop_expression(struct expression *left, int op, struct expression *right)
+{
+	struct expression *expr;
+
+	expr = alloc_tmp_expression(right->pos, EXPR_BINOP);
+	expr->op = op;
+	expr->left = left;
+	expr->right = right;
+	return expr;
+}
+
+struct expression *array_element_expression(struct expression *array, struct expression *offset)
+{
+	struct expression *expr;
+
+	expr = binop_expression(array, '+', offset);
+	return deref_expression(expr);
+}
+
+struct expression *symbol_expression(struct symbol *sym)
+{
+	struct expression *expr;
+
+	expr = alloc_tmp_expression(sym->pos, EXPR_SYMBOL);
+	expr->symbol = sym;
+	expr->symbol_name = sym->ident;
+	return expr;
+}
+
+struct expression *compare_expression(struct expression *left, int op, struct expression *right)
+{
+	struct expression *expr;
+
+	expr = alloc_tmp_expression(get_cur_pos(), EXPR_COMPARE);
+	expr->op = op;
+	expr->left = left;
+	expr->right = right;
+	return expr;
+}
+
+struct expression *string_expression(char *str)
+{
+	struct expression *ret;
+	struct string *string;
+	int len;
+
+	len = strlen(str) + 1;
+	string = (void *)__alloc_sname(4 + len);
+	string->length = len;
+	string->immutable = 0;
+	memcpy(string->data, str, len);
+
+	ret = alloc_tmp_expression(get_cur_pos(), EXPR_STRING);
+	ret->wide = 0;
+	ret->string = string;
+
+	return ret;
+}
+
+struct expression *gen_expression_from_key(struct expression *arg, const char *key)
+{
+	struct expression *ret;
+	struct token *token, *end;
+	const char *p = key;
+	char buf[4095];
+	char *alloc;
+	size_t len;
+
+	/* The idea is that we can parse either $0->foo or $->foo */
+	if (key[0] != '$')
+		return NULL;
+	p++;
+	while (*p >= '0' && *p <= '9')
+		p++;
+	len = snprintf(buf, sizeof(buf), "%s\n", p);
+	alloc = alloc_string(buf);
+
+	token = tokenize_buffer(alloc, len, &end);
+	if (!token)
+		return NULL;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return NULL;
+	token = token->next;
+
+	ret = arg;
+	while (token_type(token) == TOKEN_SPECIAL &&
+	       token->special == SPECIAL_DEREFERENCE) {
+		token = token->next;
+		if (token_type(token) != TOKEN_IDENT)
+			return NULL;
+		ret = deref_expression(ret);
+		ret = member_expression(ret, '*', token->ident);
+		token = token->next;
+	}
+
+	if (token_type(token) != TOKEN_STREAMEND)
+		return NULL;
+
+	return ret;
+}
+
+void expr_set_parent_expr(struct expression *expr, struct expression *parent)
+{
+	if (!expr)
+		return;
+	if (parent->smatch_flags & Fake)
+		return;
+
+	expr->parent = (unsigned long)parent | 0x1UL;
+}
+
+void expr_set_parent_stmt(struct expression *expr, struct statement *parent)
+{
+	if (!expr)
+		return;
+	expr->parent = (unsigned long)parent;
+}
+
+struct expression *expr_get_parent_expr(struct expression *expr)
+{
+	if (!expr)
+		return NULL;
+	if (!(expr->parent & 0x1UL))
+		return NULL;
+	return (struct expression *)(expr->parent & ~0x1UL);
+}
+
+struct statement *expr_get_parent_stmt(struct expression *expr)
+{
+	if (!expr)
+		return NULL;
+	if (expr->parent & 0x1UL)
+		return NULL;
+	return (struct statement *)expr->parent;
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_extra.c b/usr/src/tools/smatch/src/smatch_extra.c
new file mode 100644
index 0000000000..0633cffc6d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_extra.c
@@ -0,0 +1,2686 @@
+/*
+ * Copyright (C) 2008 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * smatch_extra.c is supposed to track the value of every variable.
+ *
+ */
+
+#define _GNU_SOURCE
+#include <string.h>
+
+#include <stdlib.h>
+#include <errno.h>
+#ifndef __USE_ISOC99
+#define __USE_ISOC99
+#endif
+#include <limits.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+static int link_id;
+
+static void match_link_modify(struct sm_state *sm, struct expression *mod_expr);
+
+struct string_list *__ignored_macros = NULL;
+static int in_warn_on_macro(void)
+{
+	struct statement *stmt;
+	char *tmp;
+	char *macro;
+
+	stmt = get_current_statement();
+	if (!stmt)
+		return 0;
+	macro = get_macro_name(stmt->pos);
+	if (!macro)
+		return 0;
+
+	FOR_EACH_PTR(__ignored_macros, tmp) {
+		if (!strcmp(tmp, macro))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+typedef void (mod_hook)(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state);
+DECLARE_PTR_LIST(void_fn_list, mod_hook *);
+static struct void_fn_list *extra_mod_hooks;
+static struct void_fn_list *extra_nomod_hooks;
+
+void add_extra_mod_hook(mod_hook *fn)
+{
+	mod_hook **p = malloc(sizeof(mod_hook *));
+	*p = fn;
+	add_ptr_list(&extra_mod_hooks, p);
+}
+
+void add_extra_nomod_hook(mod_hook *fn)
+{
+	mod_hook **p = malloc(sizeof(mod_hook *));
+	*p = fn;
+	add_ptr_list(&extra_nomod_hooks, p);
+}
+
+void call_extra_hooks(struct void_fn_list *hooks, const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	mod_hook **fn;
+
+	FOR_EACH_PTR(hooks, fn) {
+		(*fn)(name, sym, expr, state);
+	} END_FOR_EACH_PTR(fn);
+}
+
+void call_extra_mod_hooks(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	call_extra_hooks(extra_mod_hooks, name, sym, expr, state);
+}
+
+void call_extra_nomod_hooks(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	call_extra_hooks(extra_nomod_hooks, name, sym, expr, state);
+}
+
+static bool in_param_set;
+void set_extra_mod_helper(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	remove_from_equiv(name, sym);
+	call_extra_mod_hooks(name, sym, expr, state);
+	if ((__in_fake_assign || in_param_set) &&
+	    estate_is_unknown(state) && !get_state(SMATCH_EXTRA, name, sym))
+		return;
+	set_state(SMATCH_EXTRA, name, sym, state);
+}
+
+static void set_extra_nomod_helper(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	call_extra_nomod_hooks(name, sym, expr, state);
+	set_state(SMATCH_EXTRA, name, sym, state);
+}
+
+static char *get_pointed_at(const char *name, struct symbol *sym, struct symbol **new_sym)
+{
+	struct expression *assigned;
+
+	if (name[0] != '*')
+		return NULL;
+	if (strcmp(name + 1, sym->ident->name) != 0)
+		return NULL;
+
+	assigned = get_assigned_expr_name_sym(sym->ident->name, sym);
+	if (!assigned)
+		return NULL;
+	assigned = strip_parens(assigned);
+	if (assigned->type != EXPR_PREOP || assigned->op != '&')
+		return NULL;
+
+	return expr_to_var_sym(assigned->unop, new_sym);
+}
+
+char *get_other_name_sym(const char *name, struct symbol *sym, struct symbol **new_sym)
+{
+	struct expression *assigned;
+	char *orig_name = NULL;
+	char buf[256];
+	char *ret = NULL;
+	int skip;
+
+	*new_sym = NULL;
+
+	if (!sym || !sym->ident)
+		return NULL;
+
+	ret = get_pointed_at(name, sym, new_sym);
+	if (ret)
+		return ret;
+
+	skip = strlen(sym->ident->name);
+	if (name[skip] != '-' || name[skip + 1] != '>')
+		return NULL;
+	skip += 2;
+
+	assigned = get_assigned_expr_name_sym(sym->ident->name, sym);
+	if (!assigned)
+		return NULL;
+	if (assigned->type == EXPR_CALL)
+		return map_call_to_other_name_sym(name, sym, new_sym);
+	if (assigned->type == EXPR_PREOP || assigned->op == '&') {
+
+		orig_name = expr_to_var_sym(assigned, new_sym);
+		if (!orig_name || !*new_sym)
+			goto free;
+
+		snprintf(buf, sizeof(buf), "%s.%s", orig_name + 1, name + skip);
+		ret = alloc_string(buf);
+		free_string(orig_name);
+		return ret;
+	}
+
+	if (assigned->type != EXPR_DEREF)
+		goto free;
+
+	orig_name = expr_to_var_sym(assigned, new_sym);
+	if (!orig_name || !*new_sym)
+		goto free;
+
+	snprintf(buf, sizeof(buf), "%s->%s", orig_name, name + skip);
+	ret = alloc_string(buf);
+	free_string(orig_name);
+	return ret;
+
+free:
+	free_string(orig_name);
+	return NULL;
+}
+
+void set_extra_mod(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	char *new_name;
+	struct symbol *new_sym;
+
+	set_extra_mod_helper(name, sym, expr, state);
+	new_name = get_other_name_sym(name, sym, &new_sym);
+	if (new_name && new_sym)
+		set_extra_mod_helper(new_name, new_sym, expr, state);
+	free_string(new_name);
+}
+
+static struct expression *chunk_get_array_base(struct expression *expr)
+{
+	/*
+	 * The problem with is_array() is that it only returns true for things
+	 * like foo[1] but not for foo[1].bar.
+	 *
+	 */
+	expr = strip_expr(expr);
+	while (expr && expr->type == EXPR_DEREF)
+		expr = strip_expr(expr->deref);
+	return get_array_base(expr);
+}
+
+static int chunk_has_array(struct expression *expr)
+{
+	return !!chunk_get_array_base(expr);
+}
+
+static void clear_array_states(struct expression *array)
+{
+	struct sm_state *sm;
+
+	sm = get_sm_state_expr(link_id, array);
+	if (sm)
+		match_link_modify(sm, NULL);
+}
+
+static void set_extra_array_mod(struct expression *expr, struct smatch_state *state)
+{
+	struct expression *array;
+	struct var_sym_list *vsl;
+	struct var_sym *vs;
+	char *name;
+	struct symbol *sym;
+
+	array = chunk_get_array_base(expr);
+
+	name = expr_to_chunk_sym_vsl(expr, &sym, &vsl);
+	if (!name || !vsl) {
+		clear_array_states(array);
+		goto free;
+	}
+
+	FOR_EACH_PTR(vsl, vs) {
+		store_link(link_id, vs->var, vs->sym, name, sym);
+	} END_FOR_EACH_PTR(vs);
+
+	call_extra_mod_hooks(name, sym, expr, state);
+	set_state(SMATCH_EXTRA, name, sym, state);
+free:
+	free_string(name);
+}
+
+void set_extra_expr_mod(struct expression *expr, struct smatch_state *state)
+{
+	struct symbol *sym;
+	char *name;
+
+	if (chunk_has_array(expr)) {
+		set_extra_array_mod(expr, state);
+		return;
+	}
+
+	expr = strip_expr(expr);
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	set_extra_mod(name, sym, expr, state);
+free:
+	free_string(name);
+}
+
+void set_extra_nomod(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	char *new_name;
+	struct symbol *new_sym;
+	struct relation *rel;
+	struct smatch_state *orig_state;
+
+	orig_state = get_state(SMATCH_EXTRA, name, sym);
+
+	/* don't save unknown states if leaving it blank is the same */
+	if (!orig_state && estate_is_unknown(state))
+		return;
+
+	new_name = get_other_name_sym(name, sym, &new_sym);
+	if (new_name && new_sym)
+		set_extra_nomod_helper(new_name, new_sym, expr, state);
+	free_string(new_name);
+
+	if (!estate_related(orig_state)) {
+		set_extra_nomod_helper(name, sym, expr, state);
+		return;
+	}
+
+	set_related(state, estate_related(orig_state));
+	FOR_EACH_PTR(estate_related(orig_state), rel) {
+		struct smatch_state *estate;
+
+		if (option_debug_related)
+			sm_msg("%s updating related %s to %s", name, rel->name, state->name);
+		estate = get_state(SMATCH_EXTRA, rel->name, rel->sym);
+		if (!estate)
+			continue;
+		set_extra_nomod_helper(rel->name, rel->sym, expr, clone_estate_cast(estate_type(estate), state));
+	} END_FOR_EACH_PTR(rel);
+}
+
+void set_extra_nomod_vsl(const char *name, struct symbol *sym, struct var_sym_list *vsl, struct expression *expr, struct smatch_state *state)
+{
+	struct var_sym *vs;
+
+	FOR_EACH_PTR(vsl, vs) {
+		store_link(link_id, vs->var, vs->sym, name, sym);
+	} END_FOR_EACH_PTR(vs);
+
+	set_extra_nomod(name, sym, expr, state);
+}
+
+/*
+ * This is for return_implies_state() hooks which modify a SMATCH_EXTRA state
+ */
+void set_extra_expr_nomod(struct expression *expr, struct smatch_state *state)
+{
+	struct var_sym_list *vsl;
+	struct var_sym *vs;
+	char *name;
+	struct symbol *sym;
+
+	name = expr_to_chunk_sym_vsl(expr, &sym, &vsl);
+	if (!name || !vsl)
+		goto free;
+	FOR_EACH_PTR(vsl, vs) {
+		store_link(link_id, vs->var, vs->sym, name, sym);
+	} END_FOR_EACH_PTR(vs);
+
+	set_extra_nomod(name, sym, expr, state);
+free:
+	free_string(name);
+}
+
+static void set_extra_true_false(const char *name, struct symbol *sym,
+			struct smatch_state *true_state,
+			struct smatch_state *false_state)
+{
+	char *new_name;
+	struct symbol *new_sym;
+	struct relation *rel;
+	struct smatch_state *orig_state;
+
+	if (!true_state && !false_state)
+		return;
+
+	if (in_warn_on_macro())
+		return;
+
+	new_name = get_other_name_sym(name, sym, &new_sym);
+	if (new_name && new_sym)
+		set_true_false_states(SMATCH_EXTRA, new_name, new_sym, true_state, false_state);
+	free_string(new_name);
+
+	orig_state = get_state(SMATCH_EXTRA, name, sym);
+
+	if (!estate_related(orig_state)) {
+		set_true_false_states(SMATCH_EXTRA, name, sym, true_state, false_state);
+		return;
+	}
+
+	if (true_state)
+		set_related(true_state, estate_related(orig_state));
+	if (false_state)
+		set_related(false_state, estate_related(orig_state));
+
+	FOR_EACH_PTR(estate_related(orig_state), rel) {
+		set_true_false_states(SMATCH_EXTRA, rel->name, rel->sym,
+				true_state, false_state);
+	} END_FOR_EACH_PTR(rel);
+}
+
+static void set_extra_chunk_true_false(struct expression *expr,
+				       struct smatch_state *true_state,
+				       struct smatch_state *false_state)
+{
+	struct var_sym_list *vsl;
+	struct var_sym *vs;
+	struct symbol *type;
+	char *name;
+	struct symbol *sym;
+
+	if (in_warn_on_macro())
+		return;
+
+	type = get_type(expr);
+	if (!type)
+		return;
+
+	name = expr_to_chunk_sym_vsl(expr, &sym, &vsl);
+	if (!name || !vsl)
+		goto free;
+	FOR_EACH_PTR(vsl, vs) {
+		store_link(link_id, vs->var, vs->sym, name, sym);
+	} END_FOR_EACH_PTR(vs);
+
+	set_true_false_states(SMATCH_EXTRA, name, sym,
+			      clone_estate(true_state),
+			      clone_estate(false_state));
+free:
+	free_string(name);
+}
+
+static void set_extra_expr_true_false(struct expression *expr,
+		struct smatch_state *true_state,
+		struct smatch_state *false_state)
+{
+	char *name;
+	struct symbol *sym;
+	sval_t sval;
+
+	if (!true_state && !false_state)
+		return;
+
+	if (get_value(expr, &sval))
+		return;
+
+	expr = strip_expr(expr);
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym) {
+		free_string(name);
+		set_extra_chunk_true_false(expr, true_state, false_state);
+		return;
+	}
+	set_extra_true_false(name, sym, true_state, false_state);
+	free_string(name);
+}
+
+static int get_countdown_info(struct expression *condition, struct expression **unop, int *op, sval_t *right)
+{
+	struct expression *unop_expr;
+	int comparison;
+	sval_t limit;
+
+	right->type = &int_ctype;
+	right->value = 0;
+
+	condition = strip_expr(condition);
+
+	if (condition->type == EXPR_COMPARE) {
+		comparison = remove_unsigned_from_comparison(condition->op);
+
+		if (comparison != SPECIAL_GTE && comparison != '>')
+			return 0;
+		if (!get_value(condition->right, &limit))
+			return 0;
+
+		unop_expr = condition->left;
+		if (unop_expr->type != EXPR_PREOP && unop_expr->type != EXPR_POSTOP)
+			return 0;
+		if (unop_expr->op != SPECIAL_DECREMENT)
+			return 0;
+
+		*unop = unop_expr;
+		*op = comparison;
+		*right = limit;
+
+		return 1;
+	}
+
+	if (condition->type != EXPR_PREOP && condition->type != EXPR_POSTOP)
+		return 0;
+	if (condition->op != SPECIAL_DECREMENT)
+		return 0;
+
+	*unop = condition;
+	*op = '>';
+
+	return 1;
+}
+
+static struct sm_state *handle_canonical_while_count_down(struct statement *loop)
+{
+	struct expression *iter_var;
+	struct expression *condition, *unop;
+	struct sm_state *sm;
+	struct smatch_state *estate;
+	int op;
+	sval_t start, right;
+
+	right.type = &int_ctype;
+	right.value = 0;
+
+	condition = strip_expr(loop->iterator_pre_condition);
+	if (!condition)
+		return NULL;
+
+	if (!get_countdown_info(condition, &unop, &op, &right))
+		return NULL;
+
+	iter_var = unop->unop;
+
+	sm = get_sm_state_expr(SMATCH_EXTRA, iter_var);
+	if (!sm)
+		return NULL;
+	if (sval_cmp(estate_min(sm->state), right) < 0)
+		return NULL;
+	start = estate_max(sm->state);
+	if  (sval_cmp(start, right) <= 0)
+		return NULL;
+	if (!sval_is_max(start))
+		start.value--;
+
+	if (op == SPECIAL_GTE)
+		right.value--;
+
+	if (unop->type == EXPR_PREOP) {
+		right.value++;
+		estate = alloc_estate_range(right, start);
+		if (estate_has_hard_max(sm->state))
+			estate_set_hard_max(estate);
+		estate_copy_fuzzy_max(estate, sm->state);
+		set_extra_expr_mod(iter_var, estate);
+	}
+	if (unop->type == EXPR_POSTOP) {
+		estate = alloc_estate_range(right, start);
+		if (estate_has_hard_max(sm->state))
+			estate_set_hard_max(estate);
+		estate_copy_fuzzy_max(estate, sm->state);
+		set_extra_expr_mod(iter_var, estate);
+	}
+	return get_sm_state_expr(SMATCH_EXTRA, iter_var);
+}
+
+static struct sm_state *handle_canonical_for_inc(struct expression *iter_expr,
+						struct expression *condition)
+{
+	struct expression *iter_var;
+	struct sm_state *sm;
+	struct smatch_state *estate;
+	sval_t start, end, max;
+
+	iter_var = iter_expr->unop;
+	sm = get_sm_state_expr(SMATCH_EXTRA, iter_var);
+	if (!sm)
+		return NULL;
+	if (!estate_get_single_value(sm->state, &start))
+		return NULL;
+	if (get_implied_max(condition->right, &end))
+		end = sval_cast(get_type(iter_var), end);
+	else
+		end = sval_type_max(get_type(iter_var));
+
+	if (get_sm_state_expr(SMATCH_EXTRA, condition->left) != sm)
+		return NULL;
+
+	switch (condition->op) {
+	case SPECIAL_UNSIGNED_LT:
+	case SPECIAL_NOTEQUAL:
+	case '<':
+		if (!sval_is_min(end))
+			end.value--;
+		break;
+	case SPECIAL_UNSIGNED_LTE:
+	case SPECIAL_LTE:
+		break;
+	default:
+		return NULL;
+	}
+	if (sval_cmp(end, start) < 0)
+		return NULL;
+	estate = alloc_estate_range(start, end);
+	if (get_hard_max(condition->right, &max)) {
+		estate_set_hard_max(estate);
+		if (condition->op == '<' ||
+		    condition->op == SPECIAL_UNSIGNED_LT ||
+		    condition->op == SPECIAL_NOTEQUAL)
+			max.value--;
+		estate_set_fuzzy_max(estate, max);
+	}
+	set_extra_expr_mod(iter_var, estate);
+	return get_sm_state_expr(SMATCH_EXTRA, iter_var);
+}
+
+static struct sm_state *handle_canonical_for_dec(struct expression *iter_expr,
+						struct expression *condition)
+{
+	struct expression *iter_var;
+	struct sm_state *sm;
+	struct smatch_state *estate;
+	sval_t start, end;
+
+	iter_var = iter_expr->unop;
+	sm = get_sm_state_expr(SMATCH_EXTRA, iter_var);
+	if (!sm)
+		return NULL;
+	if (!estate_get_single_value(sm->state, &start))
+		return NULL;
+	if (!get_implied_min(condition->right, &end))
+		end = sval_type_min(get_type(iter_var));
+	if (get_sm_state_expr(SMATCH_EXTRA, condition->left) != sm)
+		return NULL;
+
+	switch (condition->op) {
+	case SPECIAL_NOTEQUAL:
+	case '>':
+		if (!sval_is_min(end) && !sval_is_max(end))
+			end.value++;
+		break;
+	case SPECIAL_GTE:
+		break;
+	default:
+		return NULL;
+	}
+	if (sval_cmp(end, start) > 0)
+		return NULL;
+	estate = alloc_estate_range(end, start);
+	estate_set_hard_max(estate);
+	estate_set_fuzzy_max(estate, estate_get_fuzzy_max(estate));
+	set_extra_expr_mod(iter_var, estate);
+	return get_sm_state_expr(SMATCH_EXTRA, iter_var);
+}
+
+static struct sm_state *handle_canonical_for_loops(struct statement *loop)
+{
+	struct expression *iter_expr;
+	struct expression *condition;
+
+	if (!loop->iterator_post_statement)
+		return NULL;
+	if (loop->iterator_post_statement->type != STMT_EXPRESSION)
+		return NULL;
+	iter_expr = loop->iterator_post_statement->expression;
+	if (!loop->iterator_pre_condition)
+		return NULL;
+	if (loop->iterator_pre_condition->type != EXPR_COMPARE)
+		return NULL;
+	condition = loop->iterator_pre_condition;
+
+	if (iter_expr->op == SPECIAL_INCREMENT)
+		return handle_canonical_for_inc(iter_expr, condition);
+	if (iter_expr->op == SPECIAL_DECREMENT)
+		return handle_canonical_for_dec(iter_expr, condition);
+	return NULL;
+}
+
+struct sm_state *__extra_handle_canonical_loops(struct statement *loop, struct stree **stree)
+{
+	struct sm_state *ret;
+
+	/*
+	 * Canonical loops are a hack.  The proper way to handle this is to
+	 * use two passes, but unfortunately, doing two passes makes parsing
+	 * code twice as slow.
+	 *
+	 * What we do is we set the inside state here, which overwrites whatever
+	 * __extra_match_condition() does.  Then we set the outside state in
+	 * __extra_pre_loop_hook_after().
+	 *
+	 */
+	__push_fake_cur_stree();
+	if (!loop->iterator_post_statement)
+		ret = handle_canonical_while_count_down(loop);
+	else
+		ret = handle_canonical_for_loops(loop);
+	*stree = __pop_fake_cur_stree();
+	return ret;
+}
+
+int __iterator_unchanged(struct sm_state *sm)
+{
+	if (!sm)
+		return 0;
+	if (get_sm_state(my_id, sm->name, sm->sym) == sm)
+		return 1;
+	return 0;
+}
+
+static void while_count_down_after(struct sm_state *sm, struct expression *condition)
+{
+	struct expression *unop;
+	int op;
+	sval_t limit, after_value;
+
+	if (!get_countdown_info(condition, &unop, &op, &limit))
+		return;
+	after_value = estate_min(sm->state);
+	after_value.value--;
+	set_extra_mod(sm->name, sm->sym, condition->unop, alloc_estate_sval(after_value));
+}
+
+void __extra_pre_loop_hook_after(struct sm_state *sm,
+				struct statement *iterator,
+				struct expression *condition)
+{
+	struct expression *iter_expr;
+	sval_t limit;
+	struct smatch_state *state;
+
+	if (!iterator) {
+		while_count_down_after(sm, condition);
+		return;
+	}
+
+	iter_expr = iterator->expression;
+
+	if (condition->type != EXPR_COMPARE)
+		return;
+	if (iter_expr->op == SPECIAL_INCREMENT) {
+		limit = sval_binop(estate_max(sm->state), '+',
+				   sval_type_val(estate_type(sm->state), 1));
+	} else {
+		limit = sval_binop(estate_min(sm->state), '-',
+				   sval_type_val(estate_type(sm->state), 1));
+	}
+	if (!estate_has_hard_max(sm->state) && !__has_breaks()) {
+		if (iter_expr->op == SPECIAL_INCREMENT)
+			state = alloc_estate_range(estate_min(sm->state), limit);
+		else
+			state = alloc_estate_range(limit, estate_max(sm->state));
+	} else {
+		state = alloc_estate_sval(limit);
+	}
+	if (!estate_has_hard_max(sm->state)) {
+		estate_clear_hard_max(state);
+	}
+	if (estate_has_fuzzy_max(sm->state)) {
+		sval_t hmax = estate_get_fuzzy_max(sm->state);
+		sval_t max = estate_max(sm->state);
+
+		if (sval_cmp(hmax, max) != 0)
+			estate_clear_fuzzy_max(state);
+	} else if (!estate_has_fuzzy_max(sm->state)) {
+		estate_clear_fuzzy_max(state);
+	}
+
+	set_extra_mod(sm->name, sm->sym, iter_expr, state);
+}
+
+static struct stree *unmatched_stree;
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	struct smatch_state *state;
+
+	if (unmatched_stree) {
+		state = get_state_stree(unmatched_stree, SMATCH_EXTRA, sm->name, sm->sym);
+		if (state)
+			return state;
+	}
+	if (parent_is_gone_var_sym(sm->name, sm->sym))
+		return alloc_estate_empty();
+	return alloc_estate_whole(estate_type(sm->state));
+}
+
+static void clear_the_pointed_at(struct expression *expr)
+{
+	struct stree *stree;
+	char *name;
+	struct symbol *sym;
+	struct sm_state *tmp;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+
+	stree = __get_cur_stree();
+	FOR_EACH_MY_SM(SMATCH_EXTRA, stree, tmp) {
+		if (tmp->name[0] != '*')
+			continue;
+		if (tmp->sym != sym)
+			continue;
+		if (strcmp(tmp->name + 1, name) != 0)
+			continue;
+		set_extra_mod(tmp->name, tmp->sym, expr, alloc_estate_whole(estate_type(tmp->state)));
+	} END_FOR_EACH_SM(tmp);
+
+free:
+	free_string(name);
+}
+
+static int is_const_param(struct expression *expr, int param)
+{
+	struct symbol *type;
+
+	type = get_arg_type(expr, param);
+	if (!type)
+		return 0;
+	if (type->ctype.modifiers & MOD_CONST)
+		return 1;
+	return 0;
+}
+
+static void match_function_call(struct expression *expr)
+{
+	struct expression *arg;
+	struct expression *tmp;
+	int param = -1;
+
+	/* if we have the db this is handled in smatch_function_hooks.c */
+	if (!option_no_db)
+		return;
+	if (inlinable(expr->fn))
+		return;
+
+	FOR_EACH_PTR(expr->args, arg) {
+		param++;
+		if (is_const_param(expr->fn, param))
+			continue;
+		tmp = strip_expr(arg);
+		if (tmp->type == EXPR_PREOP && tmp->op == '&')
+			set_extra_expr_mod(tmp->unop, alloc_estate_whole(get_type(tmp->unop)));
+		else
+			clear_the_pointed_at(tmp);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static int values_fit_type(struct expression *left, struct expression *right)
+{
+	struct range_list *rl;
+	struct symbol *type;
+
+	type = get_type(left);
+	if (!type)
+		return 0;
+	get_absolute_rl(right, &rl);
+	if (type_unsigned(type) && sval_is_negative(rl_min(rl)))
+		return 0;
+	if (sval_cmp(sval_type_min(type), rl_min(rl)) > 0)
+		return 0;
+	if (sval_cmp(sval_type_max(type), rl_max(rl)) < 0)
+		return 0;
+	return 1;
+}
+
+static void save_chunk_info(struct expression *left, struct expression *right)
+{
+	struct var_sym_list *vsl;
+	struct var_sym *vs;
+	struct expression *add_expr;
+	struct symbol *type;
+	sval_t sval;
+	char *name;
+	struct symbol *sym;
+
+	if (right->type != EXPR_BINOP || right->op != '-')
+		return;
+	if (!get_value(right->left, &sval))
+		return;
+	if (!expr_to_sym(right->right))
+		return;
+
+	add_expr = binop_expression(left, '+', right->right);
+	type = get_type(add_expr);
+	if (!type)
+		return;
+	name = expr_to_chunk_sym_vsl(add_expr, &sym, &vsl);
+	if (!name || !vsl)
+		goto free;
+	FOR_EACH_PTR(vsl, vs) {
+		store_link(link_id, vs->var, vs->sym, name, sym);
+	} END_FOR_EACH_PTR(vs);
+
+	set_state(SMATCH_EXTRA, name, sym, alloc_estate_sval(sval_cast(type, sval)));
+free:
+	free_string(name);
+}
+
+static void do_array_assign(struct expression *left, int op, struct expression *right)
+{
+	struct range_list *rl;
+
+	if (op == '=') {
+		get_absolute_rl(right, &rl);
+		rl = cast_rl(get_type(left), rl);
+	} else {
+		rl = alloc_whole_rl(get_type(left));
+	}
+
+	set_extra_array_mod(left, alloc_estate_rl(rl));
+}
+
+static void match_vanilla_assign(struct expression *left, struct expression *right)
+{
+	struct range_list *orig_rl = NULL;
+	struct range_list *rl = NULL;
+	struct symbol *right_sym;
+	struct symbol *left_type;
+	struct symbol *right_type;
+	char *right_name = NULL;
+	struct symbol *sym;
+	char *name;
+	sval_t sval, max;
+	struct smatch_state *state;
+	int comparison;
+
+	if (is_struct(left))
+		return;
+
+	save_chunk_info(left, right);
+
+	name = expr_to_var_sym(left, &sym);
+	if (!name) {
+		if (chunk_has_array(left))
+			do_array_assign(left, '=', right);
+		return;
+	}
+
+	left_type = get_type(left);
+	right_type = get_type(right);
+
+	right_name = expr_to_var_sym(right, &right_sym);
+
+	if (!__in_fake_assign &&
+	    !(right->type == EXPR_PREOP && right->op == '&') &&
+	    right_name && right_sym &&
+	    values_fit_type(left, strip_expr(right)) &&
+	    !has_symbol(right, sym)) {
+		set_equiv(left, right);
+		goto free;
+	}
+
+	if (is_pointer(right) && get_address_rl(right, &rl)) {
+		state = alloc_estate_rl(rl);
+		goto done;
+	}
+
+	if (get_implied_value(right, &sval)) {
+		state = alloc_estate_sval(sval_cast(left_type, sval));
+		goto done;
+	}
+
+	if (__in_fake_assign) {
+		struct smatch_state *right_state;
+		sval_t sval;
+
+		if (get_value(right, &sval)) {
+			sval = sval_cast(left_type, sval);
+			state = alloc_estate_sval(sval);
+			goto done;
+		}
+
+		right_state = get_state(SMATCH_EXTRA, right_name, right_sym);
+		if (right_state) {
+			/* simple assignment */
+			state = clone_estate(right_state);
+			goto done;
+		}
+
+		state = alloc_estate_rl(alloc_whole_rl(left_type));
+		goto done;
+	}
+
+	comparison = get_comparison(left, right);
+	if (comparison) {
+		comparison = flip_comparison(comparison);
+		get_implied_rl(left, &orig_rl);
+	}
+
+	if (get_implied_rl(right, &rl)) {
+		rl = cast_rl(left_type, rl);
+		if (orig_rl)
+			filter_by_comparison(&rl, comparison, orig_rl);
+		state = alloc_estate_rl(rl);
+		if (get_hard_max(right, &max)) {
+			estate_set_hard_max(state);
+			estate_set_fuzzy_max(state, max);
+		}
+	} else {
+		rl = alloc_whole_rl(right_type);
+		rl = cast_rl(left_type, rl);
+		if (orig_rl)
+			filter_by_comparison(&rl, comparison, orig_rl);
+		state = alloc_estate_rl(rl);
+	}
+
+done:
+	set_extra_mod(name, sym, left, state);
+free:
+	free_string(right_name);
+}
+
+static int op_remove_assign(int op)
+{
+	switch (op) {
+	case SPECIAL_ADD_ASSIGN:
+		return '+';
+	case SPECIAL_SUB_ASSIGN:
+		return '-';
+	case SPECIAL_MUL_ASSIGN:
+		return '*';
+	case SPECIAL_DIV_ASSIGN:
+		return '/';
+	case SPECIAL_MOD_ASSIGN:
+		return '%';
+	case SPECIAL_AND_ASSIGN:
+		return '&';
+	case SPECIAL_OR_ASSIGN:
+		return '|';
+	case SPECIAL_XOR_ASSIGN:
+		return '^';
+	case SPECIAL_SHL_ASSIGN:
+		return SPECIAL_LEFTSHIFT;
+	case SPECIAL_SHR_ASSIGN:
+		return SPECIAL_RIGHTSHIFT;
+	default:
+		return op;
+	}
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct range_list *rl = NULL;
+	struct expression *left;
+	struct expression *right;
+	struct expression *binop_expr;
+	struct symbol *left_type;
+	struct symbol *sym;
+	char *name;
+	sval_t left_min, left_max;
+	sval_t right_min, right_max;
+	sval_t res_min, res_max;
+
+	left = strip_expr(expr->left);
+
+	right = strip_parens(expr->right);
+	if (right->type == EXPR_CALL && sym_name_is("__builtin_expect", right->fn))
+		right = get_argument_from_call_expr(right->args, 0);
+	while (right->type == EXPR_ASSIGNMENT && right->op == '=')
+		right = strip_parens(right->left);
+
+	if (expr->op == '=' && is_condition(expr->right))
+		return; /* handled in smatch_condition.c */
+	if (expr->op == '=' && right->type == EXPR_CALL)
+		return; /* handled in smatch_function_hooks.c */
+	if (expr->op == '=') {
+		match_vanilla_assign(left, right);
+		return;
+	}
+
+	name = expr_to_var_sym(left, &sym);
+	if (!name)
+		return;
+
+	left_type = get_type(left);
+
+	res_min = sval_type_min(left_type);
+	res_max = sval_type_max(left_type);
+
+	switch (expr->op) {
+	case SPECIAL_ADD_ASSIGN:
+		get_absolute_max(left, &left_max);
+		get_absolute_max(right, &right_max);
+		if (sval_binop_overflows(left_max, '+', sval_cast(left_type, right_max)))
+			break;
+		if (get_implied_min(left, &left_min) &&
+		    !sval_is_negative_min(left_min) &&
+		    get_implied_min(right, &right_min) &&
+		    !sval_is_negative_min(right_min)) {
+			res_min = sval_binop(left_min, '+', right_min);
+			res_min = sval_cast(left_type, res_min);
+		}
+		if (inside_loop())  /* we are assuming loops don't lead to wrapping */
+			break;
+		res_max = sval_binop(left_max, '+', right_max);
+		res_max = sval_cast(left_type, res_max);
+		break;
+	case SPECIAL_SUB_ASSIGN:
+		if (get_implied_max(left, &left_max) &&
+		    !sval_is_max(left_max) &&
+		    get_implied_min(right, &right_min) &&
+		    !sval_is_min(right_min)) {
+			res_max = sval_binop(left_max, '-', right_min);
+			res_max = sval_cast(left_type, res_max);
+		}
+		if (inside_loop())
+			break;
+		if (get_implied_min(left, &left_min) &&
+		    !sval_is_min(left_min) &&
+		    get_implied_max(right, &right_max) &&
+		    !sval_is_max(right_max)) {
+			res_min = sval_binop(left_min, '-', right_max);
+			res_min = sval_cast(left_type, res_min);
+		}
+		break;
+	case SPECIAL_AND_ASSIGN:
+	case SPECIAL_MOD_ASSIGN:
+	case SPECIAL_SHL_ASSIGN:
+	case SPECIAL_SHR_ASSIGN:
+	case SPECIAL_OR_ASSIGN:
+	case SPECIAL_XOR_ASSIGN:
+	case SPECIAL_MUL_ASSIGN:
+	case SPECIAL_DIV_ASSIGN:
+		binop_expr = binop_expression(expr->left,
+					      op_remove_assign(expr->op),
+					      expr->right);
+		if (get_absolute_rl(binop_expr, &rl)) {
+			rl = cast_rl(left_type, rl);
+			set_extra_mod(name, sym, left, alloc_estate_rl(rl));
+			goto free;
+		}
+		break;
+	}
+	rl = cast_rl(left_type, alloc_rl(res_min, res_max));
+	set_extra_mod(name, sym, left, alloc_estate_rl(rl));
+free:
+	free_string(name);
+}
+
+static struct smatch_state *increment_state(struct smatch_state *state)
+{
+	sval_t min = estate_min(state);
+	sval_t max = estate_max(state);
+
+	if (!estate_rl(state))
+		return NULL;
+
+	if (inside_loop())
+		max = sval_type_max(max.type);
+
+	if (!sval_is_min(min) && !sval_is_max(min))
+		min.value++;
+	if (!sval_is_min(max) && !sval_is_max(max))
+		max.value++;
+	return alloc_estate_range(min, max);
+}
+
+static struct smatch_state *decrement_state(struct smatch_state *state)
+{
+	sval_t min = estate_min(state);
+	sval_t max = estate_max(state);
+
+	if (!estate_rl(state))
+		return NULL;
+
+	if (inside_loop())
+		min = sval_type_min(min.type);
+
+	if (!sval_is_min(min) && !sval_is_max(min))
+		min.value--;
+	if (!sval_is_min(max) && !sval_is_max(max))
+		max.value--;
+	return alloc_estate_range(min, max);
+}
+
+static void clear_pointed_at_state(struct expression *expr)
+{
+	struct symbol *type;
+
+	/*
+         * ALERT: This is sort of a mess.  If it's is a struct assigment like
+	 * "foo = bar;", then that's handled by smatch_struct_assignment.c.
+	 * the same thing for p++ where "p" is a struct.  Most modifications
+	 * are handled by the assignment hook or the db.  Smatch_extra.c doesn't
+	 * use smatch_modification.c because we have to get the ordering right
+	 * or something.  So if you have p++ where p is a pointer to a standard
+	 * c type then we handle that here.  What a mess.
+	 */
+	expr = strip_expr(expr);
+	type = get_type(expr);
+	if (!type || type->type != SYM_PTR)
+		return;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_BASETYPE)
+		return;
+	set_extra_expr_nomod(deref_expression(expr), alloc_estate_whole(type));
+}
+
+static void unop_expr(struct expression *expr)
+{
+	struct smatch_state *state;
+
+	if (expr->smatch_flags & Handled)
+		return;
+
+	switch (expr->op) {
+	case SPECIAL_INCREMENT:
+		state = get_state_expr(SMATCH_EXTRA, expr->unop);
+		state = increment_state(state);
+		if (!state)
+			state = alloc_estate_whole(get_type(expr));
+		set_extra_expr_mod(expr->unop, state);
+		clear_pointed_at_state(expr->unop);
+		break;
+	case SPECIAL_DECREMENT:
+		state = get_state_expr(SMATCH_EXTRA, expr->unop);
+		state = decrement_state(state);
+		if (!state)
+			state = alloc_estate_whole(get_type(expr));
+		set_extra_expr_mod(expr->unop, state);
+		clear_pointed_at_state(expr->unop);
+		break;
+	default:
+		return;
+	}
+}
+
+static void asm_expr(struct statement *stmt)
+{
+
+	struct expression *expr;
+	struct symbol *type;
+	int state = 0;
+
+	FOR_EACH_PTR(stmt->asm_outputs, expr) {
+		switch (state) {
+		case 0: /* identifier */
+		case 1: /* constraint */
+			state++;
+			continue;
+		case 2: /* expression */
+			state = 0;
+			type = get_type(strip_expr(expr));
+			set_extra_expr_mod(expr, alloc_estate_whole(type));
+			continue;
+		}
+	} END_FOR_EACH_PTR(expr);
+}
+
+static void check_dereference(struct expression *expr)
+{
+	struct smatch_state *state;
+
+	if (__in_fake_assign)
+		return;
+	if (outside_of_function())
+		return;
+	state = get_extra_state(expr);
+	if (state) {
+		struct range_list *rl;
+
+		rl = rl_intersection(estate_rl(state), valid_ptr_rl);
+		if (rl_equiv(rl, estate_rl(state)))
+			return;
+		set_extra_expr_nomod(expr, alloc_estate_rl(rl));
+	} else {
+		set_extra_expr_nomod(expr, alloc_estate_range(valid_ptr_min_sval, valid_ptr_max_sval));
+	}
+}
+
+static void match_dereferences(struct expression *expr)
+{
+	if (expr->type != EXPR_PREOP)
+		return;
+	/* it's saying that foo[1] = bar dereferences foo[1] */
+	if (is_array(expr))
+		return;
+	check_dereference(expr->unop);
+}
+
+static void match_pointer_as_array(struct expression *expr)
+{
+	if (!is_array(expr))
+		return;
+	check_dereference(get_array_base(expr));
+}
+
+static void find_dereferences(struct expression *expr)
+{
+	while (expr->type == EXPR_PREOP) {
+		if (expr->op == '*')
+			check_dereference(expr->unop);
+		expr = strip_expr(expr->unop);
+	}
+}
+
+static void set_param_dereferenced(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (name && sym) {
+		struct smatch_state *orig, *new;
+		struct range_list *rl;
+
+		orig = get_state(SMATCH_EXTRA, name, sym);
+		if (orig) {
+			rl = rl_intersection(estate_rl(orig),
+					     alloc_rl(valid_ptr_min_sval,
+						      valid_ptr_max_sval));
+			new = alloc_estate_rl(rl);
+		} else {
+			new = alloc_estate_range(valid_ptr_min_sval, valid_ptr_max_sval);
+		}
+
+		set_extra_nomod(name, sym, NULL, new);
+	}
+	free_string(name);
+
+	find_dereferences(arg);
+}
+
+static sval_t add_one(sval_t sval)
+{
+	sval.value++;
+	return sval;
+}
+
+static int handle_postop_inc(struct expression *left, int op, struct expression *right)
+{
+	struct statement *stmt;
+	struct expression *cond;
+	struct smatch_state *true_state, *false_state;
+	sval_t start;
+	sval_t limit;
+
+	/*
+	 * If we're decrementing here then that's a canonical while count down
+	 * so it's handled already.  We're only handling loops like:
+	 * i = 0;
+	 * do { ... } while (i++ < 3);
+	 */
+
+	if (left->type != EXPR_POSTOP || left->op != SPECIAL_INCREMENT)
+		return 0;
+
+	stmt = __cur_stmt->parent;
+	if (!stmt)
+		return 0;
+	if (stmt->type == STMT_COMPOUND)
+		stmt = stmt->parent;
+	if (!stmt || stmt->type != STMT_ITERATOR || !stmt->iterator_post_condition)
+		return 0;
+
+	cond = strip_expr(stmt->iterator_post_condition);
+	if (cond->type != EXPR_COMPARE || cond->op != op)
+		return 0;
+	if (left != strip_expr(cond->left) || right != strip_expr(cond->right))
+		return 0;
+
+	if (!get_implied_value(left->unop, &start))
+		return 0;
+	if (!get_implied_value(right, &limit))
+		return 0;
+
+	if (sval_cmp(start, limit) > 0)
+		return 0;
+
+	switch (op) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+		break;
+	case SPECIAL_LTE:
+	case SPECIAL_UNSIGNED_LTE:
+		limit = add_one(limit);
+	default:
+		return 0;
+
+	}
+
+	true_state = alloc_estate_range(add_one(start), limit);
+	false_state = alloc_estate_range(add_one(limit), add_one(limit));
+
+	/* Currently we just discard the false state but when two passes is
+	 * implimented correctly then it will use it.
+	 */
+
+	set_extra_expr_true_false(left->unop, true_state, false_state);
+
+	return 1;
+}
+
+bool is_impossible_variable(struct expression *expr)
+{
+	struct smatch_state *state;
+
+	state = get_extra_state(expr);
+	if (state && !estate_rl(state))
+		return true;
+	return false;
+}
+
+static void handle_comparison(struct symbol *type, struct expression *left, int op, struct expression *right)
+{
+	struct range_list *left_orig;
+	struct range_list *left_true;
+	struct range_list *left_false;
+	struct range_list *right_orig;
+	struct range_list *right_true;
+	struct range_list *right_false;
+	struct smatch_state *left_true_state;
+	struct smatch_state *left_false_state;
+	struct smatch_state *right_true_state;
+	struct smatch_state *right_false_state;
+	sval_t dummy, hard_max;
+	int left_postop = 0;
+	int right_postop = 0;
+
+	if (left->op == SPECIAL_INCREMENT || left->op == SPECIAL_DECREMENT) {
+		if (left->type == EXPR_POSTOP) {
+			left->smatch_flags |= Handled;
+			left_postop = left->op;
+			if (handle_postop_inc(left, op, right))
+				return;
+		}
+		left = strip_parens(left->unop);
+	}
+	while (left->type == EXPR_ASSIGNMENT)
+		left = strip_parens(left->left);
+
+	if (right->op == SPECIAL_INCREMENT || right->op == SPECIAL_DECREMENT) {
+		if (right->type == EXPR_POSTOP) {
+			right->smatch_flags |= Handled;
+			right_postop = right->op;
+		}
+		right = strip_parens(right->unop);
+	}
+
+	if (is_impossible_variable(left) || is_impossible_variable(right))
+		return;
+
+	get_real_absolute_rl(left, &left_orig);
+	left_orig = cast_rl(type, left_orig);
+
+	get_real_absolute_rl(right, &right_orig);
+	right_orig = cast_rl(type, right_orig);
+
+	split_comparison_rl(left_orig, op, right_orig, &left_true, &left_false, &right_true, &right_false);
+
+	left_true = rl_truncate_cast(get_type(strip_expr(left)), left_true);
+	left_false = rl_truncate_cast(get_type(strip_expr(left)), left_false);
+	right_true = rl_truncate_cast(get_type(strip_expr(right)), right_true);
+	right_false = rl_truncate_cast(get_type(strip_expr(right)), right_false);
+
+	if (!left_true || !left_false) {
+		struct range_list *tmp_true, *tmp_false;
+
+		split_comparison_rl(alloc_whole_rl(type), op, right_orig, &tmp_true, &tmp_false, NULL, NULL);
+		tmp_true = rl_truncate_cast(get_type(strip_expr(left)), tmp_true);
+		tmp_false = rl_truncate_cast(get_type(strip_expr(left)), tmp_false);
+		if (tmp_true && tmp_false)
+			__save_imaginary_state(left, tmp_true, tmp_false);
+	}
+
+	if (!right_true || !right_false) {
+		struct range_list *tmp_true, *tmp_false;
+
+		split_comparison_rl(alloc_whole_rl(type), op, right_orig, NULL, NULL, &tmp_true, &tmp_false);
+		tmp_true = rl_truncate_cast(get_type(strip_expr(right)), tmp_true);
+		tmp_false = rl_truncate_cast(get_type(strip_expr(right)), tmp_false);
+		if (tmp_true && tmp_false)
+			__save_imaginary_state(right, tmp_true, tmp_false);
+	}
+
+	left_true_state = alloc_estate_rl(left_true);
+	left_false_state = alloc_estate_rl(left_false);
+	right_true_state = alloc_estate_rl(right_true);
+	right_false_state = alloc_estate_rl(right_false);
+
+	switch (op) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+	case SPECIAL_UNSIGNED_LTE:
+	case SPECIAL_LTE:
+		if (get_hard_max(right, &dummy))
+			estate_set_hard_max(left_true_state);
+		if (get_hard_max(left, &dummy))
+			estate_set_hard_max(right_false_state);
+		break;
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+	case SPECIAL_UNSIGNED_GTE:
+	case SPECIAL_GTE:
+		if (get_hard_max(left, &dummy))
+			estate_set_hard_max(right_true_state);
+		if (get_hard_max(right, &dummy))
+			estate_set_hard_max(left_false_state);
+		break;
+	}
+
+	switch (op) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+	case SPECIAL_UNSIGNED_LTE:
+	case SPECIAL_LTE:
+		if (get_hard_max(right, &hard_max)) {
+			if (op == '<' || op == SPECIAL_UNSIGNED_LT)
+				hard_max.value--;
+			estate_set_fuzzy_max(left_true_state, hard_max);
+		}
+		if (get_implied_value(right, &hard_max)) {
+			if (op == SPECIAL_UNSIGNED_LTE ||
+			    op == SPECIAL_LTE)
+				hard_max.value++;
+			estate_set_fuzzy_max(left_false_state, hard_max);
+		}
+		if (get_hard_max(left, &hard_max)) {
+			if (op == SPECIAL_UNSIGNED_LTE ||
+			    op == SPECIAL_LTE)
+				hard_max.value--;
+			estate_set_fuzzy_max(right_false_state, hard_max);
+		}
+		if (get_implied_value(left, &hard_max)) {
+			if (op == '<' || op == SPECIAL_UNSIGNED_LT)
+				hard_max.value++;
+			estate_set_fuzzy_max(right_true_state, hard_max);
+		}
+		break;
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+	case SPECIAL_UNSIGNED_GTE:
+	case SPECIAL_GTE:
+		if (get_hard_max(left, &hard_max)) {
+			if (op == '>' || op == SPECIAL_UNSIGNED_GT)
+				hard_max.value--;
+			estate_set_fuzzy_max(right_true_state, hard_max);
+		}
+		if (get_implied_value(left, &hard_max)) {
+			if (op == SPECIAL_UNSIGNED_GTE ||
+			    op == SPECIAL_GTE)
+				hard_max.value++;
+			estate_set_fuzzy_max(right_false_state, hard_max);
+		}
+		if (get_hard_max(right, &hard_max)) {
+			if (op == SPECIAL_UNSIGNED_LTE ||
+			    op == SPECIAL_LTE)
+				hard_max.value--;
+			estate_set_fuzzy_max(left_false_state, hard_max);
+		}
+		if (get_implied_value(right, &hard_max)) {
+			if (op == '>' ||
+			    op == SPECIAL_UNSIGNED_GT)
+				hard_max.value++;
+			estate_set_fuzzy_max(left_true_state, hard_max);
+		}
+		break;
+	case SPECIAL_EQUAL:
+		if (get_hard_max(left, &hard_max))
+			estate_set_fuzzy_max(right_true_state, hard_max);
+		if (get_hard_max(right, &hard_max))
+			estate_set_fuzzy_max(left_true_state, hard_max);
+		break;
+	}
+
+	if (get_hard_max(left, &hard_max)) {
+		estate_set_hard_max(left_true_state);
+		estate_set_hard_max(left_false_state);
+	}
+	if (get_hard_max(right, &hard_max)) {
+		estate_set_hard_max(right_true_state);
+		estate_set_hard_max(right_false_state);
+	}
+
+	if (left_postop == SPECIAL_INCREMENT) {
+		left_true_state = increment_state(left_true_state);
+		left_false_state = increment_state(left_false_state);
+	}
+	if (left_postop == SPECIAL_DECREMENT) {
+		left_true_state = decrement_state(left_true_state);
+		left_false_state = decrement_state(left_false_state);
+	}
+	if (right_postop == SPECIAL_INCREMENT) {
+		right_true_state = increment_state(right_true_state);
+		right_false_state = increment_state(right_false_state);
+	}
+	if (right_postop == SPECIAL_DECREMENT) {
+		right_true_state = decrement_state(right_true_state);
+		right_false_state = decrement_state(right_false_state);
+	}
+
+	if (estate_rl(left_true_state) && estates_equiv(left_true_state, left_false_state)) {
+		left_true_state = NULL;
+		left_false_state = NULL;
+	}
+
+	if (estate_rl(right_true_state) && estates_equiv(right_true_state, right_false_state)) {
+		right_true_state = NULL;
+		right_false_state = NULL;
+	}
+
+	/* Don't introduce new states for known true/false conditions */
+	if (rl_equiv(left_orig, estate_rl(left_true_state)))
+		left_true_state = NULL;
+	if (rl_equiv(left_orig, estate_rl(left_false_state)))
+		left_false_state = NULL;
+	if (rl_equiv(right_orig, estate_rl(right_true_state)))
+		right_true_state = NULL;
+	if (rl_equiv(right_orig, estate_rl(right_false_state)))
+		right_false_state = NULL;
+
+	set_extra_expr_true_false(left, left_true_state, left_false_state);
+	set_extra_expr_true_false(right, right_true_state, right_false_state);
+}
+
+static int is_simple_math(struct expression *expr)
+{
+	if (!expr)
+		return 0;
+	if (expr->type != EXPR_BINOP)
+		return 0;
+	switch (expr->op) {
+	case '+':
+	case '-':
+	case '*':
+		return 1;
+	}
+	return 0;
+}
+
+static void move_known_values(struct expression **left_p, struct expression **right_p)
+{
+	struct expression *left = *left_p;
+	struct expression *right = *right_p;
+	sval_t sval, dummy;
+
+	if (get_implied_value(left, &sval)) {
+		if (!is_simple_math(right))
+			return;
+		if (get_implied_value(right, &dummy))
+			return;
+		if (right->op == '*') {
+			sval_t divisor;
+
+			if (!get_value(right->right, &divisor))
+				return;
+			if (divisor.value == 0)
+				return;
+			*left_p = binop_expression(left, invert_op(right->op), right->right);
+			*right_p = right->left;
+			return;
+		}
+		if (right->op == '+' && get_value(right->left, &sval)) {
+			*left_p = binop_expression(left, invert_op(right->op), right->left);
+			*right_p = right->right;
+			return;
+		}
+		if (get_value(right->right, &sval)) {
+			*left_p = binop_expression(left, invert_op(right->op), right->right);
+			*right_p = right->left;
+			return;
+		}
+		return;
+	}
+	if (get_implied_value(right, &sval)) {
+		if (!is_simple_math(left))
+			return;
+		if (get_implied_value(left, &dummy))
+			return;
+		if (left->op == '*') {
+			sval_t divisor;
+
+			if (!get_value(left->right, &divisor))
+				return;
+			if (divisor.value == 0)
+				return;
+			*right_p = binop_expression(right, invert_op(left->op), left->right);
+			*left_p = left->left;
+			return;
+		}
+		if (left->op == '+' && get_value(left->left, &sval)) {
+			*right_p = binop_expression(right, invert_op(left->op), left->left);
+			*left_p = left->right;
+			return;
+		}
+
+		if (get_value(left->right, &sval)) {
+			*right_p = binop_expression(right, invert_op(left->op), left->right);
+			*left_p = left->left;
+			return;
+		}
+		return;
+	}
+}
+
+/*
+ * The reason for do_simple_algebra() is to solve things like:
+ * if (foo > 66 || foo + bar > 64) {
+ * "foo" is not really a known variable so it won't be handled by
+ * move_known_variables() but it's a super common idiom.
+ *
+ */
+static int do_simple_algebra(struct expression **left_p, struct expression **right_p)
+{
+	struct expression *left = *left_p;
+	struct expression *right = *right_p;
+	struct range_list *rl;
+	sval_t tmp;
+
+	if (left->type != EXPR_BINOP || left->op != '+')
+		return 0;
+	if (can_integer_overflow(get_type(left), left))
+		return 0;
+	if (!get_implied_value(right, &tmp))
+		return 0;
+
+	if (!get_implied_value(left->left, &tmp) &&
+	    get_implied_rl(left->left, &rl) &&
+	    !is_whole_rl(rl)) {
+		*right_p = binop_expression(right, '-', left->left);
+		*left_p = left->right;
+		return 1;
+	}
+	if (!get_implied_value(left->right, &tmp) &&
+	    get_implied_rl(left->right, &rl) &&
+	    !is_whole_rl(rl)) {
+		*right_p = binop_expression(right, '-', left->right);
+		*left_p = left->left;
+		return 1;
+	}
+
+	return 0;
+}
+
+static int match_func_comparison(struct expression *expr)
+{
+	struct expression *left = strip_expr(expr->left);
+	struct expression *right = strip_expr(expr->right);
+	sval_t sval;
+
+	/*
+	 * fixme: think about this harder. We should always be trying to limit
+	 * the non-call side as well.  If we can't determine the limitter does
+	 * that mean we aren't querying the database and are missing important
+	 * information?
+	 */
+
+	if (left->type == EXPR_CALL) {
+		if (get_implied_value(left, &sval)) {
+			handle_comparison(get_type(expr), left, expr->op, right);
+			return 1;
+		}
+		function_comparison(left, expr->op, right);
+		return 1;
+	}
+
+	if (right->type == EXPR_CALL) {
+		if (get_implied_value(right, &sval)) {
+			handle_comparison(get_type(expr), left, expr->op, right);
+			return 1;
+		}
+		function_comparison(left, expr->op, right);
+		return 1;
+	}
+
+	return 0;
+}
+
+/* Handle conditions like "if (foo + bar < foo) {" */
+static int handle_integer_overflow_test(struct expression *expr)
+{
+	struct expression *left, *right;
+	struct symbol *type;
+	sval_t left_min, right_min, min, max;
+
+	if (expr->op != '<' && expr->op != SPECIAL_UNSIGNED_LT)
+		return 0;
+
+	left = strip_parens(expr->left);
+	right = strip_parens(expr->right);
+
+	if (left->op != '+')
+		return 0;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+	if (type_positive_bits(type) == 32) {
+		max.type = &uint_ctype;
+		max.uvalue = (unsigned int)-1;
+	} else if (type_positive_bits(type) == 64) {
+		max.type = &ulong_ctype;
+		max.value = (unsigned long long)-1;
+	} else {
+		return 0;
+	}
+
+	if (!expr_equiv(left->left, right) && !expr_equiv(left->right, right))
+		return 0;
+
+	get_absolute_min(left->left, &left_min);
+	get_absolute_min(left->right, &right_min);
+	min = sval_binop(left_min, '+', right_min);
+
+	set_extra_chunk_true_false(left, NULL, alloc_estate_range(min, max));
+	return 1;
+}
+
+static void match_comparison(struct expression *expr)
+{
+	struct expression *left_orig = strip_parens(expr->left);
+	struct expression *right_orig = strip_parens(expr->right);
+	struct expression *left, *right, *tmp;
+	struct expression *prev;
+	struct symbol *type;
+	int redo, count;
+
+	if (match_func_comparison(expr))
+		return;
+
+	type = get_type(expr);
+	if (!type)
+		type = &llong_ctype;
+
+	if (handle_integer_overflow_test(expr))
+		return;
+
+	left = left_orig;
+	right = right_orig;
+	move_known_values(&left, &right);
+	handle_comparison(type, left, expr->op, right);
+
+	left = left_orig;
+	right = right_orig;
+	if (do_simple_algebra(&left, &right))
+		handle_comparison(type, left, expr->op, right);
+
+	prev = get_assigned_expr(left_orig);
+	if (is_simple_math(prev) && has_variable(prev, left_orig) == 0) {
+		left = prev;
+		right = right_orig;
+		move_known_values(&left, &right);
+		handle_comparison(type, left, expr->op, right);
+	}
+
+	prev = get_assigned_expr(right_orig);
+	if (is_simple_math(prev) && has_variable(prev, right_orig) == 0) {
+		left = left_orig;
+		right = prev;
+		move_known_values(&left, &right);
+		handle_comparison(type, left, expr->op, right);
+	}
+
+	redo = 0;
+	left = left_orig;
+	right = right_orig;
+	if (get_last_expr_from_expression_stmt(left_orig)) {
+		left = get_last_expr_from_expression_stmt(left_orig);
+		redo = 1;
+	}
+	if (get_last_expr_from_expression_stmt(right_orig)) {
+		right = get_last_expr_from_expression_stmt(right_orig);
+		redo = 1;
+	}
+
+	if (!redo)
+		return;
+
+	count = 0;
+	while ((tmp = get_assigned_expr(left))) {
+		if (count++ > 3)
+			break;
+		left = strip_expr(tmp);
+	}
+	count = 0;
+	while ((tmp = get_assigned_expr(right))) {
+		if (count++ > 3)
+			break;
+		right = strip_expr(tmp);
+	}
+
+	handle_comparison(type, left, expr->op, right);
+}
+
+static sval_t get_high_mask(sval_t known)
+{
+	sval_t ret;
+	int i;
+
+	ret = known;
+	ret.value = 0;
+
+	for (i = type_bits(known.type) - 1; i >= 0; i--) {
+		if (known.uvalue & (1ULL << i))
+			ret.uvalue |= (1ULL << i);
+		else
+			return ret;
+
+	}
+	return ret;
+}
+
+static void handle_AND_op(struct expression *var, sval_t known)
+{
+	struct range_list *orig_rl;
+	struct range_list *true_rl = NULL;
+	struct range_list *false_rl = NULL;
+	int bit;
+	sval_t low_mask = known;
+	sval_t high_mask;
+	sval_t max;
+
+	get_absolute_rl(var, &orig_rl);
+
+	if (known.value > 0) {
+		bit = ffsll(known.value) - 1;
+		low_mask.uvalue = (1ULL << bit) - 1;
+		true_rl = remove_range(orig_rl, sval_type_val(known.type, 0), low_mask);
+	}
+	high_mask = get_high_mask(known);
+	if (high_mask.value) {
+		bit = ffsll(high_mask.value) - 1;
+		low_mask.uvalue = (1ULL << bit) - 1;
+
+		false_rl = orig_rl;
+		if (sval_is_negative(rl_min(orig_rl)))
+			false_rl = remove_range(false_rl, sval_type_min(known.type), sval_type_val(known.type, -1));
+		false_rl = remove_range(false_rl, low_mask, sval_type_max(known.type));
+		if (type_signed(high_mask.type) && type_unsigned(rl_type(false_rl))) {
+			false_rl = remove_range(false_rl,
+						sval_type_val(rl_type(false_rl), sval_type_max(known.type).uvalue),
+					sval_type_val(rl_type(false_rl), -1));
+		}
+	} else if (known.value == 1 &&
+		   get_hard_max(var, &max) &&
+		   sval_cmp(max, rl_max(orig_rl)) == 0 &&
+		   max.value & 1) {
+		false_rl = remove_range(orig_rl, max, max);
+	}
+	set_extra_expr_true_false(var,
+				  true_rl ? alloc_estate_rl(true_rl) : NULL,
+				  false_rl ? alloc_estate_rl(false_rl) : NULL);
+}
+
+static void handle_AND_condition(struct expression *expr)
+{
+	sval_t known;
+
+	if (get_implied_value(expr->left, &known))
+		handle_AND_op(expr->right, known);
+	else if (get_implied_value(expr->right, &known))
+		handle_AND_op(expr->left, known);
+}
+
+static void handle_MOD_condition(struct expression *expr)
+{
+	struct range_list *orig_rl;
+	struct range_list *true_rl;
+	struct range_list *false_rl = NULL;
+	sval_t right;
+	sval_t zero;
+
+	if (!get_implied_value(expr->right, &right) || right.value == 0)
+		return;
+	get_absolute_rl(expr->left, &orig_rl);
+
+	zero.value = 0;
+	zero.type = rl_type(orig_rl);
+
+	/* We're basically dorking around the min and max here */
+	true_rl = remove_range(orig_rl, zero, zero);
+	if (!sval_is_max(rl_max(true_rl)) &&
+	    !(rl_max(true_rl).value % right.value))
+		true_rl = remove_range(true_rl, rl_max(true_rl), rl_max(true_rl));
+
+	if (rl_equiv(true_rl, orig_rl))
+		true_rl = NULL;
+
+	if (sval_is_positive(rl_min(orig_rl)) &&
+	    (rl_max(orig_rl).value - rl_min(orig_rl).value) / right.value < 5) {
+		sval_t add;
+		int i;
+
+		add = rl_min(orig_rl);
+		add.value += right.value - (add.value % right.value);
+		add.value -= right.value;
+
+		for (i = 0; i < 5; i++) {
+			add.value += right.value;
+			if (add.value > rl_max(orig_rl).value)
+				break;
+			add_range(&false_rl, add, add);
+		}
+	} else {
+		if (rl_min(orig_rl).uvalue != 0 &&
+		    rl_min(orig_rl).uvalue < right.uvalue) {
+			sval_t chop = right;
+			chop.value--;
+			false_rl = remove_range(orig_rl, zero, chop);
+		}
+
+		if (!sval_is_max(rl_max(orig_rl)) &&
+		    (rl_max(orig_rl).value % right.value)) {
+			sval_t chop = rl_max(orig_rl);
+			chop.value -= chop.value % right.value;
+			chop.value++;
+			if (!false_rl)
+				false_rl = clone_rl(orig_rl);
+			false_rl = remove_range(false_rl, chop, rl_max(orig_rl));
+		}
+	}
+
+	set_extra_expr_true_false(expr->left,
+				  true_rl ? alloc_estate_rl(true_rl) : NULL,
+				  false_rl ? alloc_estate_rl(false_rl) : NULL);
+}
+
+/* this is actually hooked from smatch_implied.c...  it's hacky, yes */
+void __extra_match_condition(struct expression *expr)
+{
+	struct smatch_state *pre_state;
+	struct smatch_state *true_state;
+	struct smatch_state *false_state;
+	struct range_list *pre_rl;
+
+	expr = strip_expr(expr);
+	switch (expr->type) {
+	case EXPR_CALL:
+		function_comparison(expr, SPECIAL_NOTEQUAL, zero_expr());
+		return;
+	case EXPR_PREOP:
+	case EXPR_SYMBOL:
+	case EXPR_DEREF: {
+		sval_t zero;
+
+		zero = sval_blank(expr);
+		zero.value = 0;
+
+		pre_state = get_extra_state(expr);
+		if (estate_is_empty(pre_state))
+			return;
+		if (pre_state)
+			pre_rl = estate_rl(pre_state);
+		else
+			get_absolute_rl(expr, &pre_rl);
+		if (possibly_true_rl(pre_rl, SPECIAL_EQUAL, rl_zero()))
+			false_state = alloc_estate_sval(zero);
+		else
+			false_state = alloc_estate_empty();
+		true_state = alloc_estate_rl(remove_range(pre_rl, zero, zero));
+		set_extra_expr_true_false(expr, true_state, false_state);
+		return;
+	}
+	case EXPR_COMPARE:
+		match_comparison(expr);
+		return;
+	case EXPR_ASSIGNMENT:
+		__extra_match_condition(expr->left);
+		return;
+	case EXPR_BINOP:
+		if (expr->op == '&')
+			handle_AND_condition(expr);
+		if (expr->op == '%')
+			handle_MOD_condition(expr);
+		return;
+	}
+}
+
+static void assume_indexes_are_valid(struct expression *expr)
+{
+	struct expression *array_expr;
+	int array_size;
+	struct expression *offset;
+	struct symbol *offset_type;
+	struct range_list *rl_before;
+	struct range_list *rl_after;
+	struct range_list *filter = NULL;
+	sval_t size;
+
+	expr = strip_expr(expr);
+	if (!is_array(expr))
+		return;
+
+	offset = get_array_offset(expr);
+	offset_type = get_type(offset);
+	if (offset_type && type_signed(offset_type)) {
+		filter = alloc_rl(sval_type_min(offset_type),
+				  sval_type_val(offset_type, -1));
+	}
+
+	array_expr = get_array_base(expr);
+	array_size = get_real_array_size(array_expr);
+	if (array_size > 1) {
+		size = sval_type_val(offset_type, array_size);
+		add_range(&filter, size, sval_type_max(offset_type));
+	}
+
+	if (!filter)
+		return;
+	get_absolute_rl(offset, &rl_before);
+	rl_after = rl_filter(rl_before, filter);
+	if (rl_equiv(rl_before, rl_after))
+		return;
+	set_extra_expr_nomod(offset, alloc_estate_rl(rl_after));
+}
+
+/* returns 1 if it is not possible for expr to be value, otherwise returns 0 */
+int implied_not_equal(struct expression *expr, long long val)
+{
+	return !possibly_false(expr, SPECIAL_NOTEQUAL, value_expr(val));
+}
+
+int implied_not_equal_name_sym(char *name, struct symbol *sym, long long val)
+{
+	struct smatch_state *estate;
+
+	estate = get_state(SMATCH_EXTRA, name, sym);
+	if (!estate)
+		return 0;
+	if (!rl_has_sval(estate_rl(estate), sval_type_val(estate_type(estate), 0)))
+		return 1;
+	return 0;
+}
+
+int parent_is_null_var_sym(const char *name, struct symbol *sym)
+{
+	char buf[256];
+	char *start;
+	char *end;
+	struct smatch_state *state;
+
+	strncpy(buf, name, sizeof(buf) - 1);
+	buf[sizeof(buf) - 1] = '\0';
+
+	start = &buf[0];
+	while (*start == '*') {
+		start++;
+		state = get_state(SMATCH_EXTRA, start, sym);
+		if (!state)
+			continue;
+		if (!estate_rl(state))
+			return 1;
+		if (estate_min(state).value == 0 &&
+		    estate_max(state).value == 0)
+			return 1;
+	}
+
+	start = &buf[0];
+	while (*start == '&')
+		start++;
+
+	while ((end = strrchr(start, '-'))) {
+		*end = '\0';
+		state = __get_state(SMATCH_EXTRA, start, sym);
+		if (!state)
+			continue;
+		if (estate_min(state).value == 0 &&
+		    estate_max(state).value == 0)
+			return 1;
+	}
+	return 0;
+}
+
+int parent_is_null(struct expression *expr)
+{
+	struct symbol *sym;
+	char *var;
+	int ret = 0;
+
+	expr = strip_expr(expr);
+	var = expr_to_var_sym(expr, &sym);
+	if (!var || !sym)
+		goto free;
+	ret = parent_is_null_var_sym(var, sym);
+free:
+	free_string(var);
+	return ret;
+}
+
+static int param_used_callback(void *found, int argc, char **argv, char **azColName)
+{
+	*(int *)found = 1;
+	return 0;
+}
+
+static int filter_unused_kzalloc_info(struct expression *call, int param, char *printed_name, struct sm_state *sm)
+{
+	sval_t sval;
+	int found = 0;
+
+	/* for function pointers assume everything is used */
+	if (call->fn->type != EXPR_SYMBOL)
+		return 0;
+
+	/*
+	 * This is to handle __builtin_mul_overflow().  In an ideal world we
+	 * would only need this for invalid code.
+	 *
+	 */
+	if (!call->fn->symbol)
+		return 0;
+
+	/*
+	 * kzalloc() information is treated as special because so there is just
+	 * a lot of stuff initialized to zero and it makes building the database
+	 * take hours and hours.
+	 *
+	 * In theory, we should just remove this line and not pass any unused
+	 * information, but I'm not sure enough that this code works so I want
+	 * to hold off on that for now.
+	 */
+	if (!estate_get_single_value(sm->state, &sval) || sval.value != 0)
+		return 0;
+
+	run_sql(&param_used_callback, &found,
+		"select * from return_implies where %s and type = %d and parameter = %d and key = '%s';",
+		get_static_filter(call->fn->symbol), PARAM_USED, param, printed_name);
+	if (found)
+		return 0;
+
+	/* If the database is not built yet, then assume everything is used */
+	run_sql(&param_used_callback, &found,
+		"select * from return_implies where %s and type = %d;",
+		get_static_filter(call->fn->symbol), PARAM_USED);
+	if (!found)
+		return 0;
+
+	return 1;
+}
+
+struct range_list *intersect_with_real_abs_var_sym(const char *name, struct symbol *sym, struct range_list *start)
+{
+	struct smatch_state *state;
+
+	/*
+	 * Here is the difference between implied value and real absolute, say
+	 * you have:
+	 *
+	 *	int a = (u8)x;
+	 *
+	 * Then you know that a is 0-255.  That's real absolute.  But you don't
+	 * know for sure that it actually goes up to 255.  So it's not implied.
+	 * Implied indicates a degree of certainty.
+	 *
+	 * But then say you cap "a" at 8.  That means you know it goes up to
+	 * 8.  So now the implied value is s32min-8.  But you can combine it
+	 * with the real absolute to say that actually it's 0-8.
+	 *
+	 * We are combining it here.  But now that I think about it, this is
+	 * probably not the ideal place to combine it because it should proably
+	 * be done earlier.  Oh well, this is an improvement on what was there
+	 * before so I'm going to commit this code.
+	 *
+	 */
+
+	state = get_real_absolute_state_var_sym(name, sym);
+	if (!state || !estate_rl(state))
+		return start;
+
+	return rl_intersection(estate_rl(state), start);
+}
+
+struct range_list *intersect_with_real_abs_expr(struct expression *expr, struct range_list *start)
+{
+	struct smatch_state *state;
+	struct range_list *abs_rl;
+
+	state = get_real_absolute_state(expr);
+	if (!state || !estate_rl(state))
+		return start;
+
+	abs_rl = cast_rl(rl_type(start), estate_rl(state));
+	return rl_intersection(abs_rl, start);
+}
+
+static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
+{
+	struct range_list *rl;
+
+	if (estate_is_whole(sm->state))
+		return;
+	if (filter_unused_kzalloc_info(call, param, printed_name, sm))
+		return;
+	rl = estate_rl(sm->state);
+	rl = intersect_with_real_abs_var_sym(sm->name, sm->sym, rl);
+	sql_insert_caller_info(call, PARAM_VALUE, param, printed_name, show_rl(rl));
+	if (estate_has_fuzzy_max(sm->state))
+		sql_insert_caller_info(call, FUZZY_MAX, param, printed_name,
+				       sval_to_str(estate_get_fuzzy_max(sm->state)));
+}
+
+static void returned_struct_members(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct symbol *returned_sym;
+	struct sm_state *sm;
+	const char *param_name;
+	char *compare_str;
+	char buf[256];
+
+	returned_sym = expr_to_sym(expr);
+	if (!returned_sym)
+		return;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (!estate_rl(sm->state))
+			continue;
+		if (returned_sym != sm->sym)
+			continue;
+
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+		if (strcmp(param_name, "$") == 0)
+			continue;
+		compare_str = name_sym_to_param_comparison(sm->name, sm->sym);
+		if (!compare_str && estate_is_whole(sm->state))
+			continue;
+		snprintf(buf, sizeof(buf), "%s%s", sm->state->name, compare_str ?: "");
+
+		sql_insert_return_states(return_id, return_ranges, PARAM_VALUE,
+					 -1, param_name, buf);
+	} END_FOR_EACH_SM(sm);
+}
+
+static void db_limited_before(void)
+{
+	unmatched_stree = clone_stree(__get_cur_stree());
+}
+
+static void db_limited_after(void)
+{
+	free_stree(&unmatched_stree);
+}
+
+static int rl_fits_in_type(struct range_list *rl, struct symbol *type)
+{
+	if (type_bits(rl_type(rl)) <= type_bits(type))
+		return 1;
+	if (sval_cmp(rl_max(rl), sval_type_max(type)) > 0)
+		return 0;
+	if (sval_is_negative(rl_min(rl)) &&
+	    sval_cmp(rl_min(rl), sval_type_min(type)) < 0)
+		return 0;
+	return 1;
+}
+
+static int basically_the_same(struct range_list *orig, struct range_list *new)
+{
+	if (rl_equiv(orig, new))
+		return 1;
+
+	/*
+	 * The whole range is essentially the same as 0,4096-27777777777 so
+	 * don't overwrite the implications just to store that.
+	 *
+	 */
+	if (rl_type(orig)->type == SYM_PTR &&
+	    is_whole_rl(orig) &&
+	    rl_min(new).value == 0 &&
+	    rl_max(new).value == valid_ptr_max)
+		return 1;
+	return 0;
+}
+
+static void db_param_limit_binops(struct expression *arg, char *key, struct range_list *rl)
+{
+	struct range_list *left_rl;
+	sval_t zero = {	.type = rl_type(rl), };
+	sval_t sval;
+
+	if (arg->op != '*')
+		return;
+	if (!get_implied_value(arg->right, &sval))
+		return;
+	if (can_integer_overflow(get_type(arg), arg))
+		return;
+
+	left_rl = rl_binop(rl, '/', alloc_rl(sval, sval));
+	if (!rl_has_sval(rl, zero))
+		left_rl = remove_range(left_rl, zero, zero);
+
+	set_extra_expr_nomod(arg->left, alloc_estate_rl(left_rl));
+}
+
+static void db_param_limit_filter(struct expression *expr, int param, char *key, char *value, enum info_type op)
+{
+	struct expression *arg;
+	char *name;
+	struct symbol *sym;
+	struct var_sym_list *vsl = NULL;
+	struct sm_state *sm;
+	struct symbol *compare_type, *var_type;
+	struct range_list *rl;
+	struct range_list *limit;
+	struct range_list *new;
+	char *tmp_name;
+	struct symbol *tmp_sym;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+
+	name = get_chunk_from_key(arg, key, &sym, &vsl);
+	if (!name)
+		return;
+	if (op != PARAM_LIMIT && !sym)
+		goto free;
+
+	if (strcmp(key, "$") == 0)
+		compare_type = get_arg_type(expr->fn, param);
+	else
+		compare_type = get_member_type_from_key(arg, key);
+
+	sm = get_sm_state(SMATCH_EXTRA, name, sym);
+	if (sm)
+		rl = estate_rl(sm->state);
+	else
+		rl = alloc_whole_rl(compare_type);
+
+	if (op == PARAM_LIMIT && !rl_fits_in_type(rl, compare_type))
+		goto free;
+
+	call_results_to_rl(expr, compare_type, value, &limit);
+	new = rl_intersection(rl, limit);
+
+	var_type = get_member_type_from_key(arg, key);
+	new = cast_rl(var_type, new);
+
+	/* We want to preserve the implications here */
+	if (sm && basically_the_same(estate_rl(sm->state), new))
+		goto free;
+	tmp_name = map_long_to_short_name_sym(name, sym, &tmp_sym);
+	if (tmp_name && tmp_sym) {
+		free_string(name);
+		name = tmp_name;
+		sym = tmp_sym;
+	}
+
+	if (op == PARAM_LIMIT)
+		set_extra_nomod_vsl(name, sym, vsl, NULL, alloc_estate_rl(new));
+	else
+		set_extra_mod(name, sym, NULL, alloc_estate_rl(new));
+
+	if (op == PARAM_LIMIT && arg->type == EXPR_BINOP)
+		db_param_limit_binops(arg, key, new);
+free:
+	free_string(name);
+}
+
+static void db_param_limit(struct expression *expr, int param, char *key, char *value)
+{
+	db_param_limit_filter(expr, param, key, value, PARAM_LIMIT);
+}
+
+static void db_param_filter(struct expression *expr, int param, char *key, char *value)
+{
+	db_param_limit_filter(expr, param, key, value, PARAM_FILTER);
+}
+
+static void db_param_add_set(struct expression *expr, int param, char *key, char *value, enum info_type op)
+{
+	struct expression *arg;
+	char *name, *tmp_name;
+	struct symbol *sym, *tmp_sym;
+	struct symbol *param_type, *arg_type;
+	struct smatch_state *state;
+	struct range_list *new = NULL;
+	struct range_list *added = NULL;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+
+	arg_type = get_arg_type_from_key(expr->fn, param, arg, key);
+	param_type = get_member_type_from_key(arg, key);
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	state = get_state(SMATCH_EXTRA, name, sym);
+	if (state)
+		new = estate_rl(state);
+
+	call_results_to_rl(expr, arg_type, value, &added);
+	added = cast_rl(param_type, added);
+	if (op == PARAM_SET)
+		new = added;
+	else
+		new = rl_union(new, added);
+
+	tmp_name = map_long_to_short_name_sym_nostack(name, sym, &tmp_sym);
+	if (tmp_name && tmp_sym) {
+		free_string(name);
+		name = tmp_name;
+		sym = tmp_sym;
+	}
+	set_extra_mod(name, sym, NULL, alloc_estate_rl(new));
+free:
+	free_string(name);
+}
+
+static void db_param_add(struct expression *expr, int param, char *key, char *value)
+{
+	in_param_set = true;
+	db_param_add_set(expr, param, key, value, PARAM_ADD);
+	in_param_set = false;
+}
+
+static void db_param_set(struct expression *expr, int param, char *key, char *value)
+{
+	in_param_set = true;
+	db_param_add_set(expr, param, key, value, PARAM_SET);
+	in_param_set = false;
+}
+
+static void db_param_value(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *call;
+	char *name;
+	struct symbol *sym;
+	struct symbol *type;
+	struct range_list *rl = NULL;
+
+	if (param != -1)
+		return;
+
+	call = expr;
+	while (call->type == EXPR_ASSIGNMENT)
+		call = strip_expr(call->right);
+	if (call->type != EXPR_CALL)
+		return;
+
+	type = get_member_type_from_key(expr->left, key);
+	name = get_variable_from_key(expr->left, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	call_results_to_rl(call, type, value, &rl);
+
+	set_extra_mod(name, sym, NULL, alloc_estate_rl(rl));
+free:
+	free_string(name);
+}
+
+static void match_call_info(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct range_list *rl = NULL;
+	struct expression *arg;
+	struct symbol *type;
+	int i = 0;
+
+	FOR_EACH_PTR(expr->args, arg) {
+		type = get_arg_type(expr->fn, i);
+
+		get_absolute_rl(arg, &rl);
+		rl = cast_rl(type, rl);
+
+		if (!is_whole_rl(rl)) {
+			rl = intersect_with_real_abs_expr(arg, rl);
+			sql_insert_caller_info(expr, PARAM_VALUE, i, "$", show_rl(rl));
+		}
+		state = get_state_expr(SMATCH_EXTRA, arg);
+		if (estate_has_fuzzy_max(state)) {
+			sql_insert_caller_info(expr, FUZZY_MAX, i, "$",
+					       sval_to_str(estate_get_fuzzy_max(state)));
+		}
+		i++;
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void set_param_value(const char *name, struct symbol *sym, char *key, char *value)
+{
+	struct range_list *rl = NULL;
+	struct smatch_state *state;
+	struct symbol *type;
+	char fullname[256];
+	sval_t dummy;
+
+	if (strcmp(key, "*$") == 0)
+		snprintf(fullname, sizeof(fullname), "*%s", name);
+	else if (strncmp(key, "$", 1) == 0)
+		snprintf(fullname, 256, "%s%s", name, key + 1);
+	else
+		return;
+
+	type = get_member_type_from_key(symbol_expression(sym), key);
+	str_to_rl(type, value, &rl);
+	state = alloc_estate_rl(rl);
+	if (estate_get_single_value(state, &dummy))
+		estate_set_hard_max(state);
+	set_state(SMATCH_EXTRA, fullname, sym, state);
+}
+
+static void set_param_hard_max(const char *name, struct symbol *sym, char *key, char *value)
+{
+	struct range_list *rl = NULL;
+	struct smatch_state *state;
+	struct symbol *type;
+	char fullname[256];
+	sval_t max;
+
+	if (strcmp(key, "*$") == 0)
+		snprintf(fullname, sizeof(fullname), "*%s", name);
+	else if (strncmp(key, "$", 1) == 0)
+		snprintf(fullname, 256, "%s%s", name, key + 1);
+	else
+		return;
+
+	state = get_state(SMATCH_EXTRA, fullname, sym);
+	if (!state)
+		return;
+	type = get_member_type_from_key(symbol_expression(sym), key);
+	str_to_rl(type, value, &rl);
+	if (!rl_to_sval(rl, &max))
+		return;
+	estate_set_fuzzy_max(state, max);
+}
+
+struct sm_state *get_extra_sm_state(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	struct sm_state *ret = NULL;
+
+	name = expr_to_known_chunk_sym(expr, &sym);
+	if (!name)
+		goto free;
+
+	ret = get_sm_state(SMATCH_EXTRA, name, sym);
+free:
+	free_string(name);
+	return ret;
+}
+
+struct smatch_state *get_extra_state(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	sm = get_extra_sm_state(expr);
+	if (!sm)
+		return NULL;
+	return sm->state;
+}
+
+void register_smatch_extra(int id)
+{
+	my_id = id;
+
+	add_merge_hook(my_id, &merge_estates);
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	select_caller_info_hook(set_param_value, PARAM_VALUE);
+	select_caller_info_hook(set_param_hard_max, FUZZY_MAX);
+	select_return_states_before(&db_limited_before);
+	select_return_states_hook(PARAM_LIMIT, &db_param_limit);
+	select_return_states_hook(PARAM_FILTER, &db_param_filter);
+	select_return_states_hook(PARAM_ADD, &db_param_add);
+	select_return_states_hook(PARAM_SET, &db_param_set);
+	select_return_states_hook(PARAM_VALUE, &db_param_value);
+	select_return_states_after(&db_limited_after);
+}
+
+static void match_link_modify(struct sm_state *sm, struct expression *mod_expr)
+{
+	struct var_sym_list *links;
+	struct var_sym *tmp;
+	struct smatch_state *state;
+
+	links = sm->state->data;
+
+	FOR_EACH_PTR(links, tmp) {
+		if (sm->sym == tmp->sym &&
+		    strcmp(sm->name, tmp->var) == 0)
+			continue;
+		state = get_state(SMATCH_EXTRA, tmp->var, tmp->sym);
+		if (!state)
+			continue;
+		set_state(SMATCH_EXTRA, tmp->var, tmp->sym, alloc_estate_whole(estate_type(state)));
+	} END_FOR_EACH_PTR(tmp);
+	set_state(link_id, sm->name, sm->sym, &undefined);
+}
+
+void register_smatch_extra_links(int id)
+{
+	link_id = id;
+}
+
+void register_smatch_extra_late(int id)
+{
+	add_merge_hook(link_id, &merge_link_states);
+	add_modification_hook(link_id, &match_link_modify);
+	add_hook(&match_dereferences, DEREF_HOOK);
+	add_hook(&match_pointer_as_array, OP_HOOK);
+	select_return_implies_hook(DEREFERENCE, &set_param_dereferenced);
+	add_hook(&match_function_call, FUNCTION_CALL_HOOK);
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_assign, GLOBAL_ASSIGNMENT_HOOK);
+	add_hook(&unop_expr, OP_HOOK);
+	add_hook(&asm_expr, ASM_HOOK);
+
+	add_hook(&match_call_info, FUNCTION_CALL_HOOK);
+	add_member_info_callback(my_id, struct_member_callback);
+	add_split_return_callback(&returned_struct_members);
+
+//	add_hook(&assume_indexes_are_valid, OP_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_extra.h b/usr/src/tools/smatch/src/smatch_extra.h
new file mode 100644
index 0000000000..d48cdf1f79
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_extra.h
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+DECLARE_PTR_LIST(range_list, struct data_range);
+DECLARE_PTR_LIST(range_list_stack, struct range_list);
+
+struct relation {
+	char *name;
+	struct symbol *sym;
+};
+
+DECLARE_PTR_LIST(related_list, struct relation);
+
+struct data_info {
+	struct related_list *related;
+	struct range_list *value_ranges;
+	sval_t fuzzy_max;
+	unsigned int hard_max:1;
+};
+DECLARE_ALLOCATOR(data_info);
+
+extern struct string_list *__ignored_macros;
+
+/* these are implemented in smatch_ranges.c */
+struct range_list *rl_zero(void);
+struct range_list *rl_one(void);
+char *show_rl(struct range_list *list);
+int str_to_comparison_arg(const char *c, struct expression *call, int *comparison, struct expression **arg);
+void str_to_rl(struct symbol *type, char *value, struct range_list **rl);
+void call_results_to_rl(struct expression *call, struct symbol *type, char *value, struct range_list **rl);
+
+struct data_range *alloc_range(sval_t min, sval_t max);
+struct data_range *alloc_range_perm(sval_t min, sval_t max);
+
+struct range_list *alloc_rl(sval_t min, sval_t max);
+struct range_list *clone_rl(struct range_list *list);
+struct range_list *clone_rl_permanent(struct range_list *list);
+struct range_list *alloc_whole_rl(struct symbol *type);
+
+void add_range(struct range_list **list, sval_t min, sval_t max);
+struct range_list *remove_range(struct range_list *list, sval_t min, sval_t max);
+void tack_on(struct range_list **list, struct data_range *drange);
+
+int true_comparison_range(struct data_range *left, int comparison, struct data_range *right);
+int true_comparison_range_LR(int comparison, struct data_range *var, struct data_range *val, int left);
+int false_comparison_range_LR(int comparison, struct data_range *var, struct data_range *val, int left);
+
+int possibly_true(struct expression *left, int comparison, struct expression *right);
+int possibly_true_rl(struct range_list *left_ranges, int comparison, struct range_list *right_ranges);
+int possibly_true_rl_LR(int comparison, struct range_list *a, struct range_list *b, int left);
+
+int possibly_false(struct expression *left, int comparison, struct expression *right);
+int possibly_false_rl(struct range_list *left_ranges, int comparison, struct range_list *right_ranges);
+int possibly_false_rl_LR(int comparison, struct range_list *a, struct range_list *b, int left);
+
+int rl_has_sval(struct range_list *rl, sval_t sval);
+int ranges_equiv(struct data_range *one, struct data_range *two);
+
+int rl_equiv(struct range_list *one, struct range_list *two);
+int is_whole_rl(struct range_list *rl);
+int is_whole_rl_non_zero(struct range_list *rl);
+int estate_is_unknown(struct smatch_state *state);
+
+sval_t rl_min(struct range_list *rl);
+sval_t rl_max(struct range_list *rl);
+int rl_to_sval(struct range_list *rl, sval_t *sval);
+struct symbol *rl_type(struct range_list *rl);
+
+struct range_list *rl_invert(struct range_list *orig);
+struct range_list *rl_filter(struct range_list *rl, struct range_list *filter);
+struct range_list *rl_intersection(struct range_list *one, struct range_list *two);
+struct range_list *rl_union(struct range_list *one, struct range_list *two);
+struct range_list *rl_binop(struct range_list *left, int op, struct range_list *right);
+
+void push_rl(struct range_list_stack **rl_stack, struct range_list *rl);
+struct range_list *pop_rl(struct range_list_stack **rl_stack);
+struct range_list *top_rl(struct range_list_stack *rl_stack);
+void filter_top_rl(struct range_list_stack **rl_stack, struct range_list *filter);
+
+struct range_list *rl_truncate_cast(struct symbol *type, struct range_list *rl);
+struct range_list *cast_rl(struct symbol *type, struct range_list *rl);
+int get_implied_rl(struct expression *expr, struct range_list **rl);
+int get_absolute_rl(struct expression *expr, struct range_list **rl);
+int get_real_absolute_rl(struct expression *expr, struct range_list **rl);
+struct range_list *var_to_absolute_rl(struct expression *expr);
+int custom_get_absolute_rl(struct expression *expr,
+			   struct range_list *(*fn)(struct expression *expr),
+			   struct range_list **rl);
+int get_implied_rl_var_sym(const char *var, struct symbol *sym, struct range_list **rl);
+void split_comparison_rl(struct range_list *left_orig, int op, struct range_list *right_orig,
+		struct range_list **left_true_rl, struct range_list **left_false_rl,
+		struct range_list **right_true_rl, struct range_list **right_false_rl);
+
+void free_data_info_allocs(void);
+void free_all_rl(void);
+
+/* smatch_estate.c */
+
+struct smatch_state *alloc_estate_empty(void);
+struct smatch_state *alloc_estate_sval(sval_t sval);
+struct smatch_state *alloc_estate_range(sval_t min, sval_t max);
+struct smatch_state *alloc_estate_rl(struct range_list *rl);
+struct smatch_state *alloc_estate_whole(struct symbol *type);
+struct smatch_state *clone_estate(struct smatch_state *state);
+struct smatch_state *clone_estate_cast(struct symbol *type, struct smatch_state *state);
+
+struct smatch_state *merge_estates(struct smatch_state *s1, struct smatch_state *s2);
+
+int estates_equiv(struct smatch_state *one, struct smatch_state *two);
+int estate_is_whole(struct smatch_state *state);
+int estate_is_empty(struct smatch_state *state);
+
+struct range_list *estate_rl(struct smatch_state *state);
+struct related_list *estate_related(struct smatch_state *state);
+
+sval_t estate_min(struct smatch_state *state);
+sval_t estate_max(struct smatch_state *state);
+struct symbol *estate_type(struct smatch_state *state);
+
+int estate_has_fuzzy_max(struct smatch_state *state);
+sval_t estate_get_fuzzy_max(struct smatch_state *state);
+void estate_set_fuzzy_max(struct smatch_state *state, sval_t max);
+void estate_copy_fuzzy_max(struct smatch_state *new, struct smatch_state *old);
+void estate_clear_fuzzy_max(struct smatch_state *state);
+int estate_has_hard_max(struct smatch_state *state);
+void estate_set_hard_max(struct smatch_state *state);
+void estate_clear_hard_max(struct smatch_state *state);
+int estate_get_hard_max(struct smatch_state *state, sval_t *sval);
+
+int estate_get_single_value(struct smatch_state *state, sval_t *sval);
+struct smatch_state *get_implied_estate(struct expression *expr);
+
+struct smatch_state *estate_filter_sval(struct smatch_state *orig, sval_t filter);
+struct smatch_state *estate_filter_range(struct smatch_state *orig, sval_t filter_min, sval_t filter_max);
+struct data_info *clone_dinfo_perm(struct data_info *dinfo);
+struct smatch_state *clone_estate_perm(struct smatch_state *state);
+
+/* smatch_extra.c */
+bool is_impossible_variable(struct expression *expr);
+struct sm_state *get_extra_sm_state(struct expression *expr);
+struct smatch_state *get_extra_state(struct expression *expr);
+void call_extra_mod_hooks(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state);
+void set_extra_mod(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state);
+void set_extra_expr_mod(struct expression *expr, struct smatch_state *state);
+void set_extra_nomod(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state);
+void set_extra_nomod_vsl(const char *name, struct symbol *sym, struct var_sym_list *vsl, struct expression *expr, struct smatch_state *state);
+void set_extra_expr_nomod(struct expression *expr, struct smatch_state *state);
+void set_extra_mod_helper(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state);
+
+struct data_info *get_dinfo(struct smatch_state *state);
+
+void add_extra_mod_hook(void (*fn)(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state));
+void add_extra_nomod_hook(void (*fn)(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state));
+int implied_not_equal(struct expression *expr, long long val);
+int implied_not_equal_name_sym(char *name, struct symbol *sym, long long val);
+int parent_is_null_var_sym(const char *name, struct symbol *sym);
+int parent_is_null(struct expression *expr);
+int parent_is_free_var_sym_strict(const char *name, struct symbol *sym);
+int parent_is_free_var_sym(const char *name, struct symbol *sym);
+int parent_is_free(struct expression *expr);
+
+struct sm_state *__extra_handle_canonical_loops(struct statement *loop, struct stree **stree);
+int __iterator_unchanged(struct sm_state *sm);
+void __extra_pre_loop_hook_after(struct sm_state *sm,
+				struct statement *iterator,
+				struct expression *condition);
+
+/* smatch_equiv.c */
+void set_equiv(struct expression *left, struct expression *right);
+void set_related(struct smatch_state *estate, struct related_list *rlist);
+struct related_list *get_shared_relations(struct related_list *one,
+					      struct related_list *two);
+struct related_list *clone_related_list(struct related_list *related);
+void remove_from_equiv(const char *name, struct symbol *sym);
+void remove_from_equiv_expr(struct expression *expr);
+void set_equiv_state_expr(int id, struct expression *expr, struct smatch_state *state);
+
+/* smatch_function_hooks.c */
+void function_comparison(struct expression *left, int comparison, struct expression *right);
+
+/* smatch_expressions.c */
+struct expression *zero_expr();
+struct expression *value_expr(long long val);
+struct expression *member_expression(struct expression *deref, int op, struct ident *member);
+struct expression *preop_expression(struct expression *expr, int op);
+struct expression *deref_expression(struct expression *expr);
+struct expression *assign_expression(struct expression *left, int op, struct expression *right);
+struct expression *binop_expression(struct expression *left, int op, struct expression *right);
+struct expression *array_element_expression(struct expression *array, struct expression *offset);
+struct expression *symbol_expression(struct symbol *sym);
+struct expression *string_expression(char *str);
+struct expression *compare_expression(struct expression *left, int op, struct expression *right);
+struct expression *unknown_value_expression(struct expression *expr);
+int is_fake_call(struct expression *expr);
+struct expression *gen_expression_from_key(struct expression *arg, const char *key);
+void free_tmp_expressions(void);
+void expr_set_parent_expr(struct expression *expr, struct expression *parent);
+void expr_set_parent_stmt(struct expression *expr, struct statement *parent);
+struct expression *expr_get_parent_expr(struct expression *expr);
+struct statement *expr_get_parent_stmt(struct expression *expr);
+
+/* smatch_param_limit.c */
+struct smatch_state *get_orig_estate(const char *name, struct symbol *sym);
+
+/* smatch_real_absolute.c */
+struct smatch_state *get_real_absolute_state(struct expression *expr);
+struct smatch_state *get_real_absolute_state_var_sym(const char *name, struct symbol *sym);
+
+/* smatch_imaginary_absolute.c */
+void __save_imaginary_state(struct expression *expr, struct range_list *true_rl, struct range_list *false_rl);
+int get_imaginary_absolute(struct expression *expr, struct range_list **rl);
+
diff --git a/usr/src/tools/smatch/src/smatch_files.c b/usr/src/tools/smatch/src/smatch_files.c
new file mode 100644
index 0000000000..8f690e2f72
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_files.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "parse.h"
+#include "smatch.h"
+
+int open_data_file(const char *filename)
+{
+	char buf[256];
+	int fd;
+
+	fd = open(filename, O_RDONLY);
+	if (fd >= 0)
+		return fd;
+	if (!data_dir)
+		return -1;
+	snprintf(buf, 256, "%s/%s", data_dir, filename);
+	return open(buf, O_RDONLY);
+}
+
+int open_schema_file(const char *schema)
+{
+	char buf[256];
+	int fd;
+
+	fd = open_data_file(schema);
+	if (fd >= 0)
+		return fd;
+	snprintf(buf, 256, "%s/smatch_data/%s", bin_dir, schema);
+	return open(buf, O_RDONLY);
+}
+
+struct token *get_tokens_file(const char *filename)
+{
+	int fd;
+	struct token *token;
+
+	if (option_no_data)
+		return NULL;
+	fd = open_data_file(filename);
+	if (fd < 0)
+		return NULL;
+	token = tokenize(filename, fd, NULL, NULL);
+	close(fd);
+	return token;
+}
diff --git a/usr/src/tools/smatch/src/smatch_flow.c b/usr/src/tools/smatch/src/smatch_flow.c
new file mode 100644
index 0000000000..5c4d64bc02
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_flow.c
@@ -0,0 +1,1947 @@
+/*
+ * Copyright (C) 2006,2008 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#define _GNU_SOURCE 1
+#include <unistd.h>
+#include <stdio.h>
+#include "token.h"
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_expression_stacks.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+int __in_fake_assign;
+int __in_fake_struct_assign;
+int in_fake_env;
+int final_pass;
+int __inline_call;
+struct expression  *__inline_fn;
+
+static int __smatch_lineno = 0;
+
+static char *base_file;
+static const char *filename;
+static char *pathname;
+static char *full_filename;
+static char *full_base_file;
+static char *cur_func;
+static unsigned int loop_count;
+static int last_goto_statement_handled;
+int __expr_stmt_count;
+int __in_function_def;
+static struct expression_list *switch_expr_stack = NULL;
+static struct expression_list *post_op_stack = NULL;
+
+static struct ptr_list *backup;
+
+struct expression_list *big_expression_stack;
+struct statement_list *big_statement_stack;
+struct statement *__prev_stmt;
+struct statement *__cur_stmt;
+struct statement *__next_stmt;
+int __in_pre_condition = 0;
+int __bail_on_rest_of_function = 0;
+static struct timeval fn_start_time;
+static struct timeval outer_fn_start_time;
+char *get_function(void) { return cur_func; }
+int get_lineno(void) { return __smatch_lineno; }
+int inside_loop(void) { return !!loop_count; }
+int definitely_inside_loop(void) { return !!(loop_count & ~0x08000000); }
+struct expression *get_switch_expr(void) { return top_expression(switch_expr_stack); }
+int in_expression_statement(void) { return !!__expr_stmt_count; }
+
+static void split_symlist(struct symbol_list *sym_list);
+static void split_declaration(struct symbol_list *sym_list);
+static void split_expr_list(struct expression_list *expr_list, struct expression *parent);
+static void add_inline_function(struct symbol *sym);
+static void parse_inline(struct expression *expr);
+
+int option_assume_loops = 0;
+int option_two_passes = 0;
+struct symbol *cur_func_sym = NULL;
+struct stree *global_states;
+
+long long valid_ptr_min = 4096;
+long long valid_ptr_max = 2117777777;
+sval_t valid_ptr_min_sval = {
+	.type = &ptr_ctype,
+	{.value = 4096},
+};
+sval_t valid_ptr_max_sval = {
+	.type = &ptr_ctype,
+	{.value = LONG_MAX - 100000},
+};
+struct range_list *valid_ptr_rl;
+
+static void set_valid_ptr_max(void)
+{
+	if (type_bits(&ptr_ctype) == 32)
+		valid_ptr_max = 2117777777;
+	else if (type_bits(&ptr_ctype) == 64)
+		valid_ptr_max = 2117777777777777777LL;
+
+	valid_ptr_max_sval.value = valid_ptr_max;
+}
+
+static void alloc_valid_ptr_rl(void)
+{
+	valid_ptr_rl = alloc_rl(valid_ptr_min_sval, valid_ptr_max_sval);
+	valid_ptr_rl = cast_rl(&ptr_ctype, valid_ptr_rl);
+	valid_ptr_rl = clone_rl_permanent(valid_ptr_rl);
+}
+
+int outside_of_function(void)
+{
+	return cur_func_sym == NULL;
+}
+
+const char *get_filename(void)
+{
+	if (option_info && option_full_path)
+		return full_base_file;
+	if (option_info)
+		return base_file;
+	if (option_full_path)
+		return full_filename;
+	return filename;
+}
+
+const char *get_base_file(void)
+{
+	if (option_full_path)
+		return full_base_file;
+	return base_file;
+}
+
+static void set_position(struct position pos)
+{
+	int len;
+	static int prev_stream = -1;
+
+	if (in_fake_env)
+		return;
+
+	if (pos.stream == 0 && pos.line == 0)
+		return;
+
+	__smatch_lineno = pos.line;
+
+	if (pos.stream == prev_stream)
+		return;
+
+	filename = stream_name(pos.stream);
+
+	free(full_filename);
+	pathname = getcwd(NULL, 0);
+	if (pathname) {
+		len = strlen(pathname) + 1 + strlen(filename) + 1;
+		full_filename = malloc(len);
+		snprintf(full_filename, len, "%s/%s", pathname, filename);
+	} else {
+		full_filename = alloc_string(filename);
+	}
+	free(pathname);
+}
+
+int is_assigned_call(struct expression *expr)
+{
+	struct expression *parent = expr_get_parent_expr(expr);
+
+	if (parent &&
+	    parent->type == EXPR_ASSIGNMENT &&
+	    parent->op == '=' &&
+	    strip_expr(parent->right) == expr)
+		return 1;
+
+	return 0;
+}
+
+static int is_inline_func(struct expression *expr)
+{
+	if (expr->type != EXPR_SYMBOL || !expr->symbol)
+		return 0;
+	if (expr->symbol->ctype.modifiers & MOD_INLINE)
+		return 1;
+	return 0;
+}
+
+static int is_noreturn_func(struct expression *expr)
+{
+	if (expr->type != EXPR_SYMBOL || !expr->symbol)
+		return 0;
+	if (expr->symbol->ctype.modifiers & MOD_NORETURN)
+		return 1;
+	return 0;
+}
+
+static int inline_budget = 20;
+
+int inlinable(struct expression *expr)
+{
+	struct symbol *sym;
+	struct statement *last_stmt = NULL;
+
+	if (__inline_fn)  /* don't nest */
+		return 0;
+
+	if (expr->type != EXPR_SYMBOL || !expr->symbol)
+		return 0;
+	if (is_no_inline_function(expr->symbol->ident->name))
+		return 0;
+	sym = get_base_type(expr->symbol);
+	if (sym->stmt && sym->stmt->type == STMT_COMPOUND) {
+		if (ptr_list_size((struct ptr_list *)sym->stmt->stmts) > 10)
+			return 0;
+		if (sym->stmt->type != STMT_COMPOUND)
+			return 0;
+		last_stmt = last_ptr_list((struct ptr_list *)sym->stmt->stmts);
+	}
+	if (sym->inline_stmt && sym->inline_stmt->type == STMT_COMPOUND) {
+		if (ptr_list_size((struct ptr_list *)sym->inline_stmt->stmts) > 10)
+			return 0;
+		if (sym->inline_stmt->type != STMT_COMPOUND)
+			return 0;
+		last_stmt = last_ptr_list((struct ptr_list *)sym->inline_stmt->stmts);
+	}
+
+	if (!last_stmt)
+		return 0;
+
+	/* the magic numbers in this function are pulled out of my bum. */
+	if (last_stmt->pos.line > sym->pos.line + inline_budget)
+		return 0;
+
+	return 1;
+}
+
+void __process_post_op_stack(void)
+{
+	struct expression *expr;
+
+	FOR_EACH_PTR(post_op_stack, expr) {
+		__pass_to_client(expr, OP_HOOK);
+	} END_FOR_EACH_PTR(expr);
+
+	__free_ptr_list((struct ptr_list **)&post_op_stack);
+}
+
+static int handle_comma_assigns(struct expression *expr)
+{
+	struct expression *right;
+	struct expression *assign;
+
+	right = strip_expr(expr->right);
+	if (right->type != EXPR_COMMA)
+		return 0;
+
+	__split_expr(right->left);
+	__process_post_op_stack();
+
+	assign = assign_expression(expr->left, '=', right->right);
+	__split_expr(assign);
+
+	return 1;
+}
+
+/* This is to handle *p++ = foo; assignments */
+static int handle_postop_assigns(struct expression *expr)
+{
+	struct expression *left, *fake_left;
+	struct expression *assign;
+
+	left = strip_expr(expr->left);
+	if (left->type != EXPR_PREOP || left->op != '*')
+		return 0;
+	left = strip_expr(left->unop);
+	if (left->type != EXPR_POSTOP)
+		return 0;
+
+	fake_left = deref_expression(strip_expr(left->unop));
+	assign = assign_expression(fake_left, '=', expr->right);
+
+	__split_expr(assign);
+	__split_expr(expr->left);
+
+	return 1;
+}
+
+static int prev_expression_is_getting_address(struct expression *expr)
+{
+	struct expression *parent;
+
+	do {
+		parent = expr_get_parent_expr(expr);
+
+		if (!parent)
+			return 0;
+		if (parent->type == EXPR_PREOP && parent->op == '&')
+			return 1;
+		if (parent->type == EXPR_PREOP && parent->op == '(')
+			goto next;
+		if (parent->type == EXPR_DEREF && parent->op == '.')
+			goto next;
+
+		return 0;
+next:
+		expr = parent;
+	} while (1);
+}
+
+static void handle_builtin_overflow_func(struct expression *expr)
+{
+	struct expression *a, *b, *res, *assign;
+	int op;
+
+	if (sym_name_is("__builtin_add_overflow", expr->fn))
+		op = '+';
+	else if (sym_name_is("__builtin_sub_overflow", expr->fn))
+		op = '-';
+	else if (sym_name_is("__builtin_mul_overflow", expr->fn))
+		op = '*';
+	else
+		return;
+
+	a = get_argument_from_call_expr(expr->args, 0);
+	b = get_argument_from_call_expr(expr->args, 1);
+	res = get_argument_from_call_expr(expr->args, 2);
+
+	assign = assign_expression(deref_expression(res), '=', binop_expression(a, op, b));
+	__split_expr(assign);
+}
+
+static int handle__builtin_choose_expr(struct expression *expr)
+{
+	struct expression *const_expr, *expr1, *expr2;
+	sval_t sval;
+
+	if (!sym_name_is("__builtin_choose_expr", expr->fn))
+		return 0;
+
+	const_expr = get_argument_from_call_expr(expr->args, 0);
+	expr1 = get_argument_from_call_expr(expr->args, 1);
+	expr2 = get_argument_from_call_expr(expr->args, 2);
+
+	if (!get_value(const_expr, &sval) || !expr1 || !expr2)
+		return 0;
+	if (sval.value)
+		__split_expr(expr1);
+	else
+		__split_expr(expr2);
+	return 1;
+}
+
+static int handle__builtin_choose_expr_assigns(struct expression *expr)
+{
+	struct expression *const_expr, *right, *expr1, *expr2, *fake;
+	sval_t sval;
+
+	right = strip_expr(expr->right);
+	if (right->type != EXPR_CALL)
+		return 0;
+	if (!sym_name_is("__builtin_choose_expr", right->fn))
+		return 0;
+
+	const_expr = get_argument_from_call_expr(right->args, 0);
+	expr1 = get_argument_from_call_expr(right->args, 1);
+	expr2 = get_argument_from_call_expr(right->args, 2);
+
+	if (!get_value(const_expr, &sval) || !expr1 || !expr2)
+		return 0;
+
+	fake = assign_expression(expr->left, '=', sval.value ? expr1 : expr2);
+	__split_expr(fake);
+	return 1;
+}
+
+void __split_expr(struct expression *expr)
+{
+	if (!expr)
+		return;
+
+	// sm_msg(" Debug expr_type %d %s", expr->type, show_special(expr->op));
+
+	if (__in_fake_assign && expr->type != EXPR_ASSIGNMENT)
+		return;
+	if (__in_fake_assign >= 4)  /* don't allow too much nesting */
+		return;
+
+	push_expression(&big_expression_stack, expr);
+	set_position(expr->pos);
+	__pass_to_client(expr, EXPR_HOOK);
+
+	switch (expr->type) {
+	case EXPR_PREOP:
+		expr_set_parent_expr(expr->unop, expr);
+
+		if (expr->op == '*' &&
+		    !prev_expression_is_getting_address(expr))
+			__pass_to_client(expr, DEREF_HOOK);
+		__split_expr(expr->unop);
+		__pass_to_client(expr, OP_HOOK);
+		break;
+	case EXPR_POSTOP:
+		expr_set_parent_expr(expr->unop, expr);
+
+		__split_expr(expr->unop);
+		push_expression(&post_op_stack, expr);
+		break;
+	case EXPR_STATEMENT:
+		__expr_stmt_count++;
+		if (expr->statement && !expr->statement) {
+			stmt_set_parent_stmt(expr->statement,
+					last_ptr_list((struct ptr_list *)big_statement_stack));
+		}
+		__split_stmt(expr->statement);
+		__expr_stmt_count--;
+		break;
+	case EXPR_LOGICAL:
+	case EXPR_COMPARE:
+		expr_set_parent_expr(expr->left, expr);
+		expr_set_parent_expr(expr->right, expr);
+
+		__pass_to_client(expr, LOGIC_HOOK);
+		__handle_logic(expr);
+		break;
+	case EXPR_BINOP:
+		expr_set_parent_expr(expr->left, expr);
+		expr_set_parent_expr(expr->right, expr);
+
+		__pass_to_client(expr, BINOP_HOOK);
+	case EXPR_COMMA:
+		expr_set_parent_expr(expr->left, expr);
+		expr_set_parent_expr(expr->right, expr);
+
+		__split_expr(expr->left);
+		__process_post_op_stack();
+		__split_expr(expr->right);
+		break;
+	case EXPR_ASSIGNMENT: {
+		struct expression *right;
+
+		expr_set_parent_expr(expr->left, expr);
+		expr_set_parent_expr(expr->right, expr);
+
+		right = strip_expr(expr->right);
+		if (!right)
+			break;
+
+		__pass_to_client(expr, RAW_ASSIGNMENT_HOOK);
+
+		/* foo = !bar() */
+		if (__handle_condition_assigns(expr))
+			break;
+		/* foo = (x < 5 ? foo : 5); */
+		if (__handle_select_assigns(expr))
+			break;
+		/* foo = ({frob(); frob(); frob(); 1;}) */
+		if (__handle_expr_statement_assigns(expr))
+			break;
+		/* foo = (3, 4); */
+		if (handle_comma_assigns(expr))
+			break;
+		if (handle_postop_assigns(expr))
+			break;
+		if (handle__builtin_choose_expr_assigns(expr))
+			break;
+
+		__split_expr(expr->right);
+		if (outside_of_function())
+			__pass_to_client(expr, GLOBAL_ASSIGNMENT_HOOK);
+		else
+			__pass_to_client(expr, ASSIGNMENT_HOOK);
+
+		__fake_struct_member_assignments(expr);
+
+		if (expr->op == '=' && right->type == EXPR_CALL)
+			__pass_to_client(expr, CALL_ASSIGNMENT_HOOK);
+
+		if (get_macro_name(right->pos) &&
+		    get_macro_name(expr->pos) != get_macro_name(right->pos))
+			__pass_to_client(expr, MACRO_ASSIGNMENT_HOOK);
+
+		__pass_to_client(expr, ASSIGNMENT_HOOK_AFTER);
+
+		__split_expr(expr->left);
+		break;
+	}
+	case EXPR_DEREF:
+		expr_set_parent_expr(expr->deref, expr);
+
+		__pass_to_client(expr, DEREF_HOOK);
+		__split_expr(expr->deref);
+		break;
+	case EXPR_SLICE:
+		expr_set_parent_expr(expr->base, expr);
+
+		__split_expr(expr->base);
+		break;
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+		expr_set_parent_expr(expr->cast_expression, expr);
+
+		__pass_to_client(expr, CAST_HOOK);
+		__split_expr(expr->cast_expression);
+		break;
+	case EXPR_SIZEOF:
+		if (expr->cast_expression)
+			__pass_to_client(strip_parens(expr->cast_expression),
+					 SIZEOF_HOOK);
+		break;
+	case EXPR_OFFSETOF:
+	case EXPR_ALIGNOF:
+		evaluate_expression(expr);
+		break;
+	case EXPR_CONDITIONAL:
+	case EXPR_SELECT:
+		expr_set_parent_expr(expr->conditional, expr);
+		expr_set_parent_expr(expr->cond_true, expr);
+		expr_set_parent_expr(expr->cond_false, expr);
+
+		if (known_condition_true(expr->conditional)) {
+			__split_expr(expr->cond_true);
+			break;
+		}
+		if (known_condition_false(expr->conditional)) {
+			__split_expr(expr->cond_false);
+			break;
+		}
+		__pass_to_client(expr, SELECT_HOOK);
+		__split_whole_condition(expr->conditional);
+		__split_expr(expr->cond_true);
+		__push_true_states();
+		__use_false_states();
+		__split_expr(expr->cond_false);
+		__merge_true_states();
+		break;
+	case EXPR_CALL:
+		expr_set_parent_expr(expr->fn, expr);
+
+		if (sym_name_is("__builtin_constant_p", expr->fn))
+			break;
+		if (handle__builtin_choose_expr(expr))
+			break;
+		split_expr_list(expr->args, expr);
+		__split_expr(expr->fn);
+		if (is_inline_func(expr->fn))
+			add_inline_function(expr->fn->symbol);
+		if (inlinable(expr->fn))
+			__inline_call = 1;
+		__process_post_op_stack();
+		__pass_to_client(expr, FUNCTION_CALL_HOOK_BEFORE);
+		__pass_to_client(expr, FUNCTION_CALL_HOOK);
+		__inline_call = 0;
+		if (inlinable(expr->fn)) {
+			parse_inline(expr);
+		}
+		__pass_to_client(expr, CALL_HOOK_AFTER_INLINE);
+		if (is_noreturn_func(expr->fn))
+			nullify_path();
+		handle_builtin_overflow_func(expr);
+		break;
+	case EXPR_INITIALIZER:
+		split_expr_list(expr->expr_list, expr);
+		break;
+	case EXPR_IDENTIFIER:
+		expr_set_parent_expr(expr->ident_expression, expr);
+		__split_expr(expr->ident_expression);
+		break;
+	case EXPR_INDEX:
+		expr_set_parent_expr(expr->idx_expression, expr);
+		__split_expr(expr->idx_expression);
+		break;
+	case EXPR_POS:
+		expr_set_parent_expr(expr->init_expr, expr);
+		__split_expr(expr->init_expr);
+		break;
+	case EXPR_SYMBOL:
+		__pass_to_client(expr, SYM_HOOK);
+		break;
+	case EXPR_STRING:
+		__pass_to_client(expr, STRING_HOOK);
+		break;
+	default:
+		break;
+	};
+	pop_expression(&big_expression_stack);
+}
+
+static int is_forever_loop(struct statement *stmt)
+{
+	struct expression *expr;
+	sval_t sval;
+
+	expr = strip_expr(stmt->iterator_pre_condition);
+	if (!expr)
+		expr = stmt->iterator_post_condition;
+	if (!expr) {
+		/* this is a for(;;) loop... */
+		return 1;
+	}
+
+	if (get_value(expr, &sval) && sval.value != 0)
+		return 1;
+
+	return 0;
+}
+
+static int loop_num;
+static char *get_loop_name(int num)
+{
+	char buf[256];
+
+	snprintf(buf, 255, "-loop%d", num);
+	buf[255] = '\0';
+	return alloc_sname(buf);
+}
+
+/*
+ * Pre Loops are while and for loops.
+ */
+static void handle_pre_loop(struct statement *stmt)
+{
+	int once_through; /* we go through the loop at least once */
+	struct sm_state *extra_sm = NULL;
+	int unchanged = 0;
+	char *loop_name;
+	struct stree *stree = NULL;
+	struct sm_state *sm = NULL;
+
+	loop_name = get_loop_name(loop_num);
+	loop_num++;
+
+	__split_stmt(stmt->iterator_pre_statement);
+	__prev_stmt = stmt->iterator_pre_statement;
+
+	once_through = implied_condition_true(stmt->iterator_pre_condition);
+
+	loop_count++;
+	__push_continues();
+	__push_breaks();
+
+	__merge_gotos(loop_name, NULL);
+
+	extra_sm = __extra_handle_canonical_loops(stmt, &stree);
+	__in_pre_condition++;
+	__pass_to_client(stmt, PRELOOP_HOOK);
+	__split_whole_condition(stmt->iterator_pre_condition);
+	__in_pre_condition--;
+	FOR_EACH_SM(stree, sm) {
+		set_state(sm->owner, sm->name, sm->sym, sm->state);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&stree);
+	if (extra_sm)
+		extra_sm = get_sm_state(extra_sm->owner, extra_sm->name, extra_sm->sym);
+
+	if (option_assume_loops)
+		once_through = 1;
+
+	__split_stmt(stmt->iterator_statement);
+	if (is_forever_loop(stmt)) {
+		__merge_continues();
+		__save_gotos(loop_name, NULL);
+
+		__push_fake_cur_stree();
+		__split_stmt(stmt->iterator_post_statement);
+		stree = __pop_fake_cur_stree();
+
+		__discard_false_states();
+		__use_breaks();
+
+		if (!__path_is_null())
+			__merge_stree_into_cur(stree);
+		free_stree(&stree);
+	} else {
+		__merge_continues();
+		unchanged = __iterator_unchanged(extra_sm);
+		__split_stmt(stmt->iterator_post_statement);
+		__prev_stmt = stmt->iterator_post_statement;
+		__cur_stmt = stmt;
+
+		__save_gotos(loop_name, NULL);
+		__in_pre_condition++;
+		__split_whole_condition(stmt->iterator_pre_condition);
+		__in_pre_condition--;
+		nullify_path();
+		__merge_false_states();
+		if (once_through)
+			__discard_false_states();
+		else
+			__merge_false_states();
+
+		if (extra_sm && unchanged)
+			__extra_pre_loop_hook_after(extra_sm,
+						stmt->iterator_post_statement,
+						stmt->iterator_pre_condition);
+		__merge_breaks();
+	}
+	loop_count--;
+}
+
+/*
+ * Post loops are do {} while();
+ */
+static void handle_post_loop(struct statement *stmt)
+{
+	char *loop_name;
+
+	loop_name = get_loop_name(loop_num);
+	loop_num++;
+	loop_count++;
+
+	__push_continues();
+	__push_breaks();
+	__merge_gotos(loop_name, NULL);
+	__split_stmt(stmt->iterator_statement);
+	__merge_continues();
+	if (!is_zero(stmt->iterator_post_condition))
+		__save_gotos(loop_name, NULL);
+
+	if (is_forever_loop(stmt)) {
+		__use_breaks();
+	} else {
+		__split_whole_condition(stmt->iterator_post_condition);
+		__use_false_states();
+		__merge_breaks();
+	}
+	loop_count--;
+}
+
+static int empty_statement(struct statement *stmt)
+{
+	if (!stmt)
+		return 0;
+	if (stmt->type == STMT_EXPRESSION && !stmt->expression)
+		return 1;
+	return 0;
+}
+
+static int last_stmt_on_same_line(void)
+{
+	struct statement *stmt;
+	int i = 0;
+
+	FOR_EACH_PTR_REVERSE(big_statement_stack, stmt) {
+		if (!i++)
+			continue;
+		if  (stmt->pos.line == get_lineno())
+			return 1;
+		return 0;
+	} END_FOR_EACH_PTR_REVERSE(stmt);
+	return 0;
+}
+
+static void split_asm_constraints(struct expression_list *expr_list)
+{
+	struct expression *expr;
+	int state = 0;
+
+	FOR_EACH_PTR(expr_list, expr) {
+		switch (state) {
+		case 0: /* identifier */
+		case 1: /* constraint */
+			state++;
+			continue;
+		case 2: /* expression */
+			state = 0;
+			__split_expr(expr);
+			continue;
+		}
+	} END_FOR_EACH_PTR(expr);
+}
+
+static int is_case_val(struct statement *stmt, sval_t sval)
+{
+	sval_t case_sval;
+
+	if (stmt->type != STMT_CASE)
+		return 0;
+	if (!stmt->case_expression) {
+		__set_default();
+		return 1;
+	}
+	if (!get_value(stmt->case_expression, &case_sval))
+		return 0;
+	if (case_sval.value == sval.value)
+		return 1;
+	return 0;
+}
+
+static struct range_list *get_case_rl(struct expression *switch_expr,
+				      struct expression *case_expr,
+				      struct expression *case_to)
+{
+	sval_t start, end;
+	struct range_list *rl = NULL;
+	struct symbol *switch_type;
+
+	switch_type = get_type(switch_expr);
+	if (get_value(case_to, &end) && get_value(case_expr, &start)) {
+		start = sval_cast(switch_type, start);
+		end = sval_cast(switch_type, end);
+		add_range(&rl, start, end);
+	} else if (get_value(case_expr, &start)) {
+		start = sval_cast(switch_type, start);
+		add_range(&rl, start, start);
+	}
+
+	return rl;
+}
+
+static void split_known_switch(struct statement *stmt, sval_t sval)
+{
+	struct statement *tmp;
+	struct range_list *rl;
+
+	__split_expr(stmt->switch_expression);
+	sval = sval_cast(get_type(stmt->switch_expression), sval);
+
+	push_expression(&switch_expr_stack, stmt->switch_expression);
+	__save_switch_states(top_expression(switch_expr_stack));
+	nullify_path();
+	__push_default();
+	__push_breaks();
+
+	stmt = stmt->switch_statement;
+
+	__push_scope_hooks();
+	FOR_EACH_PTR(stmt->stmts, tmp) {
+		__smatch_lineno = tmp->pos.line;
+		if (is_case_val(tmp, sval)) {
+			rl = alloc_rl(sval, sval);
+			__merge_switches(top_expression(switch_expr_stack), rl);
+			__pass_case_to_client(top_expression(switch_expr_stack), rl);
+		}
+		if (__path_is_null())
+			continue;
+		__split_stmt(tmp);
+		if (__path_is_null()) {
+			__set_default();
+			goto out;
+		}
+	} END_FOR_EACH_PTR(tmp);
+out:
+	__call_scope_hooks();
+	if (!__pop_default())
+		__merge_switches(top_expression(switch_expr_stack), NULL);
+	__discard_switches();
+	__merge_breaks();
+	pop_expression(&switch_expr_stack);
+}
+
+static void split_case(struct statement *stmt)
+{
+	struct range_list *rl = NULL;
+
+	expr_set_parent_stmt(stmt->case_expression, stmt);
+	expr_set_parent_stmt(stmt->case_to, stmt);
+
+	rl = get_case_rl(top_expression(switch_expr_stack),
+			 stmt->case_expression, stmt->case_to);
+	while (stmt->case_statement->type == STMT_CASE) {
+		struct range_list *tmp;
+
+		tmp = get_case_rl(top_expression(switch_expr_stack),
+				  stmt->case_statement->case_expression,
+				  stmt->case_statement->case_to);
+		if (!tmp)
+			break;
+		rl = rl_union(rl, tmp);
+		if (!stmt->case_expression)
+			__set_default();
+		stmt = stmt->case_statement;
+	}
+
+	__merge_switches(top_expression(switch_expr_stack), rl);
+
+	if (!stmt->case_expression)
+		__set_default();
+	__split_stmt(stmt->case_statement);
+}
+
+int time_parsing_function(void)
+{
+	return ms_since(&fn_start_time) / 1000;
+}
+
+static int taking_too_long(void)
+{
+	if ((ms_since(&outer_fn_start_time) / 1000) > 60 * 5) /* five minutes */
+		return 1;
+	return 0;
+}
+
+static int is_last_stmt(struct statement *cur_stmt)
+{
+	struct symbol *fn;
+	struct statement *stmt;
+
+	if (!cur_func_sym)
+		return 0;
+	fn = get_base_type(cur_func_sym);
+	if (!fn)
+		return 0;
+	stmt = fn->stmt;
+	if (!stmt)
+		stmt = fn->inline_stmt;
+	if (!stmt || stmt->type != STMT_COMPOUND)
+		return 0;
+	stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
+	if (stmt && stmt->type == STMT_LABEL)
+		stmt = stmt->label_statement;
+	if (stmt == cur_stmt)
+		return 1;
+	return 0;
+}
+
+static void handle_backward_goto(struct statement *goto_stmt)
+{
+	const char *goto_name, *label_name;
+	struct statement *func_stmt;
+	struct symbol *base_type = get_base_type(cur_func_sym);
+	struct statement *tmp;
+	int found = 0;
+
+	if (!option_info)
+		return;
+	if (last_goto_statement_handled)
+		return;
+	last_goto_statement_handled = 1;
+
+	if (!goto_stmt->goto_label ||
+	    goto_stmt->goto_label->type != SYM_LABEL ||
+	    !goto_stmt->goto_label->ident)
+		return;
+	goto_name = goto_stmt->goto_label->ident->name;
+
+	func_stmt = base_type->stmt;
+	if (!func_stmt)
+		func_stmt = base_type->inline_stmt;
+	if (!func_stmt)
+		return;
+	if (func_stmt->type != STMT_COMPOUND)
+		return;
+
+	FOR_EACH_PTR(func_stmt->stmts, tmp) {
+		if (!found) {
+			if (tmp->type != STMT_LABEL)
+				continue;
+			if (!tmp->label_identifier ||
+			    tmp->label_identifier->type != SYM_LABEL ||
+			    !tmp->label_identifier->ident)
+				continue;
+			label_name = tmp->label_identifier->ident->name;
+			if (strcmp(goto_name, label_name) != 0)
+				continue;
+			found = 1;
+		}
+		__split_stmt(tmp);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void fake_a_return(void)
+{
+	struct symbol *return_type;
+
+	nullify_path();
+	__unnullify_path();
+
+	return_type = get_real_base_type(cur_func_sym);
+	return_type = get_real_base_type(return_type);
+	if (return_type != &void_ctype) {
+		__pass_to_client(unknown_value_expression(NULL), RETURN_HOOK);
+		nullify_path();
+	}
+}
+
+static void fake_an_empty_default(struct position pos)
+{
+	static struct statement none = {};
+
+	none.pos = pos;
+	none.type = STMT_NONE;
+	__merge_switches(top_expression(switch_expr_stack), NULL);
+	__split_stmt(&none);
+}
+
+static void split_compound(struct statement *stmt)
+{
+	struct statement *prev = NULL;
+	struct statement *cur = NULL;
+	struct statement *next;
+
+	__push_scope_hooks();
+
+	FOR_EACH_PTR(stmt->stmts, next) {
+		/* just set them all ahead of time */
+		stmt_set_parent_stmt(next, stmt);
+
+		if (cur) {
+			__prev_stmt = prev;
+			__next_stmt = next;
+			__cur_stmt = cur;
+			__split_stmt(cur);
+		}
+		prev = cur;
+		cur = next;
+	} END_FOR_EACH_PTR(next);
+	if (cur) {
+		__prev_stmt = prev;
+		__cur_stmt = cur;
+		__next_stmt = NULL;
+		__split_stmt(cur);
+	}
+
+	/*
+	 * For function scope, then delay calling the scope hooks until the
+	 * end of function hooks can run.  I'm not positive this is the right
+	 * thing...
+	 */
+	if (!is_last_stmt(cur))
+		__call_scope_hooks();
+}
+
+/*
+ * This is a hack, work around for detecting empty functions.
+ */
+static int need_delayed_scope_hooks(void)
+{
+	struct symbol *fn = get_base_type(cur_func_sym);
+	struct statement *stmt;
+
+	if (!fn)
+		return 0;
+	stmt = fn->stmt;
+	if (!stmt)
+		stmt = fn->inline_stmt;
+	if (stmt && stmt->type == STMT_COMPOUND)
+		return 1;
+	return 0;
+}
+
+void __split_label_stmt(struct statement *stmt)
+{
+	if (stmt->label_identifier &&
+	    stmt->label_identifier->type == SYM_LABEL &&
+	    stmt->label_identifier->ident) {
+		loop_count |= 0x0800000;
+		__merge_gotos(stmt->label_identifier->ident->name, stmt->label_identifier);
+	}
+}
+
+static void find_asm_gotos(struct statement *stmt)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(stmt->asm_labels, sym) {
+		__save_gotos(sym->ident->name, sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+void __split_stmt(struct statement *stmt)
+{
+	sval_t sval;
+
+	if (!stmt)
+		goto out;
+
+	if (!__in_fake_assign)
+		__silence_warnings_for_stmt = false;
+
+	if (__bail_on_rest_of_function || is_skipped_function())
+		return;
+
+	if (out_of_memory() || taking_too_long()) {
+		struct timeval stop;
+
+		gettimeofday(&stop, NULL);
+
+		__bail_on_rest_of_function = 1;
+		final_pass = 1;
+		sm_perror("Function too hairy.  Giving up. %lu seconds",
+		       stop.tv_sec - fn_start_time.tv_sec);
+		fake_a_return();
+		final_pass = 0;  /* turn off sm_msg() from here */
+		return;
+	}
+
+	add_ptr_list(&big_statement_stack, stmt);
+	free_expression_stack(&big_expression_stack);
+	set_position(stmt->pos);
+	__pass_to_client(stmt, STMT_HOOK);
+
+	switch (stmt->type) {
+	case STMT_DECLARATION:
+		split_declaration(stmt->declaration);
+		break;
+	case STMT_RETURN:
+		expr_set_parent_stmt(stmt->ret_value, stmt);
+
+		__split_expr(stmt->ret_value);
+		__pass_to_client(stmt->ret_value, RETURN_HOOK);
+		__process_post_op_stack();
+		nullify_path();
+		break;
+	case STMT_EXPRESSION:
+		expr_set_parent_stmt(stmt->expression, stmt);
+		expr_set_parent_stmt(stmt->context, stmt);
+
+		__split_expr(stmt->expression);
+		break;
+	case STMT_COMPOUND:
+		split_compound(stmt);
+		break;
+	case STMT_IF:
+		stmt_set_parent_stmt(stmt->if_true, stmt);
+		stmt_set_parent_stmt(stmt->if_false, stmt);
+		expr_set_parent_stmt(stmt->if_conditional, stmt);
+
+		if (known_condition_true(stmt->if_conditional)) {
+			__split_stmt(stmt->if_true);
+			break;
+		}
+		if (known_condition_false(stmt->if_conditional)) {
+			__split_stmt(stmt->if_false);
+			break;
+		}
+		__split_whole_condition(stmt->if_conditional);
+		__split_stmt(stmt->if_true);
+		if (empty_statement(stmt->if_true) &&
+			last_stmt_on_same_line() &&
+			!get_macro_name(stmt->if_true->pos))
+			sm_warning("if();");
+		__push_true_states();
+		__use_false_states();
+		__split_stmt(stmt->if_false);
+		__merge_true_states();
+		break;
+	case STMT_ITERATOR:
+		stmt_set_parent_stmt(stmt->iterator_pre_statement, stmt);
+		stmt_set_parent_stmt(stmt->iterator_statement, stmt);
+		stmt_set_parent_stmt(stmt->iterator_post_statement, stmt);
+		expr_set_parent_stmt(stmt->iterator_pre_condition, stmt);
+		expr_set_parent_stmt(stmt->iterator_post_condition, stmt);
+
+		if (stmt->iterator_pre_condition)
+			handle_pre_loop(stmt);
+		else if (stmt->iterator_post_condition)
+			handle_post_loop(stmt);
+		else {
+			// these are for(;;) type loops.
+			handle_pre_loop(stmt);
+		}
+		break;
+	case STMT_SWITCH:
+		stmt_set_parent_stmt(stmt->switch_statement, stmt);
+		expr_set_parent_stmt(stmt->switch_expression, stmt);
+
+		if (get_value(stmt->switch_expression, &sval)) {
+			split_known_switch(stmt, sval);
+			break;
+		}
+		__split_expr(stmt->switch_expression);
+		push_expression(&switch_expr_stack, stmt->switch_expression);
+		__save_switch_states(top_expression(switch_expr_stack));
+		nullify_path();
+		__push_default();
+		__push_breaks();
+		__split_stmt(stmt->switch_statement);
+		if (!__pop_default() && have_remaining_cases())
+			fake_an_empty_default(stmt->pos);
+		__discard_switches();
+		__merge_breaks();
+		pop_expression(&switch_expr_stack);
+		break;
+	case STMT_CASE:
+		split_case(stmt);
+		break;
+	case STMT_LABEL:
+		__split_label_stmt(stmt);
+		__split_stmt(stmt->label_statement);
+		break;
+	case STMT_GOTO:
+		expr_set_parent_stmt(stmt->goto_expression, stmt);
+
+		__split_expr(stmt->goto_expression);
+		if (stmt->goto_label && stmt->goto_label->type == SYM_NODE) {
+			if (!strcmp(stmt->goto_label->ident->name, "break")) {
+				__process_breaks();
+			} else if (!strcmp(stmt->goto_label->ident->name,
+					   "continue")) {
+				__process_continues();
+			}
+		} else if (stmt->goto_label &&
+			   stmt->goto_label->type == SYM_LABEL &&
+			   stmt->goto_label->ident) {
+			__save_gotos(stmt->goto_label->ident->name, stmt->goto_label);
+		}
+		nullify_path();
+		if (is_last_stmt(stmt))
+			handle_backward_goto(stmt);
+		break;
+	case STMT_NONE:
+		break;
+	case STMT_ASM:
+		expr_set_parent_stmt(stmt->asm_string, stmt);
+
+		find_asm_gotos(stmt);
+		__pass_to_client(stmt, ASM_HOOK);
+		__split_expr(stmt->asm_string);
+		split_asm_constraints(stmt->asm_outputs);
+		split_asm_constraints(stmt->asm_inputs);
+		split_asm_constraints(stmt->asm_clobbers);
+		break;
+	case STMT_CONTEXT:
+		break;
+	case STMT_RANGE:
+		__split_expr(stmt->range_expression);
+		__split_expr(stmt->range_low);
+		__split_expr(stmt->range_high);
+		break;
+	}
+	__pass_to_client(stmt, STMT_HOOK_AFTER);
+out:
+	__process_post_op_stack();
+}
+
+static void split_expr_list(struct expression_list *expr_list, struct expression *parent)
+{
+	struct expression *expr;
+
+	FOR_EACH_PTR(expr_list, expr) {
+		expr_set_parent_expr(expr, parent);
+		__split_expr(expr);
+		__process_post_op_stack();
+	} END_FOR_EACH_PTR(expr);
+}
+
+static void split_sym(struct symbol *sym)
+{
+	if (!sym)
+		return;
+	if (!(sym->namespace & NS_SYMBOL))
+		return;
+
+	__split_stmt(sym->stmt);
+	__split_expr(sym->array_size);
+	split_symlist(sym->arguments);
+	split_symlist(sym->symbol_list);
+	__split_stmt(sym->inline_stmt);
+	split_symlist(sym->inline_symbol_list);
+}
+
+static void split_symlist(struct symbol_list *sym_list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(sym_list, sym) {
+		split_sym(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+typedef void (fake_cb)(struct expression *expr);
+
+static int member_to_number(struct expression *expr, struct ident *member)
+{
+	struct symbol *type, *tmp;
+	char *name;
+	int i;
+
+	if (!member)
+		return -1;
+	name = member->name;
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_STRUCT)
+		return -1;
+
+	i = -1;
+	FOR_EACH_PTR(type->symbol_list, tmp) {
+		i++;
+		if (!tmp->ident)
+			continue;
+		if (strcmp(name, tmp->ident->name) == 0)
+			return i;
+	} END_FOR_EACH_PTR(tmp);
+	return -1;
+}
+
+static struct ident *number_to_member(struct expression *expr, int num)
+{
+	struct symbol *type, *member;
+	int i = 0;
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_STRUCT)
+		return NULL;
+
+	FOR_EACH_PTR(type->symbol_list, member) {
+		if (i == num)
+			return member->ident;
+		i++;
+	} END_FOR_EACH_PTR(member);
+	return NULL;
+}
+
+static void fake_element_assigns_helper(struct expression *array, struct expression_list *expr_list, fake_cb *fake_cb);
+
+static void set_inner_struct_members(struct expression *expr, struct symbol *member)
+{
+	struct expression *edge_member, *assign;
+	struct symbol *base = get_real_base_type(member);
+	struct symbol *tmp;
+
+	if (member->ident)
+		expr = member_expression(expr, '.', member->ident);
+
+	FOR_EACH_PTR(base->symbol_list, tmp) {
+		struct symbol *type;
+
+		type = get_real_base_type(tmp);
+		if (!type)
+			continue;
+
+		edge_member = member_expression(expr, '.', tmp->ident);
+		if (get_extra_state(edge_member))
+			continue;
+
+		if (type->type == SYM_UNION || type->type == SYM_STRUCT) {
+			set_inner_struct_members(expr, tmp);
+			continue;
+		}
+
+		if (!tmp->ident)
+			continue;
+
+		assign = assign_expression(edge_member, '=', zero_expr());
+		__split_expr(assign);
+	} END_FOR_EACH_PTR(tmp);
+
+
+}
+
+static void set_unset_to_zero(struct symbol *type, struct expression *expr)
+{
+	struct symbol *tmp;
+	struct expression *member = NULL;
+	struct expression *assign;
+	int op = '*';
+
+	if (expr->type == EXPR_PREOP && expr->op == '&') {
+		expr = strip_expr(expr->unop);
+		op = '.';
+	}
+
+	FOR_EACH_PTR(type->symbol_list, tmp) {
+		type = get_real_base_type(tmp);
+		if (!type)
+			continue;
+
+		if (tmp->ident) {
+			member = member_expression(expr, op, tmp->ident);
+			if (get_extra_state(member))
+				continue;
+		}
+
+		if (type->type == SYM_UNION || type->type == SYM_STRUCT) {
+			set_inner_struct_members(expr, tmp);
+			continue;
+		}
+		if (type->type == SYM_ARRAY)
+			continue;
+		if (!tmp->ident)
+			continue;
+
+		assign = assign_expression(member, '=', zero_expr());
+		__split_expr(assign);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void fake_member_assigns_helper(struct expression *symbol, struct expression_list *members, fake_cb *fake_cb)
+{
+	struct expression *deref, *assign, *tmp, *right;
+	struct symbol *struct_type, *type;
+	struct ident *member;
+	int member_idx;
+
+	struct_type = get_type(symbol);
+	if (!struct_type ||
+	    (struct_type->type != SYM_STRUCT && struct_type->type != SYM_UNION))
+		return;
+
+	/*
+	 * We're parsing an initializer that could look something like this:
+	 * struct foo foo = {
+	 *	42,
+	 *	.whatever.xxx = 11,
+	 *	.zzz = 12,
+	 * };
+	 *
+	 * So what we have here is a list with 42, .whatever, and .zzz.  We need
+	 * to break it up into left and right sides of the assignments.
+	 *
+	 */
+	member_idx = 0;
+	FOR_EACH_PTR(members, tmp) {
+		deref = NULL;
+		if (tmp->type == EXPR_IDENTIFIER) {
+			member_idx = member_to_number(symbol, tmp->expr_ident);
+			while (tmp->type == EXPR_IDENTIFIER) {
+				member = tmp->expr_ident;
+				tmp = tmp->ident_expression;
+				if (deref)
+					deref = member_expression(deref, '.', member);
+				else
+					deref = member_expression(symbol, '.', member);
+			}
+		} else {
+			member = number_to_member(symbol, member_idx);
+			deref = member_expression(symbol, '.', member);
+		}
+		right = tmp;
+		member_idx++;
+		if (right->type == EXPR_INITIALIZER) {
+			type = get_type(deref);
+			if (type && type->type == SYM_ARRAY)
+				fake_element_assigns_helper(deref, right->expr_list, fake_cb);
+			else
+				fake_member_assigns_helper(deref, right->expr_list, fake_cb);
+		} else {
+			assign = assign_expression(deref, '=', right);
+			fake_cb(assign);
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+	set_unset_to_zero(struct_type, symbol);
+}
+
+static void fake_member_assigns(struct symbol *sym, fake_cb *fake_cb)
+{
+	fake_member_assigns_helper(symbol_expression(sym),
+				   sym->initializer->expr_list, fake_cb);
+}
+
+static void fake_element_assigns_helper(struct expression *array, struct expression_list *expr_list, fake_cb *fake_cb)
+{
+	struct expression *offset, *binop, *assign, *tmp;
+	struct symbol *type;
+	int idx;
+
+	if (ptr_list_size((struct ptr_list *)expr_list) > 1000)
+		return;
+
+	idx = 0;
+	FOR_EACH_PTR(expr_list, tmp) {
+		if (tmp->type == EXPR_INDEX) {
+			if (tmp->idx_from != tmp->idx_to)
+				return;
+			idx = tmp->idx_from;
+			if (!tmp->idx_expression)
+				goto next;
+			tmp = tmp->idx_expression;
+		}
+		offset = value_expr(idx);
+		binop = array_element_expression(array, offset);
+		if (tmp->type == EXPR_INITIALIZER) {
+			type = get_type(binop);
+			if (type && type->type == SYM_ARRAY)
+				fake_element_assigns_helper(binop, tmp->expr_list, fake_cb);
+			else
+				fake_member_assigns_helper(binop, tmp->expr_list, fake_cb);
+		} else {
+			assign = assign_expression(binop, '=', tmp);
+			fake_cb(assign);
+		}
+next:
+		idx++;
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void fake_element_assigns(struct symbol *sym, fake_cb *fake_cb)
+{
+	fake_element_assigns_helper(symbol_expression(sym), sym->initializer->expr_list, fake_cb);
+}
+
+static void fake_assign_expr(struct symbol *sym)
+{
+	struct expression *assign, *symbol;
+
+	symbol = symbol_expression(sym);
+	assign = assign_expression(symbol, '=', sym->initializer);
+	__split_expr(assign);
+}
+
+static void do_initializer_stuff(struct symbol *sym)
+{
+	if (!sym->initializer)
+		return;
+
+	if (sym->initializer->type == EXPR_INITIALIZER) {
+		if (get_real_base_type(sym)->type == SYM_ARRAY)
+			fake_element_assigns(sym, __split_expr);
+		else
+			fake_member_assigns(sym, __split_expr);
+	} else {
+		fake_assign_expr(sym);
+	}
+}
+
+static void split_declaration(struct symbol_list *sym_list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(sym_list, sym) {
+		__pass_to_client(sym, DECLARATION_HOOK);
+		do_initializer_stuff(sym);
+		split_sym(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+static void call_global_assign_hooks(struct expression *assign)
+{
+	__pass_to_client(assign, GLOBAL_ASSIGNMENT_HOOK);
+}
+
+static void fake_global_assign(struct symbol *sym)
+{
+	struct expression *assign, *symbol;
+
+	if (get_real_base_type(sym)->type == SYM_ARRAY) {
+		if (sym->initializer && sym->initializer->type == EXPR_INITIALIZER) {
+			fake_element_assigns(sym, call_global_assign_hooks);
+		} else if (sym->initializer) {
+			symbol = symbol_expression(sym);
+			assign = assign_expression(symbol, '=', sym->initializer);
+			__pass_to_client(assign, GLOBAL_ASSIGNMENT_HOOK);
+		} else {
+			fake_element_assigns_helper(symbol_expression(sym), NULL, call_global_assign_hooks);
+		}
+	} else if (get_real_base_type(sym)->type == SYM_STRUCT) {
+		if (sym->initializer && sym->initializer->type == EXPR_INITIALIZER) {
+			fake_member_assigns(sym, call_global_assign_hooks);
+		} else if (sym->initializer) {
+			symbol = symbol_expression(sym);
+			assign = assign_expression(symbol, '=', sym->initializer);
+			__pass_to_client(assign, GLOBAL_ASSIGNMENT_HOOK);
+		} else {
+			fake_member_assigns_helper(symbol_expression(sym), NULL, call_global_assign_hooks);
+		}
+	} else {
+		symbol = symbol_expression(sym);
+		if (sym->initializer) {
+			assign = assign_expression(symbol, '=', sym->initializer);
+			__split_expr(assign);
+		} else {
+			assign = assign_expression(symbol, '=', zero_expr());
+		}
+		__pass_to_client(assign, GLOBAL_ASSIGNMENT_HOOK);
+	}
+}
+
+static void start_function_definition(struct symbol *sym)
+{
+	__in_function_def = 1;
+	__pass_to_client(sym, FUNC_DEF_HOOK);
+	__in_function_def = 0;
+	__pass_to_client(sym, AFTER_DEF_HOOK);
+
+}
+
+static void split_function(struct symbol *sym)
+{
+	struct symbol *base_type = get_base_type(sym);
+	struct timeval stop;
+
+	if (!base_type->stmt && !base_type->inline_stmt)
+		return;
+
+	gettimeofday(&outer_fn_start_time, NULL);
+	gettimeofday(&fn_start_time, NULL);
+	cur_func_sym = sym;
+	if (sym->ident)
+		cur_func = sym->ident->name;
+	set_position(sym->pos);
+	loop_count = 0;
+	last_goto_statement_handled = 0;
+	sm_debug("new function:  %s\n", cur_func);
+	__stree_id = 0;
+	if (option_two_passes) {
+		__unnullify_path();
+		loop_num = 0;
+		final_pass = 0;
+		start_function_definition(sym);
+		__split_stmt(base_type->stmt);
+		__split_stmt(base_type->inline_stmt);
+		nullify_path();
+	}
+	__unnullify_path();
+	loop_num = 0;
+	final_pass = 1;
+	start_function_definition(sym);
+	__split_stmt(base_type->stmt);
+	__split_stmt(base_type->inline_stmt);
+	__pass_to_client(sym, END_FUNC_HOOK);
+	if (need_delayed_scope_hooks())
+		__call_scope_hooks();
+	__pass_to_client(sym, AFTER_FUNC_HOOK);
+
+	clear_all_states();
+
+	gettimeofday(&stop, NULL);
+	if (option_time && stop.tv_sec - fn_start_time.tv_sec > 2) {
+		final_pass++;
+		sm_msg("func_time: %lu", stop.tv_sec - fn_start_time.tv_sec);
+		final_pass--;
+	}
+	cur_func_sym = NULL;
+	cur_func = NULL;
+	free_data_info_allocs();
+	free_expression_stack(&switch_expr_stack);
+	__free_ptr_list((struct ptr_list **)&big_statement_stack);
+	__bail_on_rest_of_function = 0;
+}
+
+static void save_flow_state(void)
+{
+	__add_ptr_list(&backup, INT_PTR(loop_num << 2), 0);
+	__add_ptr_list(&backup, INT_PTR(loop_count << 2), 0);
+	__add_ptr_list(&backup, INT_PTR(final_pass << 2), 0);
+
+	__add_ptr_list(&backup, big_statement_stack, 0);
+	__add_ptr_list(&backup, big_expression_stack, 0);
+	__add_ptr_list(&backup, big_condition_stack, 0);
+	__add_ptr_list(&backup, switch_expr_stack, 0);
+
+	__add_ptr_list(&backup, cur_func_sym, 0);
+
+	__add_ptr_list(&backup, __prev_stmt, 0);
+	__add_ptr_list(&backup, __cur_stmt, 0);
+	__add_ptr_list(&backup, __next_stmt, 0);
+
+}
+
+static void *pop_backup(void)
+{
+	void *ret;
+
+	ret = last_ptr_list(backup);
+	delete_ptr_list_last(&backup);
+	return ret;
+}
+
+static void restore_flow_state(void)
+{
+	__next_stmt = pop_backup();
+	__cur_stmt = pop_backup();
+	__prev_stmt = pop_backup();
+
+	cur_func_sym = pop_backup();
+	switch_expr_stack = pop_backup();
+	big_condition_stack = pop_backup();
+	big_expression_stack = pop_backup();
+	big_statement_stack = pop_backup();
+	final_pass = PTR_INT(pop_backup()) >> 2;
+	loop_count = PTR_INT(pop_backup()) >> 2;
+	loop_num = PTR_INT(pop_backup()) >> 2;
+}
+
+static void parse_inline(struct expression *call)
+{
+	struct symbol *base_type;
+	char *cur_func_bak = cur_func;  /* not aligned correctly for backup */
+	struct timeval time_backup = fn_start_time;
+	struct expression *orig_inline = __inline_fn;
+	int orig_budget;
+
+	if (out_of_memory() || taking_too_long())
+		return;
+
+	save_flow_state();
+
+	__pass_to_client(call, INLINE_FN_START);
+	final_pass = 0;  /* don't print anything */
+	__inline_fn = call;
+	orig_budget = inline_budget;
+	inline_budget = inline_budget - 5;
+
+	base_type = get_base_type(call->fn->symbol);
+	cur_func_sym = call->fn->symbol;
+	if (call->fn->symbol->ident)
+		cur_func = call->fn->symbol->ident->name;
+	else
+		cur_func = NULL;
+	set_position(call->fn->symbol->pos);
+
+	save_all_states();
+	big_statement_stack = NULL;
+	big_expression_stack = NULL;
+	big_condition_stack = NULL;
+	switch_expr_stack = NULL;
+
+	sm_debug("inline function:  %s\n", cur_func);
+	__unnullify_path();
+	loop_num = 0;
+	loop_count = 0;
+	start_function_definition(call->fn->symbol);
+	__split_stmt(base_type->stmt);
+	__split_stmt(base_type->inline_stmt);
+	__pass_to_client(call->fn->symbol, END_FUNC_HOOK);
+	__pass_to_client(call->fn->symbol, AFTER_FUNC_HOOK);
+
+	free_expression_stack(&switch_expr_stack);
+	__free_ptr_list((struct ptr_list **)&big_statement_stack);
+	nullify_path();
+	free_goto_stack();
+
+	restore_flow_state();
+	fn_start_time = time_backup;
+	cur_func = cur_func_bak;
+
+	restore_all_states();
+	set_position(call->pos);
+	__inline_fn = orig_inline;
+	inline_budget = orig_budget;
+	__pass_to_client(call, INLINE_FN_END);
+}
+
+static struct symbol_list *inlines_called;
+static void add_inline_function(struct symbol *sym)
+{
+	static struct symbol_list *already_added;
+	struct symbol *tmp;
+
+	FOR_EACH_PTR(already_added, tmp) {
+		if (tmp == sym)
+			return;
+	} END_FOR_EACH_PTR(tmp);
+
+	add_ptr_list(&already_added, sym);
+	add_ptr_list(&inlines_called, sym);
+}
+
+static void process_inlines(void)
+{
+	struct symbol *tmp;
+
+	FOR_EACH_PTR(inlines_called, tmp) {
+		split_function(tmp);
+	} END_FOR_EACH_PTR(tmp);
+	free_ptr_list(&inlines_called);
+}
+
+static struct symbol *get_last_scoped_symbol(struct symbol_list *big_list, int use_static)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR_REVERSE(big_list, sym) {
+		if (!sym->scope)
+			continue;
+		if (use_static && sym->ctype.modifiers & MOD_STATIC)
+			return sym;
+		if (!use_static && !(sym->ctype.modifiers & MOD_STATIC))
+			return sym;
+	} END_FOR_EACH_PTR_REVERSE(sym);
+
+	return NULL;
+}
+
+static bool interesting_function(struct symbol *sym)
+{
+	static int prev_stream = -1;
+	static bool prev_answer;
+	const char *filename;
+	int len;
+
+	if (!(sym->ctype.modifiers & MOD_INLINE))
+		return true;
+
+	if (sym->pos.stream == prev_stream)
+		return prev_answer;
+
+	prev_stream = sym->pos.stream;
+	prev_answer = false;
+
+	filename = stream_name(sym->pos.stream);
+	len = strlen(filename);
+	if (len > 0 && filename[len - 1] == 'c')
+		prev_answer = true;
+	return prev_answer;
+}
+
+static void split_inlines_in_scope(struct symbol *sym)
+{
+	struct symbol *base;
+	struct symbol_list *scope_list;
+	int stream;
+
+	scope_list = sym->scope->symbols;
+	stream = sym->pos.stream;
+
+	/* find the last static symbol in the file */
+	FOR_EACH_PTR_REVERSE(scope_list, sym) {
+		if (sym->pos.stream != stream)
+			continue;
+		if (sym->type != SYM_NODE)
+			continue;
+		base = get_base_type(sym);
+		if (!base)
+			continue;
+		if (base->type != SYM_FN)
+			continue;
+		if (!base->inline_stmt)
+			continue;
+		if (!interesting_function(sym))
+			continue;
+		add_inline_function(sym);
+	} END_FOR_EACH_PTR_REVERSE(sym);
+
+	process_inlines();
+}
+
+static void split_inlines(struct symbol_list *sym_list)
+{
+	struct symbol *sym;
+
+	sym = get_last_scoped_symbol(sym_list, 0);
+	if (sym)
+		split_inlines_in_scope(sym);
+	sym = get_last_scoped_symbol(sym_list, 1);
+	if (sym)
+		split_inlines_in_scope(sym);
+}
+
+static struct stree *clone_estates_perm(struct stree *orig)
+{
+	struct stree *ret = NULL;
+	struct sm_state *tmp;
+
+	FOR_EACH_SM(orig, tmp) {
+		set_state_stree_perm(&ret, tmp->owner, tmp->name, tmp->sym, clone_estate_perm(tmp->state));
+	} END_FOR_EACH_SM(tmp);
+
+	return ret;
+}
+
+struct position last_pos;
+static void split_c_file_functions(struct symbol_list *sym_list)
+{
+	struct symbol *sym;
+
+	__unnullify_path();
+	FOR_EACH_PTR(sym_list, sym) {
+		set_position(sym->pos);
+		if (sym->type != SYM_NODE || get_base_type(sym)->type != SYM_FN) {
+			__pass_to_client(sym, BASE_HOOK);
+			fake_global_assign(sym);
+		}
+	} END_FOR_EACH_PTR(sym);
+	global_states = clone_estates_perm(get_all_states_stree(SMATCH_EXTRA));
+	nullify_path();
+
+	FOR_EACH_PTR(sym_list, sym) {
+		set_position(sym->pos);
+		last_pos = sym->pos;
+		if (!interesting_function(sym))
+			continue;
+		if (sym->type == SYM_NODE && get_base_type(sym)->type == SYM_FN) {
+			split_function(sym);
+			process_inlines();
+		}
+		last_pos = sym->pos;
+	} END_FOR_EACH_PTR(sym);
+	split_inlines(sym_list);
+	__pass_to_client(sym_list, END_FILE_HOOK);
+}
+
+static int final_before_fake;
+void init_fake_env(void)
+{
+	if (!in_fake_env)
+		final_before_fake = final_pass;
+	in_fake_env++;
+	__push_fake_cur_stree();
+	final_pass = 0;
+}
+
+void end_fake_env(void)
+{
+	__pop_fake_cur_stree();
+	in_fake_env--;
+	if (!in_fake_env)
+		final_pass = final_before_fake;
+}
+
+static void open_output_files(char *base_file)
+{
+	char buf[256];
+
+	snprintf(buf, sizeof(buf), "%s.smatch", base_file);
+	sm_outfd = fopen(buf, "w");
+	if (!sm_outfd)
+		sm_fatal("Cannot open %s", buf);
+
+	if (!option_info)
+		return;
+
+	snprintf(buf, sizeof(buf), "%s.smatch.sql", base_file);
+	sql_outfd = fopen(buf, "w");
+	if (!sql_outfd)
+		sm_fatal("Error:  Cannot open %s", buf);
+
+	snprintf(buf, sizeof(buf), "%s.smatch.caller_info", base_file);
+	caller_info_fd = fopen(buf, "w");
+	if (!caller_info_fd)
+		sm_fatal("Error:  Cannot open %s", buf);
+}
+
+void smatch(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	struct symbol_list *sym_list;
+	struct timeval stop, start;
+	char *path;
+	int len;
+
+	gettimeofday(&start, NULL);
+
+	sparse_initialize(argc, argv, &filelist);
+	set_valid_ptr_max();
+	alloc_valid_ptr_rl();
+	FOR_EACH_PTR_NOTAG(filelist, base_file) {
+		path = getcwd(NULL, 0);
+		free(full_base_file);
+		if (path) {
+			len = strlen(path) + 1 + strlen(base_file) + 1;
+			full_base_file = malloc(len);
+			snprintf(full_base_file, len, "%s/%s", path, base_file);
+		} else {
+			full_base_file = alloc_string(base_file);
+		}
+		if (option_file_output)
+			open_output_files(base_file);
+		sym_list = sparse_keep_tokens(base_file);
+		split_c_file_functions(sym_list);
+	} END_FOR_EACH_PTR_NOTAG(base_file);
+
+	gettimeofday(&stop, NULL);
+
+	set_position(last_pos);
+	if (option_time)
+		sm_msg("time: %lu", stop.tv_sec - start.tv_sec);
+	if (option_mem)
+		sm_msg("mem: %luKb", get_max_memory());
+}
diff --git a/usr/src/tools/smatch/src/smatch_fn_arg_link.c b/usr/src/tools/smatch/src/smatch_fn_arg_link.c
new file mode 100644
index 0000000000..daff38c424
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_fn_arg_link.c
@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2016 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * What we're trying to do here is record links between function pointers and
+ * function data.  If you have foo->function(foo->data); that's very easy.  But
+ * the problem is maybe when you pass the function and the data as parameters.
+ *
+ */
+
+#include "smatch.h"
+#include <ctype.h>
+
+static int my_id;
+
+static void save_in_fn_ptr_data_link_table(struct expression *fn, struct expression *arg)
+{
+	struct symbol *fn_sym, *arg_sym;
+	struct symbol *type;
+	char *fn_name, *arg_name;
+	int sym_len;
+	char fn_buf[128];
+	char arg_buf[128];
+
+	fn_name = expr_to_var_sym(fn, &fn_sym);
+	arg_name = expr_to_var_sym(arg, &arg_sym);
+	if (!fn_sym || !fn_sym->ident || !arg_sym || !fn_name || !arg_name)
+		goto free;
+	if (fn_sym != arg_sym)
+		goto free;
+
+	sym_len = fn_sym->ident->len;
+
+	/* This is ignoring
+	 * net/mac80211/driver-ops.h:482 drv_sta_remove() FN: local->ops->sta_remove ARG: &local->hw
+	 * but ideally the restriction can be removed later.
+	 */
+	if (strncmp(fn_name, arg_name, sym_len) != 0)
+		goto free;
+
+	type = get_real_base_type(fn_sym);
+	if (!type)
+		goto free;
+	if (type->type != SYM_PTR)
+		goto free;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_STRUCT || !type->ident)
+		goto free;
+
+	snprintf(fn_buf, sizeof(fn_buf), "(struct %s)%s", type->ident->name,
+		 fn_name + sym_len);
+
+	snprintf(arg_buf, sizeof(arg_buf), "(struct %s)%s", type->ident->name,
+		 arg_name + sym_len);
+
+	sql_insert_fn_ptr_data_link(fn_buf, arg_buf);
+free:
+	free_string(arg_name);
+	free_string(fn_name);
+}
+
+static int print_calls_parameter(struct expression *call)
+{
+	struct expression *arg;
+	int fn_param, arg_param;
+	char buf[32];
+
+	fn_param = get_param_num(call->fn);
+	if (fn_param < 0)
+		return 0;
+
+	arg = get_argument_from_call_expr(call->args, 0);
+	if (!arg)
+		return 0;
+
+	arg_param = get_param_num(arg);
+	if (arg_param < 0)
+		return 0;
+
+	snprintf(buf, sizeof(buf), "%d", arg_param);
+	sql_insert_return_implies(FN_ARG_LINK, fn_param, "$", buf);
+	return 0;
+}
+
+static int print_call_is_linked(struct expression *call)
+{
+	struct expression *fn, *tmp;
+	struct expression *arg;
+	struct symbol *fn_sym;
+	struct symbol *arg_sym = NULL;
+	int i;
+
+	fn = strip_expr(call->fn);
+	tmp = get_assigned_expr(fn);
+	if (tmp)
+		fn = tmp;
+	if (fn->type != EXPR_DEREF || !fn->member)
+		return 0;
+
+	fn_sym = expr_to_sym(fn);
+	if (!fn_sym)
+		return 0;
+
+	i = -1;
+	FOR_EACH_PTR(call->args, arg) {
+		i++;
+		tmp = get_assigned_expr(arg);
+		if (tmp)
+			arg = tmp;
+		arg_sym = expr_to_sym(arg);
+		if (arg_sym == fn_sym) {
+			save_in_fn_ptr_data_link_table(fn, arg);
+			return 1;
+		}
+	} END_FOR_EACH_PTR(arg);
+
+	return 0;
+}
+
+static int is_recursive_call(struct expression *call)
+{
+	if (call->fn->type != EXPR_SYMBOL)
+		return 0;
+	if (call->fn->symbol == cur_func_sym)
+		return 1;
+	return 0;
+}
+
+static void check_passes_fn_and_data(struct expression *call, struct expression *fn, char *key, char *value)
+{
+	struct expression *arg;
+	struct expression *tmp;
+	struct symbol *fn_sym, *arg_sym;
+	struct symbol *type;
+	int data_nr;
+	int fn_param, arg_param;
+
+	if (is_recursive_call(call))
+		return;
+
+	type = get_type(fn);
+	if (!type || type->type != SYM_PTR)
+		return;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_FN)
+		return;
+	tmp = get_assigned_expr(fn);
+	if (tmp)
+		fn = tmp;
+
+	if (!isdigit(value[0]))
+		return;
+	data_nr = atoi(value);
+	arg = get_argument_from_call_expr(call->args, data_nr);
+	if (!arg)
+		return;
+	tmp = get_assigned_expr(arg);
+	if (tmp)
+		arg = tmp;
+
+	fn_param = get_param_num(fn);
+	arg_param = get_param_num(arg);
+	if (fn_param >= 0 && arg_param >= 0) {
+		char buf[32];
+
+		snprintf(buf, sizeof(buf), "%d", arg_param);
+		sql_insert_return_implies(FN_ARG_LINK, fn_param, "$", buf);
+		return;
+	}
+
+	fn_sym = expr_to_sym(fn);
+	if (!fn_sym)
+		return;
+	arg_sym = expr_to_sym(arg);
+	if (arg_sym != fn_sym)
+		return;
+	save_in_fn_ptr_data_link_table(fn, tmp);
+}
+
+static void match_call_info(struct expression *call)
+{
+	if (print_calls_parameter(call))
+		return;
+	if (print_call_is_linked(call))
+		return;
+}
+
+void register_fn_arg_link(int id)
+{
+	my_id = id;
+
+	if (!option_info)
+		return;
+
+	add_hook(&match_call_info, FUNCTION_CALL_HOOK);
+	select_return_implies_hook(FN_ARG_LINK, &check_passes_fn_and_data);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_function_hashtable.h b/usr/src/tools/smatch/src/smatch_function_hashtable.h
new file mode 100644
index 0000000000..934ab4fe5f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_function_hashtable.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "smatch.h"
+#include "cwchash/hashtable.h"
+
+static inline unsigned int djb2_hash(void *ky)
+{
+	char *str = (char *)ky;
+	unsigned long hash = 5381;
+	int c;
+
+	while ((c = *str++))
+		hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+
+        return hash;
+}
+
+static inline int equalkeys(void *k1, void *k2)
+{
+	return !strcmp((char *)k1, (char *)k2);
+}
+
+#define DEFINE_FUNCTION_ADD_HOOK(_name, _item_type, _list_type) \
+void add_##_name(struct hashtable *table, const char *look_for, _item_type *value) \
+{                                                               \
+	_list_type *list;                                       \
+	char *key;                                              \
+                                                                \
+	key = alloc_string(look_for);                           \
+	list = search_##_name(table, key);                      \
+	if (!list) {                                            \
+		add_ptr_list(&list, value);                     \
+	} else {                                                \
+		remove_##_name(table, key);                     \
+		add_ptr_list(&list, value);                     \
+	}                                                       \
+	insert_##_name(table, key, list);                       \
+}
+
+static inline struct hashtable *create_function_hashtable(int size)
+{
+	return create_hashtable(size, djb2_hash, equalkeys);
+}
+
+static inline void destroy_function_hashtable(struct hashtable *table)
+{
+	hashtable_destroy(table, 0);
+}
+
+#define DEFINE_FUNCTION_HASHTABLE(_name, _item_type, _list_type)   \
+	DEFINE_HASHTABLE_INSERT(insert_##_name, char, _list_type); \
+	DEFINE_HASHTABLE_SEARCH(search_##_name, char, _list_type); \
+	DEFINE_HASHTABLE_REMOVE(remove_##_name, char, _list_type); \
+	DEFINE_FUNCTION_ADD_HOOK(_name, _item_type, _list_type);
+
+#define DEFINE_FUNCTION_HASHTABLE_STATIC(_name, _item_type, _list_type)   \
+	static DEFINE_HASHTABLE_INSERT(insert_##_name, char, _list_type); \
+	static DEFINE_HASHTABLE_SEARCH(search_##_name, char, _list_type); \
+	static DEFINE_HASHTABLE_REMOVE(remove_##_name, char, _list_type); \
+	static DEFINE_FUNCTION_ADD_HOOK(_name, _item_type, _list_type);
+
+#define DEFINE_STRING_HASHTABLE_STATIC(_name)   \
+	static DEFINE_HASHTABLE_INSERT(insert_##_name, char, int); \
+	static DEFINE_HASHTABLE_SEARCH(search_##_name, char, int); \
+	static struct hashtable *_name
+
+static inline void load_hashtable_helper(const char *file, int (*insert_func)(struct hashtable *, char *, int *), struct hashtable *table)
+{
+	char filename[256];
+	struct token *token;
+	char *name;
+
+	snprintf(filename, sizeof(filename), "%s.%s", option_project_str, file);
+	token = get_tokens_file(filename);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		name = alloc_string(show_ident(token->ident));
+		insert_func(table, name, (void *)1);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+#define load_strings(file, _table) load_hashtable_helper(file, insert_##_table, _table)
diff --git a/usr/src/tools/smatch/src/smatch_function_hooks.c b/usr/src/tools/smatch/src/smatch_function_hooks.c
new file mode 100644
index 0000000000..9aa51c319b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_function_hooks.c
@@ -0,0 +1,1206 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * There are several types of function hooks:
+ * add_function_hook()        - For any time a function is called.
+ * add_function_assign_hook() - foo = the_function().
+ * add_implied_return_hook()  - Calculates the implied return value.
+ * add_macro_assign_hook()    - foo = the_macro().
+ * return_implies_state()     - For when a return value of 1 implies locked
+ *                              and 0 implies unlocked. etc. etc.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+#include "smatch_function_hashtable.h"
+
+struct fcall_back {
+	int type;
+	struct data_range *range;
+	union {
+		func_hook *call_back;
+		implication_hook *ranged;
+		implied_return_hook *implied_return;
+	} u;
+	void *info;
+};
+
+ALLOCATOR(fcall_back, "call backs");
+DECLARE_PTR_LIST(call_back_list, struct fcall_back);
+
+DEFINE_FUNCTION_HASHTABLE_STATIC(callback, struct fcall_back, struct call_back_list);
+static struct hashtable *func_hash;
+
+int __in_fake_parameter_assign;
+
+#define REGULAR_CALL       0
+#define RANGED_CALL        1
+#define ASSIGN_CALL        2
+#define IMPLIED_RETURN     3
+#define MACRO_ASSIGN       4
+#define MACRO_ASSIGN_EXTRA 5
+
+struct return_implies_callback {
+	int type;
+	return_implies_hook *callback;
+};
+ALLOCATOR(return_implies_callback, "return_implies callbacks");
+DECLARE_PTR_LIST(db_implies_list, struct return_implies_callback);
+static struct db_implies_list *db_return_states_list;
+
+typedef void (void_fn)(void);
+DECLARE_PTR_LIST(void_fn_list, void_fn *);
+static struct void_fn_list *return_states_before;
+static struct void_fn_list *return_states_after;
+
+static struct fcall_back *alloc_fcall_back(int type, void *call_back,
+					   void *info)
+{
+	struct fcall_back *cb;
+
+	cb = __alloc_fcall_back(0);
+	cb->type = type;
+	cb->u.call_back = call_back;
+	cb->info = info;
+	return cb;
+}
+
+void add_function_hook(const char *look_for, func_hook *call_back, void *info)
+{
+	struct fcall_back *cb;
+
+	cb = alloc_fcall_back(REGULAR_CALL, call_back, info);
+	add_callback(func_hash, look_for, cb);
+}
+
+void add_function_assign_hook(const char *look_for, func_hook *call_back,
+			      void *info)
+{
+	struct fcall_back *cb;
+
+	cb = alloc_fcall_back(ASSIGN_CALL, call_back, info);
+	add_callback(func_hash, look_for, cb);
+}
+
+void add_implied_return_hook(const char *look_for,
+			     implied_return_hook *call_back,
+			     void *info)
+{
+	struct fcall_back *cb;
+
+	cb = alloc_fcall_back(IMPLIED_RETURN, call_back, info);
+	add_callback(func_hash, look_for, cb);
+}
+
+void add_macro_assign_hook(const char *look_for, func_hook *call_back,
+			void *info)
+{
+	struct fcall_back *cb;
+
+	cb = alloc_fcall_back(MACRO_ASSIGN, call_back, info);
+	add_callback(func_hash, look_for, cb);
+}
+
+void add_macro_assign_hook_extra(const char *look_for, func_hook *call_back,
+			void *info)
+{
+	struct fcall_back *cb;
+
+	cb = alloc_fcall_back(MACRO_ASSIGN_EXTRA, call_back, info);
+	add_callback(func_hash, look_for, cb);
+}
+
+void return_implies_state(const char *look_for, long long start, long long end,
+			 implication_hook *call_back, void *info)
+{
+	struct fcall_back *cb;
+
+	cb = alloc_fcall_back(RANGED_CALL, call_back, info);
+	cb->range = alloc_range_perm(ll_to_sval(start), ll_to_sval(end));
+	add_callback(func_hash, look_for, cb);
+}
+
+void select_return_states_hook(int type, return_implies_hook *callback)
+{
+	struct return_implies_callback *cb = __alloc_return_implies_callback(0);
+
+	cb->type = type;
+	cb->callback = callback;
+	add_ptr_list(&db_return_states_list, cb);
+}
+
+void select_return_states_before(void_fn *fn)
+{
+	void_fn **p = malloc(sizeof(void_fn *));
+	*p = fn;
+	add_ptr_list(&return_states_before, p);
+}
+
+void select_return_states_after(void_fn *fn)
+{
+	void_fn **p = malloc(sizeof(void_fn *));
+	*p = fn;
+	add_ptr_list(&return_states_after, p);
+}
+
+static void call_return_states_before_hooks(void)
+{
+	void_fn **fn;
+
+	FOR_EACH_PTR(return_states_before, fn) {
+		(*fn)();
+	} END_FOR_EACH_PTR(fn);
+}
+
+static void call_return_states_after_hooks(struct expression *expr)
+{
+	void_fn **fn;
+
+	FOR_EACH_PTR(return_states_after, fn) {
+		(*fn)();
+	} END_FOR_EACH_PTR(fn);
+	__pass_to_client(expr, FUNCTION_CALL_HOOK_AFTER_DB);
+}
+
+static int call_call_backs(struct call_back_list *list, int type,
+			    const char *fn, struct expression *expr)
+{
+	struct fcall_back *tmp;
+	int handled = 0;
+
+	FOR_EACH_PTR(list, tmp) {
+		if (tmp->type == type) {
+			(tmp->u.call_back)(fn, expr, tmp->info);
+			handled = 1;
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+	return handled;
+}
+
+static void call_ranged_call_backs(struct call_back_list *list,
+				const char *fn, struct expression *call_expr,
+				struct expression *assign_expr)
+{
+	struct fcall_back *tmp;
+
+	FOR_EACH_PTR(list, tmp) {
+		(tmp->u.ranged)(fn, call_expr, assign_expr, tmp->info);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static struct call_back_list *get_same_ranged_call_backs(struct call_back_list *list,
+						struct data_range *drange)
+{
+	struct call_back_list *ret = NULL;
+	struct fcall_back *tmp;
+
+	FOR_EACH_PTR(list, tmp) {
+		if (tmp->type != RANGED_CALL)
+			continue;
+		if (ranges_equiv(tmp->range, drange))
+			add_ptr_list(&ret, tmp);
+	} END_FOR_EACH_PTR(tmp);
+	return ret;
+}
+
+static int in_list_exact_sval(struct range_list *list, struct data_range *drange)
+{
+	struct data_range *tmp;
+
+	FOR_EACH_PTR(list, tmp) {
+		if (ranges_equiv(tmp, drange))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static int assign_ranged_funcs(const char *fn, struct expression *expr,
+				 struct call_back_list *call_backs)
+{
+	struct fcall_back *tmp;
+	struct sm_state *sm;
+	char *var_name;
+	struct symbol *sym;
+	struct smatch_state *estate;
+	struct stree *tmp_stree;
+	struct stree *final_states = NULL;
+	struct range_list *handled_ranges = NULL;
+	struct call_back_list *same_range_call_backs = NULL;
+	int handled = 0;
+
+	if (!call_backs)
+		return 0;
+
+	var_name = expr_to_var_sym(expr->left, &sym);
+	if (!var_name || !sym)
+		goto free;
+
+	FOR_EACH_PTR(call_backs, tmp) {
+		if (tmp->type != RANGED_CALL)
+			continue;
+
+		if (in_list_exact_sval(handled_ranges, tmp->range))
+			continue;
+		__push_fake_cur_stree();
+		tack_on(&handled_ranges, tmp->range);
+
+		same_range_call_backs = get_same_ranged_call_backs(call_backs, tmp->range);
+		call_ranged_call_backs(same_range_call_backs, fn, expr->right, expr);
+		__free_ptr_list((struct ptr_list **)&same_range_call_backs);
+
+		estate = alloc_estate_range(tmp->range->min, tmp->range->max);
+		set_extra_mod(var_name, sym, expr->left, estate);
+
+		tmp_stree = __pop_fake_cur_stree();
+		merge_fake_stree(&final_states, tmp_stree);
+		free_stree(&tmp_stree);
+		handled = 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	FOR_EACH_SM(final_states, sm) {
+		__set_sm(sm);
+	} END_FOR_EACH_SM(sm);
+
+	free_stree(&final_states);
+free:
+	free_string(var_name);
+	return handled;
+}
+
+static void call_implies_callbacks(int comparison, struct expression *expr, sval_t sval, int left, struct stree **implied_true, struct stree **implied_false)
+{
+	struct call_back_list *call_backs;
+	struct fcall_back *tmp;
+	const char *fn;
+	struct data_range *value_range;
+	struct stree *true_states = NULL;
+	struct stree *false_states = NULL;
+	struct stree *tmp_stree;
+
+	*implied_true = NULL;
+	*implied_false = NULL;
+	if (expr->fn->type != EXPR_SYMBOL || !expr->fn->symbol)
+		return;
+	fn = expr->fn->symbol->ident->name;
+	call_backs = search_callback(func_hash, (char *)expr->fn->symbol->ident->name);
+	if (!call_backs)
+		return;
+	value_range = alloc_range(sval, sval);
+
+	/* set true states */
+	__push_fake_cur_stree();
+	FOR_EACH_PTR(call_backs, tmp) {
+		if (tmp->type != RANGED_CALL)
+			continue;
+		if (!true_comparison_range_LR(comparison, tmp->range, value_range, left))
+			continue;
+		(tmp->u.ranged)(fn, expr, NULL, tmp->info);
+	} END_FOR_EACH_PTR(tmp);
+	tmp_stree = __pop_fake_cur_stree();
+	merge_fake_stree(&true_states, tmp_stree);
+	free_stree(&tmp_stree);
+
+	/* set false states */
+	__push_fake_cur_stree();
+	FOR_EACH_PTR(call_backs, tmp) {
+		if (tmp->type != RANGED_CALL)
+			continue;
+		if (!false_comparison_range_LR(comparison, tmp->range, value_range, left))
+			continue;
+		(tmp->u.ranged)(fn, expr, NULL, tmp->info);
+	} END_FOR_EACH_PTR(tmp);
+	tmp_stree = __pop_fake_cur_stree();
+	merge_fake_stree(&false_states, tmp_stree);
+	free_stree(&tmp_stree);
+
+	*implied_true = true_states;
+	*implied_false = false_states;
+}
+
+struct db_callback_info {
+	int true_side;
+	int comparison;
+	struct expression *expr;
+	struct range_list *rl;
+	int left;
+	struct stree *stree;
+	struct db_implies_list *callbacks;
+	int prev_return_id;
+	int cull;
+	int has_states;
+	char *ret_str;
+	struct smatch_state *ret_state;
+	struct expression *var_expr;
+	int handled;
+};
+
+static void store_return_state(struct db_callback_info *db_info, const char *ret_str, struct smatch_state *state)
+{
+	db_info->ret_str = alloc_sname(ret_str),
+	db_info->ret_state = state;
+}
+
+static bool fake_a_param_assignment(struct expression *expr, const char *return_str)
+{
+	struct expression *arg, *left, *right, *fake_assign;
+	char *p;
+	int param;
+	char buf[256];
+	char *str;
+
+	if (expr->type != EXPR_ASSIGNMENT || expr->op != '=')
+		return false;
+	left = expr->left;
+	right = expr->right;
+
+	while (right->type == EXPR_ASSIGNMENT)
+		right = strip_expr(right->right);
+	if (!right || right->type != EXPR_CALL)
+		return false;
+
+	p = strchr(return_str, '[');
+	if (!p)
+		return false;
+
+	p++;
+	if (p[0] == '=' && p[1] == '=')
+		p += 2;
+	if (p[0] != '$')
+		return false;
+
+	snprintf(buf, sizeof(buf), "%s", p);
+
+	p = buf;
+	p += 1;
+	param = strtol(p, &p, 10);
+
+	p = strchr(p, ']');
+	if (!p || *p != ']')
+		return false;
+	*p = '\0';
+
+	arg = get_argument_from_call_expr(right->args, param);
+	if (!arg)
+		return false;
+	/*
+	 * This is a sanity check to prevent side effects from evaluating stuff
+	 * twice.
+	 */
+	str = expr_to_chunk_sym_vsl(arg, NULL, NULL);
+	if (!str)
+		return false;
+	free_string(str);
+
+	right = gen_expression_from_key(arg, buf);
+	if (!right)  /* Mostly fails for binops like [$0 + 4032] */
+		return false;
+	fake_assign = assign_expression(left, '=', right);
+	__in_fake_parameter_assign++;
+	__split_expr(fake_assign);
+	__in_fake_parameter_assign--;
+	return true;
+}
+
+static void set_return_state(struct expression *expr, struct db_callback_info *db_info)
+{
+	struct smatch_state *state;
+
+	if (!db_info->ret_state)
+		return;
+
+	state = alloc_estate_rl(cast_rl(get_type(expr), clone_rl(estate_rl(db_info->ret_state))));
+	set_extra_expr_mod(expr, state);
+	db_info->ret_state = NULL;
+	fake_a_param_assignment(db_info->expr, db_info->ret_str);
+	db_info->ret_str = NULL;
+}
+
+static void handle_ret_equals_param(char *ret_string, struct range_list *rl, struct expression *call)
+{
+	char *str;
+	long long param;
+	struct expression *arg;
+	struct range_list *orig;
+
+	str = strstr(ret_string, "==$");
+	if (!str)
+		return;
+	str += 3;
+	param = strtoll(str, NULL, 10);
+	arg = get_argument_from_call_expr(call->args, param);
+	if (!arg)
+		return;
+	get_absolute_rl(arg, &orig);
+	rl = rl_intersection(orig, rl);
+	if (!rl)
+		return;
+	set_extra_expr_nomod(arg, alloc_estate_rl(rl));
+}
+
+static int impossible_limit(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+	struct smatch_state *state;
+	struct range_list *passed;
+	struct range_list *limit;
+	struct symbol *compare_type;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return 0;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return 0;
+
+	if (strcmp(key, "$") == 0) {
+		if (!get_implied_rl(arg, &passed))
+			return 0;
+
+		compare_type = get_arg_type(expr->fn, param);
+	} else {
+		char *name;
+		struct symbol *sym;
+
+		name = get_variable_from_key(arg, key, &sym);
+		if (!name || !sym)
+			return 0;
+
+		state = get_state(SMATCH_EXTRA, name, sym);
+		if (!state) {
+			free_string(name);
+			return 0;
+		}
+		passed = estate_rl(state);
+		if (!passed || is_whole_rl(passed)) {
+			free_string(name);
+			return 0;
+		}
+
+		compare_type = get_member_type_from_key(arg, key);
+	}
+
+	passed = cast_rl(compare_type, passed);
+	call_results_to_rl(expr, compare_type, value, &limit);
+	if (!limit || is_whole_rl(limit))
+		return 0;
+	if (possibly_true_rl(passed, SPECIAL_EQUAL, limit))
+		return 0;
+	if (option_debug || local_debug)
+		sm_msg("impossible: %d '%s' limit '%s' == '%s'", param, key, show_rl(passed), value);
+	return 1;
+}
+
+static int is_impossible_data(int type, struct expression *expr, int param, char *key, char *value)
+{
+	if (type == PARAM_LIMIT && impossible_limit(expr, param, key, value))
+		return 1;
+	if (type == COMPARE_LIMIT && param_compare_limit_is_impossible(expr, param, key, value)) {
+		if (local_debug)
+			sm_msg("param_compare_limit_is_impossible: %d %s %s", param, key, value);
+		return 1;
+	}
+	return 0;
+}
+
+static int func_type_mismatch(struct expression *expr, const char *value)
+{
+	struct symbol *type;
+
+	/* This makes faking returns easier */
+	if (!value || value[0] == '\0')
+		return 0;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+
+	/*
+	 * Short cut:  We only care about function pointers that are struct
+	 * members.
+	 *
+	 */
+	if (expr->fn->type == EXPR_SYMBOL)
+		return 0;
+
+	type = get_type(expr->fn);
+	if (!type)
+		return 0;
+	if (type->type == SYM_PTR)
+		type = get_real_base_type(type);
+
+	if (strcmp(type_to_str(type), value) == 0)
+		return 0;
+
+	return 1;
+}
+
+static int db_compare_callback(void *_info, int argc, char **argv, char **azColName)
+{
+	struct db_callback_info *db_info = _info;
+	struct range_list *var_rl = db_info->rl;
+	struct range_list *ret_range;
+	int type, param;
+	char *key, *value;
+	struct return_implies_callback *tmp;
+	struct stree *stree;
+	int return_id;
+	int comparison;
+
+	if (argc != 6)
+		return 0;
+
+	return_id = atoi(argv[0]);
+	type = atoi(argv[2]);
+	param = atoi(argv[3]);
+	key = argv[4];
+	value = argv[5];
+
+	db_info->has_states = 1;
+	if (db_info->prev_return_id != -1 && type == INTERNAL) {
+		set_return_state(db_info->var_expr, db_info);
+		stree = __pop_fake_cur_stree();
+
+		if (!db_info->cull)
+			merge_fake_stree(&db_info->stree, stree);
+		free_stree(&stree);
+		__push_fake_cur_stree();
+		db_info->cull = 0;
+	}
+	db_info->prev_return_id = return_id;
+
+	if (type == INTERNAL && func_type_mismatch(db_info->expr, value))
+		db_info->cull = 1;
+	if (db_info->cull)
+		return 0;
+	if (type == CULL_PATH) {
+		db_info->cull = 1;
+		return 0;
+	}
+
+	if (is_impossible_data(type, db_info->expr, param, key, value)) {
+		db_info->cull = 1;
+		return 0;
+	}
+
+	call_results_to_rl(db_info->expr, get_type(strip_expr(db_info->expr)), argv[1], &ret_range);
+	ret_range = cast_rl(get_type(db_info->expr), ret_range);
+	if (!ret_range)
+		ret_range = alloc_whole_rl(get_type(db_info->expr));
+
+	comparison = db_info->comparison;
+	if (db_info->left)
+		comparison = flip_comparison(comparison);
+
+	if (db_info->true_side) {
+		if (!possibly_true_rl(var_rl, comparison, ret_range))
+			return 0;
+		if (type == PARAM_LIMIT)
+			param_limit_implications(db_info->expr, param, key, value);
+		filter_by_comparison(&var_rl, comparison, ret_range);
+		filter_by_comparison(&ret_range, flip_comparison(comparison), var_rl);
+	} else {
+		if (!possibly_false_rl(var_rl, comparison, ret_range))
+			return 0;
+		if (type == PARAM_LIMIT)
+			param_limit_implications(db_info->expr, param, key, value);
+		filter_by_comparison(&var_rl, negate_comparison(comparison), ret_range);
+		filter_by_comparison(&ret_range, flip_comparison(negate_comparison(comparison)), var_rl);
+	}
+
+	handle_ret_equals_param(argv[1], ret_range, db_info->expr);
+
+	if (type == INTERNAL) {
+		set_state(-1, "unnull_path", NULL, &true_state);
+		__add_return_comparison(strip_expr(db_info->expr), argv[1]);
+		__add_return_to_param_mapping(db_info->expr, argv[1]);
+		store_return_state(db_info, argv[1], alloc_estate_rl(clone_rl(var_rl)));
+	}
+
+	FOR_EACH_PTR(db_info->callbacks, tmp) {
+		if (tmp->type == type)
+			tmp->callback(db_info->expr, param, key, value);
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static void compare_db_return_states_callbacks(struct expression *left, int comparison, struct expression *right, struct stree *implied_true, struct stree *implied_false)
+{
+	struct stree *orig_states;
+	struct stree *stree;
+	struct stree *true_states;
+	struct stree *false_states;
+	struct sm_state *sm;
+	struct db_callback_info db_info = {};
+	struct expression *var_expr;
+	struct expression *call_expr;
+	struct range_list *rl;
+	int call_on_left;
+
+	orig_states = clone_stree(__get_cur_stree());
+
+	/* legacy cruft.  need to fix call_implies_callbacks(). */
+	call_on_left = 1;
+	call_expr = left;
+	var_expr = right;
+	if (left->type != EXPR_CALL) {
+		call_on_left = 0;
+		call_expr = right;
+		var_expr = left;
+	}
+
+	get_absolute_rl(var_expr, &rl);
+
+	db_info.comparison = comparison;
+	db_info.expr = call_expr;
+	db_info.rl = rl;
+	db_info.left = call_on_left;
+	db_info.callbacks = db_return_states_list;
+	db_info.var_expr = var_expr;
+
+	call_return_states_before_hooks();
+
+	db_info.true_side = 1;
+	db_info.stree = NULL;
+	db_info.prev_return_id = -1;
+	__push_fake_cur_stree();
+	sql_select_return_states("return_id, return, type, parameter, key, value",
+				 call_expr, db_compare_callback, &db_info);
+	set_return_state(db_info.var_expr, &db_info);
+	stree = __pop_fake_cur_stree();
+	if (!db_info.cull) {
+		set_return_state(db_info.var_expr, &db_info);
+		merge_fake_stree(&db_info.stree, stree);
+	}
+	free_stree(&stree);
+	true_states = db_info.stree;
+	if (!true_states && db_info.has_states) {
+		__push_fake_cur_stree();
+		set_path_impossible();
+		true_states = __pop_fake_cur_stree();
+	}
+
+	nullify_path();
+	__unnullify_path();
+	FOR_EACH_SM(orig_states, sm) {
+		__set_sm_cur_stree(sm);
+	} END_FOR_EACH_SM(sm);
+
+	db_info.true_side = 0;
+	db_info.stree = NULL;
+	db_info.prev_return_id = -1;
+	db_info.cull = 0;
+	__push_fake_cur_stree();
+	sql_select_return_states("return_id, return, type, parameter, key, value", call_expr,
+			db_compare_callback, &db_info);
+	stree = __pop_fake_cur_stree();
+	if (!db_info.cull) {
+		set_return_state(db_info.var_expr, &db_info);
+		merge_fake_stree(&db_info.stree, stree);
+	}
+	free_stree(&stree);
+	false_states = db_info.stree;
+	if (!false_states && db_info.has_states) {
+		__push_fake_cur_stree();
+		set_path_impossible();
+		false_states = __pop_fake_cur_stree();
+	}
+
+	nullify_path();
+	__unnullify_path();
+	FOR_EACH_SM(orig_states, sm) {
+		__set_sm_cur_stree(sm);
+	} END_FOR_EACH_SM(sm);
+
+	free_stree(&orig_states);
+
+	FOR_EACH_SM(true_states, sm) {
+		__set_true_false_sm(sm, NULL);
+	} END_FOR_EACH_SM(sm);
+	FOR_EACH_SM(false_states, sm) {
+		__set_true_false_sm(NULL, sm);
+	} END_FOR_EACH_SM(sm);
+
+	free_stree(&true_states);
+	free_stree(&false_states);
+
+	call_return_states_after_hooks(call_expr);
+
+	FOR_EACH_SM(implied_true, sm) {
+		__set_true_false_sm(sm, NULL);
+	} END_FOR_EACH_SM(sm);
+	FOR_EACH_SM(implied_false, sm) {
+		__set_true_false_sm(NULL, sm);
+	} END_FOR_EACH_SM(sm);
+}
+
+void function_comparison(struct expression *left, int comparison, struct expression *right)
+{
+	struct expression *var_expr;
+	struct expression *call_expr;
+	struct stree *implied_true = NULL;
+	struct stree *implied_false = NULL;
+	struct range_list *rl;
+	sval_t sval;
+	int call_on_left;
+
+	if (unreachable())
+		return;
+
+	/* legacy cruft.  need to fix call_implies_callbacks(). */
+	call_on_left = 1;
+	call_expr = left;
+	var_expr = right;
+	if (left->type != EXPR_CALL) {
+		call_on_left = 0;
+		call_expr = right;
+		var_expr = left;
+	}
+
+	get_absolute_rl(var_expr, &rl);
+
+	if (rl_to_sval(rl, &sval))
+		call_implies_callbacks(comparison, call_expr, sval, call_on_left, &implied_true, &implied_false);
+
+	compare_db_return_states_callbacks(left, comparison, right, implied_true, implied_false);
+	free_stree(&implied_true);
+	free_stree(&implied_false);
+}
+
+static void call_ranged_return_hooks(struct db_callback_info *db_info)
+{
+	struct call_back_list *call_backs;
+	struct expression *expr;
+	struct fcall_back *tmp;
+	char *fn;
+
+	expr = strip_expr(db_info->expr);
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL ||
+	    expr->fn->type != EXPR_SYMBOL)
+		return;
+
+	fn = expr->fn->symbol_name->name;
+
+	call_backs = search_callback(func_hash, fn);
+	FOR_EACH_PTR(call_backs, tmp) {
+		struct range_list *range_rl = NULL;
+
+		if (tmp->type != RANGED_CALL)
+			continue;
+		add_range(&range_rl, tmp->range->min, tmp->range->max);
+		range_rl = cast_rl(estate_type(db_info->ret_state), range_rl);
+		if (possibly_true_rl(range_rl, SPECIAL_EQUAL, estate_rl(db_info->ret_state))) {
+			if (!possibly_true_rl(rl_invert(range_rl), SPECIAL_EQUAL, estate_rl(db_info->ret_state)))
+				(tmp->u.ranged)(fn, expr, db_info->expr, tmp->info);
+			else
+				db_info->handled = -1;
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static int db_assign_return_states_callback(void *_info, int argc, char **argv, char **azColName)
+{
+	struct db_callback_info *db_info = _info;
+	struct range_list *ret_range;
+	int type, param;
+	char *key, *value;
+	struct return_implies_callback *tmp;
+	struct stree *stree;
+	int return_id;
+
+	if (argc != 6)
+		return 0;
+
+	return_id = atoi(argv[0]);
+	type = atoi(argv[2]);
+	param = atoi(argv[3]);
+	key = argv[4];
+	value = argv[5];
+
+	if (db_info->prev_return_id != -1 && type == INTERNAL) {
+		call_ranged_return_hooks(db_info);
+		set_return_state(db_info->expr->left, db_info);
+		stree = __pop_fake_cur_stree();
+		if (!db_info->cull)
+			merge_fake_stree(&db_info->stree, stree);
+		free_stree(&stree);
+		__push_fake_cur_stree();
+		db_info->cull = 0;
+	}
+	db_info->prev_return_id = return_id;
+
+	if (type == INTERNAL && func_type_mismatch(db_info->expr, value))
+		db_info->cull = 1;
+	if (db_info->cull)
+		return 0;
+	if (type == CULL_PATH) {
+		db_info->cull = 1;
+		return 0;
+	}
+	if (is_impossible_data(type, db_info->expr, param, key, value)) {
+		db_info->cull = 1;
+		return 0;
+	}
+
+	if (type == PARAM_LIMIT)
+		param_limit_implications(db_info->expr, param, key, value);
+
+	db_info->handled = 1;
+	call_results_to_rl(db_info->expr->right, get_type(strip_expr(db_info->expr->right)), argv[1], &ret_range);
+	if (!ret_range)
+		ret_range = alloc_whole_rl(get_type(strip_expr(db_info->expr->right)));
+	ret_range = cast_rl(get_type(db_info->expr->right), ret_range);
+
+	if (type == INTERNAL) {
+		set_state(-1, "unnull_path", NULL, &true_state);
+		__add_return_comparison(strip_expr(db_info->expr->right), argv[1]);
+		__add_comparison_info(db_info->expr->left, strip_expr(db_info->expr->right), argv[1]);
+		__add_return_to_param_mapping(db_info->expr, argv[1]);
+		store_return_state(db_info, argv[1], alloc_estate_rl(ret_range));
+	}
+
+	FOR_EACH_PTR(db_return_states_list, tmp) {
+		if (tmp->type == type)
+			tmp->callback(db_info->expr, param, key, value);
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static int db_return_states_assign(struct expression *expr)
+{
+	struct expression *right;
+	struct sm_state *sm;
+	struct stree *stree;
+	struct db_callback_info db_info = {};
+
+	right = strip_expr(expr->right);
+
+	db_info.prev_return_id = -1;
+	db_info.expr = expr;
+	db_info.stree = NULL;
+	db_info.handled = 0;
+
+	call_return_states_before_hooks();
+
+	__push_fake_cur_stree();
+	sql_select_return_states("return_id, return, type, parameter, key, value",
+			right, db_assign_return_states_callback, &db_info);
+	if (option_debug) {
+		sm_msg("%s return_id %d return_ranges %s",
+			db_info.cull ? "culled" : "merging",
+			db_info.prev_return_id,
+			db_info.ret_state ? db_info.ret_state->name : "'<empty>'");
+	}
+	if (db_info.handled)
+		call_ranged_return_hooks(&db_info);
+	set_return_state(db_info.expr->left, &db_info);
+	stree = __pop_fake_cur_stree();
+	if (!db_info.cull)
+		merge_fake_stree(&db_info.stree, stree);
+	free_stree(&stree);
+
+	if (!db_info.stree && db_info.cull) { /* this means we culled everything */
+		set_extra_expr_mod(expr->left, alloc_estate_whole(get_type(expr->left)));
+		set_path_impossible();
+	}
+	FOR_EACH_SM(db_info.stree, sm) {
+		__set_sm(sm);
+	} END_FOR_EACH_SM(sm);
+
+	free_stree(&db_info.stree);
+	call_return_states_after_hooks(right);
+
+	return db_info.handled;
+}
+
+static int handle_implied_return(struct expression *expr)
+{
+	struct range_list *rl;
+
+	if (!get_implied_return(expr->right, &rl))
+		return 0;
+	rl = cast_rl(get_type(expr->left), rl);
+	set_extra_expr_mod(expr->left, alloc_estate_rl(rl));
+	return 1;
+}
+
+static void match_assign_call(struct expression *expr)
+{
+	struct call_back_list *call_backs;
+	const char *fn;
+	struct expression *right;
+	int handled = 0;
+	struct range_list *rl;
+
+	if (expr->op != '=')
+		return;
+
+	right = strip_expr(expr->right);
+	if (right->fn->type != EXPR_SYMBOL || !right->fn->symbol) {
+		handled |= db_return_states_assign(expr);
+		if (!handled)
+			goto assigned_unknown;
+		return;
+	}
+	if (is_fake_call(right)) {
+		set_extra_expr_mod(expr->left, alloc_estate_whole(get_type(expr->left)));
+		return;
+	}
+
+	fn = right->fn->symbol->ident->name;
+	call_backs = search_callback(func_hash, (char *)fn);
+
+	/*
+	 * The ordering here is sort of important.
+	 * One example, of how this matters is that when we do:
+	 *
+	 * 	len = strlen(str);
+	 *
+	 * That is handled by smatch_common_functions.c and smatch_strlen.c.
+	 * They use implied_return and function_assign_hook respectively.
+	 * We want to get the implied return first before we do the function
+	 * assignment hook otherwise we end up writing the wrong thing for len
+	 * in smatch_extra.c because we assume that it already holds the
+	 * strlen() when we haven't set it yet.
+	 */
+
+	if (db_return_states_assign(expr) == 1)
+		handled = 1;
+	else
+		handled = assign_ranged_funcs(fn, expr, call_backs);
+	handled |= handle_implied_return(expr);
+
+
+	call_call_backs(call_backs, ASSIGN_CALL, fn, expr);
+
+	if (handled)
+		return;
+
+assigned_unknown:
+	get_absolute_rl(expr->right, &rl);
+	rl = cast_rl(get_type(expr->left), rl);
+	set_extra_expr_mod(expr->left, alloc_estate_rl(rl));
+}
+
+static int db_return_states_callback(void *_info, int argc, char **argv, char **azColName)
+{
+	struct db_callback_info *db_info = _info;
+	struct range_list *ret_range;
+	int type, param;
+	char *key, *value;
+	struct return_implies_callback *tmp;
+	struct stree *stree;
+	int return_id;
+	char buf[64];
+
+	if (argc != 6)
+		return 0;
+
+	return_id = atoi(argv[0]);
+	type = atoi(argv[2]);
+	param = atoi(argv[3]);
+	key = argv[4];
+	value = argv[5];
+
+	if (db_info->prev_return_id != -1 && type == INTERNAL) {
+		stree = __pop_fake_cur_stree();
+		if (!db_info->cull)
+			merge_fake_stree(&db_info->stree, stree);
+		free_stree(&stree);
+		__push_fake_cur_stree();
+		__unnullify_path();
+		db_info->cull = 0;
+	}
+	db_info->prev_return_id = return_id;
+
+	if (type == INTERNAL && func_type_mismatch(db_info->expr, value))
+		db_info->cull = 1;
+	if (db_info->cull)
+		return 0;
+	if (type == CULL_PATH) {
+		db_info->cull = 1;
+		return 0;
+	}
+	if (is_impossible_data(type, db_info->expr, param, key, value)) {
+		db_info->cull = 1;
+		return 0;
+	}
+
+	if (type == PARAM_LIMIT)
+		param_limit_implications(db_info->expr, param, key, value);
+
+	call_results_to_rl(db_info->expr, get_type(strip_expr(db_info->expr)), argv[1], &ret_range);
+	ret_range = cast_rl(get_type(db_info->expr), ret_range);
+
+	if (type == INTERNAL) {
+		set_state(-1, "unnull_path", NULL, &true_state);
+		__add_return_comparison(strip_expr(db_info->expr), argv[1]);
+		__add_return_to_param_mapping(db_info->expr, argv[1]);
+	}
+
+
+	FOR_EACH_PTR(db_return_states_list, tmp) {
+		if (tmp->type == type)
+			tmp->callback(db_info->expr, param, key, value);
+	} END_FOR_EACH_PTR(tmp);
+
+	/*
+	 * We want to store the return values so that we can split the strees
+	 * in smatch_db.c.  This uses set_state() directly because it's not a
+	 * real smatch_extra state.
+	 */
+	snprintf(buf, sizeof(buf), "return %p", db_info->expr);
+	set_state(SMATCH_EXTRA, buf, NULL, alloc_estate_rl(ret_range));
+
+	return 0;
+}
+
+static void db_return_states(struct expression *expr)
+{
+	struct sm_state *sm;
+	struct stree *stree;
+	struct db_callback_info db_info = {};
+
+	if (!__get_cur_stree())  /* no return functions */
+		return;
+
+	db_info.prev_return_id = -1;
+	db_info.expr = expr;
+	db_info.stree = NULL;
+
+	call_return_states_before_hooks();
+
+	__push_fake_cur_stree();
+	__unnullify_path();
+	sql_select_return_states("return_id, return, type, parameter, key, value",
+			expr, db_return_states_callback, &db_info);
+	stree = __pop_fake_cur_stree();
+	if (!db_info.cull)
+		merge_fake_stree(&db_info.stree, stree);
+	free_stree(&stree);
+
+	FOR_EACH_SM(db_info.stree, sm) {
+		__set_sm(sm);
+	} END_FOR_EACH_SM(sm);
+
+	free_stree(&db_info.stree);
+	call_return_states_after_hooks(expr);
+}
+
+static int is_condition_call(struct expression *expr)
+{
+	struct expression *tmp;
+
+	FOR_EACH_PTR_REVERSE(big_condition_stack, tmp) {
+		if (expr == tmp || expr_get_parent_expr(expr) == tmp)
+			return 1;
+		if (tmp->pos.line < expr->pos.line)
+			return 0;
+	} END_FOR_EACH_PTR_REVERSE(tmp);
+
+	return 0;
+}
+
+static void db_return_states_call(struct expression *expr)
+{
+	if (unreachable())
+		return;
+
+	if (is_assigned_call(expr))
+		return;
+	if (is_condition_call(expr))
+		return;
+	db_return_states(expr);
+}
+
+static void match_function_call(struct expression *expr)
+{
+	struct call_back_list *call_backs;
+
+	if (expr->fn->type == EXPR_SYMBOL && expr->fn->symbol) {
+		call_backs = search_callback(func_hash, (char *)expr->fn->symbol->ident->name);
+		if (call_backs)
+			call_call_backs(call_backs, REGULAR_CALL,
+					expr->fn->symbol->ident->name, expr);
+	}
+	db_return_states_call(expr);
+}
+
+static void match_macro_assign(struct expression *expr)
+{
+	struct call_back_list *call_backs;
+	const char *macro;
+	struct expression *right;
+
+	right = strip_expr(expr->right);
+	macro = get_macro_name(right->pos);
+	call_backs = search_callback(func_hash, (char *)macro);
+	if (!call_backs)
+		return;
+	call_call_backs(call_backs, MACRO_ASSIGN, macro, expr);
+	call_call_backs(call_backs, MACRO_ASSIGN_EXTRA, macro, expr);
+}
+
+int get_implied_return(struct expression *expr, struct range_list **rl)
+{
+	struct call_back_list *call_backs;
+	struct fcall_back *tmp;
+	int handled = 0;
+	char *fn;
+
+	*rl = NULL;
+
+	expr = strip_expr(expr);
+	fn = expr_to_var(expr->fn);
+	if (!fn)
+		goto out;
+
+	call_backs = search_callback(func_hash, fn);
+
+	FOR_EACH_PTR(call_backs, tmp) {
+		if (tmp->type == IMPLIED_RETURN) {
+			(tmp->u.implied_return)(expr, tmp->info, rl);
+			handled = 1;
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+out:
+	free_string(fn);
+	return handled;
+}
+
+void create_function_hook_hash(void)
+{
+	func_hash = create_function_hashtable(5000);
+}
+
+void register_function_hooks(int id)
+{
+	add_hook(&match_function_call, CALL_HOOK_AFTER_INLINE);
+	add_hook(&match_assign_call, CALL_ASSIGNMENT_HOOK);
+	add_hook(&match_macro_assign, MACRO_ASSIGNMENT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_function_info.c b/usr/src/tools/smatch/src/smatch_function_info.c
new file mode 100644
index 0000000000..7fa4dd5813
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_function_info.c
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Record parameter types in the database.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static void match_def(struct symbol *sym)
+{
+	struct symbol *arg;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(sym->ctype.base_type->arguments, arg) {
+		i++;
+		sql_insert_function_type(i, type_to_str(get_real_base_type(arg)));
+	} END_FOR_EACH_PTR(arg);
+}
+
+void register_function_info(int id)
+{
+	my_id = id;
+	add_hook(match_def, FUNC_DEF_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_function_ptrs.c b/usr/src/tools/smatch/src/smatch_function_ptrs.c
new file mode 100644
index 0000000000..9a897f9cb4
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_function_ptrs.c
@@ -0,0 +1,359 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Track how functions are saved as various struct members or passed as
+ * parameters.
+ *
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static char *get_from__symbol_get(struct expression *expr)
+{
+	struct expression *arg;
+
+	/*
+	 * typeof(&dib0070_attach) __a =
+	 * ((((typeof(&dib0070_attach)) (__symbol_get("dib0070_attach")))) ?:
+	 *  (__request_module(true, "symbol:" "dib0070_attach"), (((typeof(&dib0070_attach))(__symbol_get("dib0070_attach"))))));
+	 */
+
+	expr = strip_expr(expr);
+
+	if (expr->type != EXPR_CALL)
+		return NULL;
+	if (!sym_name_is("__symbol_get", expr->fn))
+		return NULL;
+	arg = get_argument_from_call_expr(expr->args, 0);
+	if (!arg || arg->type != EXPR_STRING)
+		return NULL;
+
+	return alloc_string(arg->string->data);
+}
+
+static char *get_array_ptr(struct expression *expr)
+{
+	struct expression *array;
+	struct symbol *type;
+	char *name;
+	char buf[256];
+
+	array = get_array_base(expr);
+
+	if (array) {
+		name = get_member_name(array);
+		if (name)
+			return name;
+	}
+
+	/* FIXME:  is_array() should probably be is_array_element() */
+	type = get_type(expr);
+	if (!array && type && type->type == SYM_ARRAY)
+		array = expr;
+	if (array) {
+		name = expr_to_var(array);
+		if (!name)
+			return NULL;
+		snprintf(buf, sizeof(buf), "%s[]", name);
+		return alloc_string(buf);
+	}
+
+	expr = get_assigned_expr(expr);
+	array = get_array_base(expr);
+	if (!array)
+		return NULL;
+	name = expr_to_var(array);
+	if (!name)
+		return NULL;
+	snprintf(buf, sizeof(buf), "%s[]", name);
+	free_string(name);
+	return alloc_string(buf);
+}
+
+static int is_local_symbol(struct symbol *sym)
+{
+	if (!sym ||
+	    !(sym->ctype.modifiers & MOD_TOPLEVEL))
+		return 1;
+	return 0;
+}
+
+static char *ptr_prefix(struct symbol *sym)
+{
+	static char buf[128];
+
+
+	if (is_local_symbol(sym))
+		snprintf(buf, sizeof(buf), "%s ptr", get_function());
+	else if (sym && toplevel(sym->scope))
+		snprintf(buf, sizeof(buf), "%s ptr", get_base_file());
+	else
+		snprintf(buf, sizeof(buf), "ptr");
+
+	return buf;
+}
+
+char *get_returned_ptr(struct expression *expr)
+{
+	struct symbol *type;
+	char *name;
+	char buf[256];
+
+	if (expr->type != EXPR_CALL)
+		return NULL;
+	if (!expr->fn || expr->fn->type != EXPR_SYMBOL)
+		return NULL;
+
+	type = get_type(expr);
+	if (type && type->type == SYM_PTR)
+		type = get_real_base_type(type);
+	if (!type || type->type != SYM_FN)
+		return NULL;
+
+	name = expr_to_var(expr->fn);
+	if (!name)
+		return NULL;
+	snprintf(buf, sizeof(buf), "r %s()", name);
+	free_string(name);
+	return alloc_string(buf);
+}
+
+char *get_fnptr_name(struct expression *expr)
+{
+	char *name;
+
+	expr = strip_expr(expr);
+
+	/* (*ptrs[0])(a, b, c) is the same as ptrs[0](a, b, c); */
+	if (expr->type == EXPR_PREOP && expr->op == '*')
+		expr = strip_expr(expr->unop);
+
+	name = get_from__symbol_get(expr);
+	if (name)
+		return name;
+
+	name = get_array_ptr(expr);
+	if (name)
+		return name;
+
+	name = get_returned_ptr(expr);
+	if (name)
+		return name;
+
+	name = get_member_name(expr);
+	if (name)
+		return name;
+
+	if (expr->type == EXPR_SYMBOL) {
+		int param;
+		char buf[256];
+		struct symbol *sym;
+		struct symbol *type;
+
+		param = get_param_num_from_sym(expr->symbol);
+		if (param >= 0) {
+			snprintf(buf, sizeof(buf), "%s param %d", get_function(), param);
+			return alloc_string(buf);
+		}
+
+		name =  expr_to_var_sym(expr, &sym);
+		if (!name)
+			return NULL;
+		type = get_type(expr);
+		if (type && type->type == SYM_PTR) {
+			snprintf(buf, sizeof(buf), "%s %s", ptr_prefix(sym), name);
+			free_string(name);
+			return alloc_string(buf);
+		}
+		return name;
+	}
+	return expr_to_var(expr);
+}
+
+static void match_passes_function_pointer(struct expression *expr)
+{
+	struct expression *arg, *tmp;
+	struct symbol *type;
+	char *called_name;
+	char *fn_name;
+	char ptr_name[256];
+	int i;
+
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+
+		tmp = strip_expr(arg);
+		if (tmp->type == EXPR_PREOP && tmp->op == '&')
+			tmp = strip_expr(tmp->unop);
+
+		type = get_type(tmp);
+		if (type && type->type == SYM_PTR)
+			type = get_real_base_type(type);
+		if (!type || type->type != SYM_FN)
+			continue;
+
+		called_name = expr_to_var(expr->fn);
+		if (!called_name)
+			return;
+		fn_name = get_fnptr_name(tmp);
+		if (!fn_name)
+			goto free;
+
+		snprintf(ptr_name, sizeof(ptr_name), "%s param %d", called_name, i);
+		sql_insert_function_ptr(fn_name, ptr_name);
+free:
+		free_string(fn_name);
+		free_string(called_name);
+	} END_FOR_EACH_PTR(arg);
+
+}
+
+static int get_row_count(void *_row_count, int argc, char **argv, char **azColName)
+{
+	int *row_count = _row_count;
+
+	*row_count = 0;
+	if (argc != 1)
+		return 0;
+	*row_count = atoi(argv[0]);
+	return 0;
+}
+
+static int can_hold_function_ptr(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+	if (type->type == SYM_PTR || type->type == SYM_ARRAY) {
+		type = get_real_base_type(type);
+		if (!type)
+			return 0;
+	}
+	if (type->type == SYM_FN)
+		return 1;
+	if (type == &ulong_ctype && expr->type == EXPR_DEREF)
+		return 1;
+	if (type == &void_ctype)
+		return 1;
+	return 0;
+}
+
+static void match_function_assign(struct expression *expr)
+{
+	struct expression *right;
+	struct symbol *type;
+	char *fn_name;
+	char *ptr_name;
+
+	if (__in_fake_assign)
+		return;
+
+	right = strip_expr(expr->right);
+	if (right->type == EXPR_PREOP && right->op == '&')
+		right = strip_expr(right->unop);
+
+	if (right->type != EXPR_SYMBOL &&
+	    right->type != EXPR_DEREF)
+		return;
+
+	if (!can_hold_function_ptr(right) ||
+	    !can_hold_function_ptr(expr->left))
+		return;
+
+	fn_name = get_fnptr_name(right);
+	ptr_name = get_fnptr_name(expr->left);
+	if (!fn_name || !ptr_name)
+		goto free;
+	if (strcmp(fn_name, ptr_name) == 0)
+		goto free;
+
+
+	type = get_type(right);
+	if (!type)
+		return;
+	if (type->type == SYM_PTR || type->type == SYM_ARRAY) {
+		type = get_real_base_type(type);
+		if (!type)
+			return;
+	}
+	if (type->type != SYM_FN) {
+		int count = 0;
+
+		/* look it up in function_ptr */
+		run_sql(get_row_count, &count,
+			"select count(*) from function_ptr where ptr = '%s'",
+			fn_name);
+		if (count == 0)
+			goto free;
+	}
+
+	sql_insert_function_ptr(fn_name, ptr_name);
+free:
+	free_string(fn_name);
+	free_string(ptr_name);
+}
+
+static void match_returns_function_pointer(struct expression *expr)
+{
+	struct symbol *type;
+	char *fn_name;
+	char ptr_name[256];
+
+	if (__inline_fn)
+		return;
+
+	type = get_real_base_type(cur_func_sym);
+	if (!type || type->type != SYM_FN)
+		return;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_PTR)
+		return;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_FN)
+		return;
+
+	if (expr->type == EXPR_PREOP && expr->op == '&')
+		expr = strip_expr(expr->unop);
+
+	fn_name = get_fnptr_name(expr);
+	if (!fn_name)
+		return;
+	snprintf(ptr_name, sizeof(ptr_name), "r %s()", get_function());
+	sql_insert_function_ptr(fn_name, ptr_name);
+}
+
+void register_function_ptrs(int id)
+{
+	my_id = id;
+
+	if (!option_info)
+		return;
+
+	add_hook(&match_passes_function_pointer, FUNCTION_CALL_HOOK);
+	add_hook(&match_returns_function_pointer, RETURN_HOOK);
+	add_hook(&match_function_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_function_assign, GLOBAL_ASSIGNMENT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_helper.c b/usr/src/tools/smatch/src/smatch_helper.c
new file mode 100644
index 0000000000..81d4e2dd78
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_helper.c
@@ -0,0 +1,1118 @@
+/*
+ * Copyright (C) 2006 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Miscellaneous helper functions.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "allocate.h"
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+#define VAR_LEN 512
+
+char *alloc_string(const char *str)
+{
+	char *tmp;
+
+	if (!str)
+		return NULL;
+	tmp = malloc(strlen(str) + 1);
+	strcpy(tmp, str);
+	return tmp;
+}
+
+void free_string(char *str)
+{
+	free(str);
+}
+
+void remove_parens(char *str)
+{
+	char *src, *dst;
+
+	dst = src = str;
+	while (*src != '\0') {
+		if (*src == '(' || *src == ')') {
+			src++;
+			continue;
+		}
+		*dst++ = *src++;
+	}
+	*dst = *src;
+}
+
+struct smatch_state *alloc_state_num(int num)
+{
+	struct smatch_state *state;
+	static char buff[256];
+
+	state = __alloc_smatch_state(0);
+	snprintf(buff, 255, "%d", num);
+	buff[255] = '\0';
+	state->name = alloc_string(buff);
+	state->data = INT_PTR(num);
+	return state;
+}
+
+struct smatch_state *alloc_state_str(const char *name)
+{
+	struct smatch_state *state;
+
+	state = __alloc_smatch_state(0);
+	state->name = alloc_string(name);
+	return state;
+}
+
+struct smatch_state *alloc_state_expr(struct expression *expr)
+{
+	struct smatch_state *state;
+	char *name;
+
+	state = __alloc_smatch_state(0);
+	expr = strip_expr(expr);
+	name = expr_to_str(expr);
+	state->name = alloc_sname(name);
+	free_string(name);
+	state->data = expr;
+	return state;
+}
+
+void append(char *dest, const char *data, int buff_len)
+{
+	strncat(dest, data, buff_len - strlen(dest) - 1);
+}
+
+/*
+ * If you have "foo(a, b, 1);" then use
+ * get_argument_from_call_expr(expr, 0) to return the expression for
+ * a.  Yes, it does start counting from 0.
+ */
+struct expression *get_argument_from_call_expr(struct expression_list *args,
+					       int num)
+{
+	struct expression *expr;
+	int i = 0;
+
+	if (!args)
+		return NULL;
+
+	FOR_EACH_PTR(args, expr) {
+		if (i == num)
+			return expr;
+		i++;
+	} END_FOR_EACH_PTR(expr);
+	return NULL;
+}
+
+static struct expression *get_array_expr(struct expression *expr)
+{
+	struct expression *parent;
+	struct symbol *type;
+
+	if (expr->type != EXPR_BINOP || expr->op != '+')
+		return NULL;
+
+	type = get_type(expr->left);
+	if (!type)
+		return NULL;
+	if (type->type == SYM_ARRAY)
+		return expr->left;
+	if (type->type != SYM_PTR)
+		return NULL;
+
+	parent = expr_get_parent_expr(expr);
+	if (!parent)  /* Sometimes we haven't set up the ->parent yet. FIXME!! */
+		return expr->left;
+	if (parent->type == EXPR_PREOP && parent->op == '*')
+		return expr->left;
+
+	return NULL;
+}
+
+static void __get_variable_from_expr(struct symbol **sym_ptr, char *buf,
+				     struct expression *expr, int len,
+				     int *complicated, int no_parens)
+{
+
+
+	if (!expr) {
+		/* can't happen on valid code */
+		*complicated = 1;
+		return;
+	}
+
+	switch (expr->type) {
+	case EXPR_DEREF: {
+		struct expression *deref;
+		int op;
+
+		deref = expr->deref;
+		op = deref->op;
+		if (op == '*') {
+			struct expression *unop = strip_expr(deref->unop);
+
+			if (unop->type == EXPR_PREOP && unop->op == '&') {
+				deref = unop->unop;
+				op = '.';
+			} else {
+				deref = deref->unop;
+				if (!is_pointer(deref))
+					op = '.';
+			}
+		}
+
+		__get_variable_from_expr(sym_ptr, buf, deref, len, complicated, no_parens);
+
+		if (op == '*')
+			append(buf, "->", len);
+		else
+			append(buf, ".", len);
+
+		if (expr->member)
+			append(buf, expr->member->name, len);
+		else
+			append(buf, "unknown_member", len);
+
+		return;
+	}
+	case EXPR_SYMBOL:
+		if (expr->symbol_name)
+			append(buf, expr->symbol_name->name, len);
+		if (sym_ptr) {
+			if (*sym_ptr)
+				*complicated = 1;
+			*sym_ptr = expr->symbol;
+		}
+		return;
+	case EXPR_PREOP: {
+		const char *tmp;
+
+		if (get_expression_statement(expr)) {
+			*complicated = 2;
+			return;
+		}
+
+		if (expr->op == '(') {
+			if (!no_parens && expr->unop->type != EXPR_SYMBOL)
+				append(buf, "(", len);
+		} else if (expr->op != '*' || !get_array_expr(expr->unop)) {
+			tmp = show_special(expr->op);
+			append(buf, tmp, len);
+		}
+		__get_variable_from_expr(sym_ptr, buf, expr->unop,
+						 len, complicated, no_parens);
+
+		if (expr->op == '(' && !no_parens && expr->unop->type != EXPR_SYMBOL)
+			append(buf, ")", len);
+
+		if (expr->op == SPECIAL_DECREMENT ||
+				expr->op == SPECIAL_INCREMENT)
+			*complicated = 1;
+
+		return;
+	}
+	case EXPR_POSTOP: {
+		const char *tmp;
+
+		__get_variable_from_expr(sym_ptr, buf, expr->unop,
+						 len, complicated, no_parens);
+		tmp = show_special(expr->op);
+		append(buf, tmp, len);
+
+		if (expr->op == SPECIAL_DECREMENT || expr->op == SPECIAL_INCREMENT)
+			*complicated = 1;
+		return;
+	}
+	case EXPR_ASSIGNMENT:
+	case EXPR_COMPARE:
+	case EXPR_LOGICAL:
+	case EXPR_BINOP: {
+		char tmp[10];
+		struct expression *array_expr;
+
+		*complicated = 1;
+		array_expr = get_array_expr(expr);
+		if (array_expr) {
+			__get_variable_from_expr(sym_ptr, buf, array_expr, len, complicated, no_parens);
+			append(buf, "[", len);
+		} else {
+			__get_variable_from_expr(sym_ptr, buf, expr->left, len, complicated, no_parens);
+			snprintf(tmp, sizeof(tmp), " %s ", show_special(expr->op));
+			append(buf, tmp, len);
+		}
+		__get_variable_from_expr(NULL, buf, expr->right, len, complicated, no_parens);
+		if (array_expr)
+			append(buf, "]", len);
+		return;
+	}
+	case EXPR_VALUE: {
+		char tmp[25];
+
+		*complicated = 1;
+		snprintf(tmp, 25, "%lld", expr->value);
+		append(buf, tmp, len);
+		return;
+	}
+	case EXPR_STRING:
+		append(buf, "\"", len);
+		if (expr->string)
+			append(buf, expr->string->data, len);
+		append(buf, "\"", len);
+		return;
+	case EXPR_CALL: {
+		struct expression *tmp;
+		int i;
+
+		*complicated = 1;
+		__get_variable_from_expr(NULL, buf, expr->fn, len, complicated, no_parens);
+		append(buf, "(", len);
+		i = 0;
+		FOR_EACH_PTR(expr->args, tmp) {
+			if (i++)
+				append(buf, ", ", len);
+			__get_variable_from_expr(NULL, buf, tmp, len, complicated, no_parens);
+		} END_FOR_EACH_PTR(tmp);
+		append(buf, ")", len);
+		return;
+	}
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+		__get_variable_from_expr(sym_ptr, buf,
+					 expr->cast_expression, len,
+					 complicated, no_parens);
+		return;
+	case EXPR_SIZEOF: {
+		sval_t sval;
+		int size;
+		char tmp[25];
+
+		if (expr->cast_type && get_base_type(expr->cast_type)) {
+			size = type_bytes(get_base_type(expr->cast_type));
+			snprintf(tmp, 25, "%d", size);
+			append(buf, tmp, len);
+		} else if (get_value(expr, &sval)) {
+			snprintf(tmp, 25, "%s", sval_to_str(sval));
+			append(buf, tmp, len);
+		}
+		return;
+	}
+	case EXPR_IDENTIFIER:
+		*complicated = 1;
+		if (expr->expr_ident)
+			append(buf, expr->expr_ident->name, len);
+		return;
+	default:
+		*complicated = 1;
+		//printf("unknown type = %d\n", expr->type);
+		return;
+	}
+}
+
+struct expr_str_cache_results {
+	struct expression *expr;
+	int no_parens;
+	char str[VAR_LEN];
+	struct symbol *sym;
+	int complicated;
+};
+
+static void get_variable_from_expr(struct symbol **sym_ptr, char *buf,
+				     struct expression *expr, int len,
+				     int *complicated, int no_parens)
+{
+	static struct expr_str_cache_results cached[8];
+	struct symbol *tmp_sym = NULL;
+	static int idx;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(cached); i++) {
+		if (expr == cached[i].expr &&
+		    no_parens == cached[i].no_parens) {
+			strncpy(buf, cached[i].str, len);
+			if (sym_ptr)
+				*sym_ptr = cached[i].sym;
+			*complicated = cached[i].complicated;
+			return;
+		}
+	}
+
+	__get_variable_from_expr(&tmp_sym, buf, expr, len, complicated, no_parens);
+	if (sym_ptr)
+		*sym_ptr = tmp_sym;
+
+	cached[idx].expr = expr;
+	cached[idx].no_parens = no_parens;
+	strncpy(cached[idx].str, buf, VAR_LEN);
+	cached[idx].sym = tmp_sym;
+	cached[idx].complicated = *complicated;
+
+	idx = (idx + 1) % ARRAY_SIZE(cached);
+}
+
+/*
+ * This is returns a stylized "c looking" representation of the
+ * variable name.
+ *
+ * It uses the same buffer every time so you have to save the result
+ * yourself if you want to keep it.
+ *
+ */
+
+char *expr_to_str_sym(struct expression *expr, struct symbol **sym_ptr)
+{
+	static char var_name[VAR_LEN];
+	int complicated = 0;
+
+	if (sym_ptr)
+		*sym_ptr = NULL;
+	var_name[0] = '\0';
+
+	if (!expr)
+		return NULL;
+	get_variable_from_expr(sym_ptr, var_name, expr, sizeof(var_name),
+				 &complicated, 0);
+	if (complicated < 2)
+		return alloc_string(var_name);
+	else
+		return NULL;
+}
+
+char *expr_to_str(struct expression *expr)
+{
+	return expr_to_str_sym(expr, NULL);
+}
+
+/*
+ * get_variable_from_expr_simple() only returns simple variables.
+ * If it's a complicated variable like a->foo[x] instead of just 'a->foo'
+ * then it returns NULL.
+ */
+char *expr_to_var_sym(struct expression *expr,
+				    struct symbol **sym_ptr)
+{
+	static char var_name[VAR_LEN];
+	int complicated = 0;
+
+	if (sym_ptr)
+		*sym_ptr = NULL;
+	var_name[0] = '\0';
+
+	if (!expr)
+		return NULL;
+	expr = strip_expr(expr);
+	get_variable_from_expr(sym_ptr, var_name, expr, sizeof(var_name),
+				 &complicated, 1);
+
+	if (complicated) {
+		if (sym_ptr)
+			*sym_ptr = NULL;
+		return NULL;
+	}
+	return alloc_string(var_name);
+}
+
+char *expr_to_var(struct expression *expr)
+{
+	return expr_to_var_sym(expr, NULL);
+}
+
+struct symbol *expr_to_sym(struct expression *expr)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = expr_to_var_sym(expr, &sym);
+	free_string(name);
+	return sym;
+}
+
+int get_complication_score(struct expression *expr)
+{
+	expr = strip_expr(expr);
+
+	/*
+	 * Don't forget to keep get_complication_score() and store_all_links()
+	 * in sync.
+	 *
+	 */
+
+	if (!expr)
+		return 990;
+
+	switch (expr->type) {
+	case EXPR_CALL:
+		return 991;
+	case EXPR_COMPARE:
+	case EXPR_BINOP:
+		return get_complication_score(expr->left) +
+		       get_complication_score(expr->right);
+	case EXPR_SYMBOL:
+		return 1;
+	case EXPR_PREOP:
+		if (expr->op == '*' || expr->op == '(')
+			return get_complication_score(expr->unop);
+		return 993;
+	case EXPR_DEREF:
+		return get_complication_score(expr->deref);
+	case EXPR_VALUE:
+	case EXPR_SIZEOF:
+		return 0;
+	default:
+		return 994;
+	}
+}
+
+struct expression *reorder_expr_alphabetically(struct expression *expr)
+{
+	struct expression *ret;
+	char *left, *right;
+
+	if (expr->type != EXPR_BINOP)
+		return expr;
+	if (expr->op != '+' && expr->op != '*')
+		return expr;
+
+	left = expr_to_var(expr->left);
+	right = expr_to_var(expr->right);
+	ret = expr;
+	if (!left || !right)
+		goto free;
+	if (strcmp(left, right) <= 0)
+		goto free;
+
+	ret = binop_expression(expr->right, expr->op, expr->left);
+free:
+	free_string(left);
+	free_string(right);
+
+	return ret;
+}
+
+char *expr_to_chunk_helper(struct expression *expr, struct symbol **sym, struct var_sym_list **vsl)
+{
+	struct var_sym_list *tmp_vsl;
+	char *name;
+	struct symbol *tmp;
+	int score;
+
+	if (vsl)
+		*vsl = NULL;
+	if (sym)
+		*sym = NULL;
+
+	expr = strip_parens(expr);
+	if (!expr)
+		return NULL;
+
+	name = expr_to_var_sym(expr, &tmp);
+	if (name && tmp) {
+		if (sym)
+			*sym = tmp;
+		if (vsl)
+			*vsl = expr_to_vsl(expr);
+		return name;
+	}
+	free_string(name);
+
+	score = get_complication_score(expr);
+	if (score <= 0 || score > 2)
+		return NULL;
+
+	tmp_vsl = expr_to_vsl(expr);
+	if (vsl) {
+		*vsl = tmp_vsl;
+		if (!*vsl)
+			return NULL;
+	}
+	if (sym) {
+		if (ptr_list_size((struct ptr_list *)tmp_vsl) == 1) {
+			struct var_sym *vs;
+
+			vs = first_ptr_list((struct ptr_list *)tmp_vsl);
+			*sym = vs->sym;
+		}
+	}
+
+	expr = reorder_expr_alphabetically(expr);
+
+	return expr_to_str(expr);
+}
+
+char *expr_to_known_chunk_sym(struct expression *expr, struct symbol **sym)
+{
+	return expr_to_chunk_helper(expr, sym, NULL);
+}
+
+char *expr_to_chunk_sym_vsl(struct expression *expr, struct symbol **sym, struct var_sym_list **vsl)
+{
+	return expr_to_chunk_helper(expr, sym, vsl);
+}
+
+int sym_name_is(const char *name, struct expression *expr)
+{
+	if (!expr)
+		return 0;
+	if (expr->type != EXPR_SYMBOL)
+		return 0;
+	if (!strcmp(expr->symbol_name->name, name))
+		return 1;
+	return 0;
+}
+
+int is_zero(struct expression *expr)
+{
+	sval_t sval;
+
+	if (get_value(expr, &sval) && sval.value == 0)
+		return 1;
+	return 0;
+}
+
+int is_array(struct expression *expr)
+{
+	struct symbol *type;
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return 0;
+
+	if (expr->type == EXPR_PREOP && expr->op == '*') {
+		expr = strip_expr(expr->unop);
+		if (!expr)
+			return 0;
+		if (expr->type == EXPR_BINOP && expr->op == '+')
+			return 1;
+	}
+
+	if (expr->type != EXPR_BINOP || expr->op != '+')
+		return 0;
+
+	type = get_type(expr->left);
+	if (!type || type->type != SYM_ARRAY)
+		return 0;
+
+	return 1;
+}
+
+struct expression *get_array_base(struct expression *expr)
+{
+	if (!is_array(expr))
+		return NULL;
+	expr = strip_expr(expr);
+	if (expr->type == EXPR_PREOP && expr->op == '*')
+		expr = strip_expr(expr->unop);
+	if (expr->type != EXPR_BINOP || expr->op != '+')
+		return NULL;
+	return strip_parens(expr->left);
+}
+
+struct expression *get_array_offset(struct expression *expr)
+{
+	if (!is_array(expr))
+		return NULL;
+	expr = strip_expr(expr);
+	if (expr->type == EXPR_PREOP && expr->op == '*')
+		expr = strip_expr(expr->unop);
+	if (expr->type != EXPR_BINOP || expr->op != '+')
+		return NULL;
+	return strip_parens(expr->right);
+}
+
+const char *show_state(struct smatch_state *state)
+{
+	if (!state)
+		return NULL;
+	return state->name;
+}
+
+struct statement *get_expression_statement(struct expression *expr)
+{
+	/* What are those things called? if (({....; ret;})) { ...*/
+
+	if (expr->type != EXPR_PREOP)
+		return NULL;
+	if (expr->op != '(')
+		return NULL;
+	if (!expr->unop)
+		return NULL;
+	if (expr->unop->type != EXPR_STATEMENT)
+		return NULL;
+	if (expr->unop->statement->type != STMT_COMPOUND)
+		return NULL;
+	return expr->unop->statement;
+}
+
+struct expression *strip_parens(struct expression *expr)
+{
+	if (!expr)
+		return NULL;
+
+	if (expr->type == EXPR_PREOP) {
+		if (!expr->unop)
+			return expr;  /* parsing invalid code */
+
+		if (expr->op == '(' && expr->unop->type == EXPR_STATEMENT &&
+			expr->unop->statement->type == STMT_COMPOUND)
+			return expr;
+		if (expr->op == '(')
+			return strip_parens(expr->unop);
+	}
+	return expr;
+}
+
+static struct expression *strip_expr_helper(struct expression *expr, bool set_parent)
+{
+	if (!expr)
+		return NULL;
+
+	switch (expr->type) {
+	case EXPR_FORCE_CAST:
+	case EXPR_CAST:
+		if (set_parent)
+			expr_set_parent_expr(expr->cast_expression, expr);
+
+		if (!expr->cast_expression)
+			return expr;
+		return strip_expr_helper(expr->cast_expression, set_parent);
+	case EXPR_PREOP: {
+		struct expression *unop;
+
+		if (!expr->unop)  /* parsing invalid code */
+			return expr;
+		if (set_parent)
+			expr_set_parent_expr(expr->unop, expr);
+
+
+		if (expr->op == '(' && expr->unop->type == EXPR_STATEMENT &&
+			expr->unop->statement->type == STMT_COMPOUND)
+			return expr;
+
+		unop = strip_expr_helper(expr->unop, set_parent);
+
+		if (expr->op == '*' && unop &&
+		    unop->type == EXPR_PREOP && unop->op == '&') {
+			struct symbol *type = get_type(unop->unop);
+
+			if (type && type->type == SYM_ARRAY)
+				return expr;
+			return strip_expr_helper(unop->unop, set_parent);
+		}
+
+		if (expr->op == '(')
+			return unop;
+
+		return expr;
+	}
+	case EXPR_CONDITIONAL:
+		if (known_condition_true(expr->conditional)) {
+			if (expr->cond_true) {
+				if (set_parent)
+					expr_set_parent_expr(expr->cond_true, expr);
+				return strip_expr_helper(expr->cond_true, set_parent);
+			}
+			if (set_parent)
+				expr_set_parent_expr(expr->conditional, expr);
+			return strip_expr_helper(expr->conditional, set_parent);
+		}
+		if (known_condition_false(expr->conditional)) {
+			if (set_parent)
+				expr_set_parent_expr(expr->cond_false, expr);
+			return strip_expr_helper(expr->cond_false, set_parent);
+		}
+		return expr;
+	case EXPR_CALL:
+		if (sym_name_is("__builtin_expect", expr->fn) ||
+		    sym_name_is("__builtin_bswap16", expr->fn) ||
+		    sym_name_is("__builtin_bswap32", expr->fn) ||
+		    sym_name_is("__builtin_bswap64", expr->fn)) {
+			expr = get_argument_from_call_expr(expr->args, 0);
+			return strip_expr_helper(expr, set_parent);
+		}
+		return expr;
+	}
+	return expr;
+}
+
+struct expression *strip_expr(struct expression *expr)
+{
+	return strip_expr_helper(expr, false);
+}
+
+struct expression *strip_expr_set_parent(struct expression *expr)
+{
+	return strip_expr_helper(expr, true);
+}
+
+static void delete_state_tracker(struct tracker *t)
+{
+	delete_state(t->owner, t->name, t->sym);
+	__free_tracker(t);
+}
+
+void scoped_state(int my_id, const char *name, struct symbol *sym)
+{
+	struct tracker *t;
+
+	t = alloc_tracker(my_id, name, sym);
+	add_scope_hook((scope_hook *)&delete_state_tracker, t);
+}
+
+int is_error_return(struct expression *expr)
+{
+	struct symbol *cur_func = cur_func_sym;
+	struct range_list *rl;
+	sval_t sval;
+
+	if (!expr)
+		return 0;
+	if (cur_func->type != SYM_NODE)
+		return 0;
+	cur_func = get_base_type(cur_func);
+	if (cur_func->type != SYM_FN)
+		return 0;
+	cur_func = get_base_type(cur_func);
+	if (cur_func == &void_ctype)
+		return 0;
+	if (option_project == PROJ_KERNEL &&
+	    get_implied_rl(expr, &rl) &&
+	    rl_type(rl) == &int_ctype &&
+	    sval_is_negative(rl_min(rl)) &&
+	    rl_max(rl).value == -1)
+		return 1;
+	if (!get_implied_value(expr, &sval))
+		return 0;
+	if (sval.value < 0)
+		return 1;
+	if (cur_func->type == SYM_PTR && sval.value == 0)
+		return 1;
+	return 0;
+}
+
+int getting_address(void)
+{
+	struct expression *tmp;
+	int i = 0;
+	int dot_ops = 0;
+
+	FOR_EACH_PTR_REVERSE(big_expression_stack, tmp) {
+		if (!i++)
+			continue;
+		if (tmp->type == EXPR_PREOP && tmp->op == '(')
+			continue;
+		if (tmp->op == '.' && !dot_ops++)
+			continue;
+		if (tmp->op == '&')
+			return 1;
+		return 0;
+	} END_FOR_EACH_PTR_REVERSE(tmp);
+	return 0;
+}
+
+int get_struct_and_member(struct expression *expr, const char **type, const char **member)
+{
+	struct symbol *sym;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_DEREF)
+		return 0;
+	if (!expr->member)
+		return 0;
+
+	sym = get_type(expr->deref);
+	if (!sym)
+		return 0;
+	if (sym->type == SYM_UNION)
+		return 0;
+	if (!sym->ident)
+		return 0;
+
+	*type = sym->ident->name;
+	*member = expr->member->name;
+	return 1;
+}
+
+char *get_member_name(struct expression *expr)
+{
+	char buf[256];
+	struct symbol *sym;
+
+	expr = strip_expr(expr);
+	if (!expr || expr->type != EXPR_DEREF)
+		return NULL;
+	if (!expr->member)
+		return NULL;
+
+	sym = get_type(expr->deref);
+	if (!sym)
+		return NULL;
+	if (sym->type == SYM_UNION) {
+		snprintf(buf, sizeof(buf), "(union %s)->%s",
+			 sym->ident ? sym->ident->name : "anonymous",
+			 expr->member->name);
+		return alloc_string(buf);
+	}
+	if (!sym->ident)
+		return NULL;
+	snprintf(buf, sizeof(buf), "(struct %s)->%s", sym->ident->name, expr->member->name);
+	return alloc_string(buf);
+}
+
+int cmp_pos(struct position pos1, struct position pos2)
+{
+	/* the stream position is ... */
+	if (pos1.stream > pos2.stream)
+		return -1;
+	if (pos1.stream < pos2.stream)
+		return 1;
+
+	if (pos1.line < pos2.line)
+		return -1;
+	if (pos1.line > pos2.line)
+		return 1;
+
+	if (pos1.pos < pos2.pos)
+		return -1;
+	if (pos1.pos > pos2.pos)
+		return 1;
+
+	return 0;
+}
+
+int positions_eq(struct position pos1, struct position pos2)
+{
+	if (pos1.line != pos2.line)
+		return 0;
+	if (pos1.pos != pos2.pos)
+		return 0;
+	if (pos1.stream != pos2.stream)
+		return 0;
+	return 1;
+}
+
+struct statement *get_current_statement(void)
+{
+	struct statement *prev, *tmp;
+
+	prev = last_ptr_list((struct ptr_list *)big_statement_stack);
+
+	if (!prev || !get_macro_name(prev->pos))
+		return prev;
+
+	FOR_EACH_PTR_REVERSE(big_statement_stack, tmp) {
+		if (positions_eq(tmp->pos, prev->pos))
+			continue;
+		if (prev->pos.line > tmp->pos.line)
+			return prev;
+		return tmp;
+	} END_FOR_EACH_PTR_REVERSE(tmp);
+	return prev;
+}
+
+struct statement *get_prev_statement(void)
+{
+	struct statement *tmp;
+	int i;
+
+	i = 0;
+	FOR_EACH_PTR_REVERSE(big_statement_stack, tmp) {
+		if (i++ == 1)
+			return tmp;
+	} END_FOR_EACH_PTR_REVERSE(tmp);
+	return NULL;
+}
+
+struct expression *get_last_expr_from_expression_stmt(struct expression *expr)
+{
+	struct statement *stmt;
+	struct statement *last_stmt;
+
+	while (expr->type == EXPR_PREOP && expr->op == '(')
+		expr = expr->unop;
+	if (expr->type != EXPR_STATEMENT)
+		return NULL;
+	stmt = expr->statement;
+	if (!stmt)
+		return NULL;
+	if (stmt->type == STMT_COMPOUND) {
+		last_stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
+		if (!last_stmt)
+			return NULL;
+		if (last_stmt->type == STMT_LABEL)
+			last_stmt = last_stmt->label_statement;
+		if (last_stmt->type != STMT_EXPRESSION)
+			return NULL;
+		return last_stmt->expression;
+	}
+	if (stmt->type == STMT_EXPRESSION)
+		return stmt->expression;
+	return NULL;
+}
+
+int get_param_num_from_sym(struct symbol *sym)
+{
+	struct symbol *tmp;
+	int i;
+
+	if (!cur_func_sym)
+		return -1;
+
+	i = 0;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, tmp) {
+		if (tmp == sym)
+			return i;
+		i++;
+	} END_FOR_EACH_PTR(tmp);
+	return -1;
+}
+
+int get_param_num(struct expression *expr)
+{
+	struct symbol *sym;
+	char *name;
+
+	if (!cur_func_sym)
+		return -1;
+	name = expr_to_var_sym(expr, &sym);
+	free_string(name);
+	if (!sym)
+		return -1;
+	return get_param_num_from_sym(sym);
+}
+
+int ms_since(struct timeval *start)
+{
+	struct timeval end;
+	double diff;
+
+	gettimeofday(&end, NULL);
+	diff = (end.tv_sec - start->tv_sec) * 1000.0;
+	diff += (end.tv_usec - start->tv_usec) / 1000.0;
+	return (int)diff;
+}
+
+int parent_is_gone_var_sym(const char *name, struct symbol *sym)
+{
+	if (!name || !sym)
+		return 0;
+
+	if (parent_is_null_var_sym(name, sym) ||
+	    parent_is_free_var_sym(name, sym))
+		return 1;
+	return 0;
+}
+
+int parent_is_gone(struct expression *expr)
+{
+	struct symbol *sym;
+	char *var;
+	int ret = 0;
+
+	expr = strip_expr(expr);
+	var = expr_to_var_sym(expr, &sym);
+	if (!var || !sym)
+		goto free;
+	ret = parent_is_gone_var_sym(var, sym);
+free:
+	free_string(var);
+	return ret;
+}
+
+int invert_op(int op)
+{
+	switch (op) {
+	case '*':
+		return '/';
+	case '/':
+		return '*';
+	case '+':
+		return '-';
+	case '-':
+		return '+';
+	case SPECIAL_LEFTSHIFT:
+		return SPECIAL_RIGHTSHIFT;
+	case SPECIAL_RIGHTSHIFT:
+		return SPECIAL_LEFTSHIFT;
+	}
+	return 0;
+}
+
+int expr_equiv(struct expression *one, struct expression *two)
+{
+	struct symbol *one_sym = NULL;
+	struct symbol *two_sym = NULL;
+	char *one_name = NULL;
+	char *two_name = NULL;
+	int ret = 0;
+
+	if (!one || !two)
+		return 0;
+	if (one->type != two->type)
+		return 0;
+	if (is_fake_call(one) || is_fake_call(two))
+		return 0;
+
+	one_name = expr_to_str_sym(one, &one_sym);
+	if (!one_name)
+		goto free;
+	two_name = expr_to_str_sym(two, &two_sym);
+	if (!two_name)
+		goto free;
+	if (one_sym != two_sym)
+		goto free;
+	/*
+	 * This is a terrible hack because expr_to_str() sometimes gives up in
+	 * the middle and just returns what it has.  If you see a () you know
+	 * the string is bogus.
+	 */
+	if (strstr(one_name, "()"))
+		goto free;
+	if (strcmp(one_name, two_name) == 0)
+		ret = 1;
+free:
+	free_string(one_name);
+	free_string(two_name);
+	return ret;
+}
+
+void push_int(struct int_stack **stack, int num)
+{
+	int *munged;
+
+	/*
+	 * Just put the int on directly instead of a pointer to the int.
+	 * Shift it to the left because Sparse uses the last two bits.
+	 * This is sort of a dirty hack, yes.
+	 */
+
+	munged = INT_PTR(num << 2);
+
+	add_ptr_list(stack, munged);
+}
+
+int pop_int(struct int_stack **stack)
+{
+	int *num;
+
+	num = last_ptr_list((struct ptr_list *)*stack);
+	delete_ptr_list_last((struct ptr_list **)stack);
+
+	return PTR_INT(num) >> 2;
+}
diff --git a/usr/src/tools/smatch/src/smatch_hooks.c b/usr/src/tools/smatch/src/smatch_hooks.c
new file mode 100644
index 0000000000..3fb50feb5b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_hooks.c
@@ -0,0 +1,368 @@
+/*
+ * Copyright (C) 2006 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+enum data_type {
+	EXPR_PTR,
+	STMT_PTR,
+	SYMBOL_PTR,
+	SYM_LIST_PTR,
+};
+
+struct hook_container {
+	int hook_type;
+	enum data_type data_type;
+	void *fn;
+};
+ALLOCATOR(hook_container, "hook functions");
+DECLARE_PTR_LIST(hook_func_list, struct hook_container);
+static struct hook_func_list *merge_funcs;
+static struct hook_func_list *unmatched_state_funcs;
+static struct hook_func_list *hook_array[NUM_HOOKS] = {};
+void (**pre_merge_hooks)(struct sm_state *sm);
+
+struct scope_container {
+	void *fn;
+	void *data;
+};
+ALLOCATOR(scope_container, "scope hook functions");
+DECLARE_PTR_LIST(scope_hook_list, struct scope_container);
+DECLARE_PTR_LIST(scope_hook_stack, struct scope_hook_list);
+static struct scope_hook_stack *scope_hooks;
+
+void add_hook(void *func, enum hook_type type)
+{
+	struct hook_container *container = __alloc_hook_container(0);
+
+	container->hook_type = type;
+	container->fn = func;
+	switch (type) {
+	case EXPR_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case STMT_HOOK:
+		container->data_type = STMT_PTR;
+		break;
+	case STMT_HOOK_AFTER:
+		container->data_type = STMT_PTR;
+		break;
+	case SYM_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case STRING_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case DECLARATION_HOOK:
+		container->data_type = SYMBOL_PTR;
+		break;
+	case ASSIGNMENT_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case ASSIGNMENT_HOOK_AFTER:
+		container->data_type = EXPR_PTR;
+		break;
+	case RAW_ASSIGNMENT_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case GLOBAL_ASSIGNMENT_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case CALL_ASSIGNMENT_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case MACRO_ASSIGNMENT_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case BINOP_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case OP_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case LOGIC_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case PRELOOP_HOOK:
+		container->data_type = STMT_PTR;
+		break;
+	case CONDITION_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case SELECT_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case WHOLE_CONDITION_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case FUNCTION_CALL_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case CALL_HOOK_AFTER_INLINE:
+		container->data_type = EXPR_PTR;
+		break;
+	case FUNCTION_CALL_HOOK_AFTER_DB:
+		container->data_type = EXPR_PTR;
+		break;
+	case DEREF_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case CASE_HOOK:
+		/* nothing needed */
+		break;
+	case ASM_HOOK:
+		container->data_type = STMT_PTR;
+		break;
+	case CAST_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case SIZEOF_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case BASE_HOOK:
+		container->data_type = SYMBOL_PTR;
+		break;
+	case FUNC_DEF_HOOK:
+		container->data_type = SYMBOL_PTR;
+		break;
+	case AFTER_DEF_HOOK:
+		container->data_type = SYMBOL_PTR;
+		break;
+	case END_FUNC_HOOK:
+		container->data_type = SYMBOL_PTR;
+		break;
+	case AFTER_FUNC_HOOK:
+		container->data_type = SYMBOL_PTR;
+		break;
+	case RETURN_HOOK:
+		container->data_type = EXPR_PTR;
+		break;
+	case INLINE_FN_START:
+		container->data_type = EXPR_PTR;
+		break;
+	case INLINE_FN_END:
+		container->data_type = EXPR_PTR;
+		break;
+	case END_FILE_HOOK:
+		container->data_type = SYM_LIST_PTR;
+		break;
+	}
+	add_ptr_list(&hook_array[type], container);
+}
+
+void add_merge_hook(int client_id, merge_func_t *func)
+{
+	struct hook_container *container = __alloc_hook_container(0);
+	container->data_type = client_id;
+	container->fn = func;
+	add_ptr_list(&merge_funcs, container);
+}
+
+void add_unmatched_state_hook(int client_id, unmatched_func_t *func)
+{
+	struct hook_container *container = __alloc_hook_container(0);
+	container->data_type = client_id;
+	container->fn = func;
+	add_ptr_list(&unmatched_state_funcs, container);
+}
+
+void add_pre_merge_hook(int client_id, void (*hook)(struct sm_state *sm))
+{
+	pre_merge_hooks[client_id] = hook;
+}
+
+static void pass_to_client(void *fn)
+{
+	typedef void (expr_func)();
+	((expr_func *) fn)();
+}
+
+static void pass_expr_to_client(void *fn, void *data)
+{
+	typedef void (expr_func)(struct expression *expr);
+	((expr_func *) fn)((struct expression *) data);
+}
+
+static void pass_stmt_to_client(void *fn, void *data)
+{
+	typedef void (stmt_func)(struct statement *stmt);
+	((stmt_func *) fn)((struct statement *) data);
+}
+
+static void pass_sym_to_client(void *fn, void *data)
+{
+	typedef void (sym_func)(struct symbol *sym);
+	((sym_func *) fn)((struct symbol *) data);
+}
+
+static void pass_sym_list_to_client(void *fn, void *data)
+{
+	typedef void (sym_func)(struct symbol_list *sym_list);
+	((sym_func *) fn)((struct symbol_list *) data);
+}
+
+void __pass_to_client(void *data, enum hook_type type)
+{
+	struct hook_container *container;
+
+
+	FOR_EACH_PTR(hook_array[type], container) {
+		switch (container->data_type) {
+		case EXPR_PTR:
+			pass_expr_to_client(container->fn, data);
+			break;
+		case STMT_PTR:
+			pass_stmt_to_client(container->fn, data);
+			break;
+		case SYMBOL_PTR:
+			pass_sym_to_client(container->fn, data);
+			break;
+		case SYM_LIST_PTR:
+			pass_sym_list_to_client(container->fn, data);
+			break;
+		}
+	} END_FOR_EACH_PTR(container);
+}
+
+void __pass_to_client_no_data(enum hook_type type)
+{
+	struct hook_container *container;
+
+	FOR_EACH_PTR(hook_array[type], container) {
+		pass_to_client(container->fn);
+	} END_FOR_EACH_PTR(container);
+}
+
+void __pass_case_to_client(struct expression *switch_expr,
+			   struct range_list *rl)
+{
+	typedef void (case_func)(struct expression *switch_expr,
+				 struct range_list *rl);
+	struct hook_container *container;
+
+	FOR_EACH_PTR(hook_array[CASE_HOOK], container) {
+		((case_func *) container->fn)(switch_expr, rl);
+	} END_FOR_EACH_PTR(container);
+}
+
+int __has_merge_function(int client_id)
+{
+	struct hook_container *tmp;
+
+	FOR_EACH_PTR(merge_funcs, tmp) {
+		if (tmp->data_type == client_id)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+struct smatch_state *__client_merge_function(int owner,
+					     struct smatch_state *s1,
+					     struct smatch_state *s2)
+{
+	struct smatch_state *tmp_state;
+	struct hook_container *tmp;
+
+	/* Pass NULL states first and the rest alphabetically by name */
+	if (!s2 || (s1 && strcmp(s2->name, s1->name) < 0)) {
+		tmp_state = s1;
+		s1 = s2;
+		s2 = tmp_state;
+	}
+
+	FOR_EACH_PTR(merge_funcs, tmp) {
+		if (tmp->data_type == owner)
+			return ((merge_func_t *) tmp->fn)(s1, s2);
+	} END_FOR_EACH_PTR(tmp);
+	return &undefined;
+}
+
+struct smatch_state *__client_unmatched_state_function(struct sm_state *sm)
+{
+	struct hook_container *tmp;
+
+	FOR_EACH_PTR(unmatched_state_funcs, tmp) {
+		if (tmp->data_type == sm->owner)
+			return ((unmatched_func_t *) tmp->fn)(sm);
+	} END_FOR_EACH_PTR(tmp);
+	return &undefined;
+}
+
+void call_pre_merge_hook(struct sm_state *sm)
+{
+	if (sm->owner >= num_checks)
+		return;
+
+	if (pre_merge_hooks[sm->owner])
+		pre_merge_hooks[sm->owner](sm);
+}
+
+static struct scope_hook_list *pop_scope_hook_list(struct scope_hook_stack **stack)
+{
+	struct scope_hook_list *hook_list;
+
+	hook_list = last_ptr_list((struct ptr_list *)*stack);
+	delete_ptr_list_last((struct ptr_list **)stack);
+	return hook_list;
+}
+
+static void push_scope_hook_list(struct scope_hook_stack **stack, struct scope_hook_list *l)
+{
+	add_ptr_list(stack, l);
+}
+
+void add_scope_hook(scope_hook *fn, void *data)
+{
+	struct scope_hook_list *hook_list;
+	struct scope_container *new;
+
+	if (!scope_hooks)
+		return;
+	hook_list = pop_scope_hook_list(&scope_hooks);
+	new = __alloc_scope_container(0);
+	new->fn = fn;
+	new->data = data;
+	add_ptr_list(&hook_list, new);
+	push_scope_hook_list(&scope_hooks, hook_list);
+}
+
+void __push_scope_hooks(void)
+{
+	push_scope_hook_list(&scope_hooks, NULL);
+}
+
+void __call_scope_hooks(void)
+{
+	struct scope_hook_list *hook_list;
+	struct scope_container *tmp;
+
+	if (!scope_hooks)
+		return;
+
+	hook_list = pop_scope_hook_list(&scope_hooks);
+	FOR_EACH_PTR(hook_list, tmp) {
+		((scope_hook *) tmp->fn)(tmp->data);
+		__free_scope_container(tmp);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+void allocate_hook_memory(void)
+{
+	pre_merge_hooks = malloc(num_checks * sizeof(*pre_merge_hooks));
+	memset(pre_merge_hooks, 0, num_checks * sizeof(*pre_merge_hooks));
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_ignore.c b/usr/src/tools/smatch/src/smatch_ignore.c
new file mode 100644
index 0000000000..eb06a0512a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_ignore.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+STATE(ignore);
+static struct stree *ignored;
+
+void add_ignore(int owner, const char *name, struct symbol *sym)
+{
+	set_state_stree(&ignored, owner, name, sym, &ignore);
+}
+
+int is_ignored(int owner, const char *name, struct symbol *sym)
+{
+	return !!get_state_stree(ignored, owner, name, sym);
+}
+
+void add_ignore_expr(int owner, struct expression *expr)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = expr_to_str_sym(expr, &sym);
+	if (!name || !sym)
+		return;
+	add_ignore(owner, name, sym);
+	free_string(name);
+}
+
+int is_ignored_expr(int owner, struct expression *expr)
+{
+	struct symbol *sym;
+	char *name;
+	int ret;
+
+	name = expr_to_str_sym(expr, &sym);
+	if (!name && !sym)
+		return 0;
+	ret = is_ignored(owner, name, sym);
+	free_string(name);
+	return ret;
+}
+
+static void clear_ignores(void)
+{
+	if (__inline_fn)
+		return;
+	free_stree(&ignored);
+}
+
+void register_smatch_ignore(int id)
+{
+	add_hook(&clear_ignores, AFTER_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_imaginary_absolute.c b/usr/src/tools/smatch/src/smatch_imaginary_absolute.c
new file mode 100644
index 0000000000..6532dfc397
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_imaginary_absolute.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2016 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Say you have a condition like:
+ *
+ *     if (foo < 0)
+ *         return foo;
+ *
+ * But we actually know that foo is zero.  Then in smatch_extra.c we set "foo"
+ * to the empty state and then for the return statement we say that "foo" is
+ * s32min-s32max because we can't return the empty state.
+ *
+ * This file is supposed to provide an alternative to say that actually "foo" is
+ * less than zero.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static struct smatch_state *empty_state(struct sm_state *sm)
+{
+	return alloc_estate_empty();
+}
+
+struct smatch_state *merge_is_empty(struct smatch_state *s1, struct smatch_state *s2)
+{
+	return alloc_estate_empty();
+}
+
+static void reset(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, alloc_estate_empty());
+}
+
+void __save_imaginary_state(struct expression *expr, struct range_list *true_rl, struct range_list *false_rl)
+{
+	set_true_false_states_expr(my_id, expr, alloc_estate_rl(true_rl), alloc_estate_rl(false_rl));
+}
+
+int get_imaginary_absolute(struct expression *expr, struct range_list **rl)
+{
+	struct smatch_state *state;
+
+	*rl = NULL;
+
+	state = get_state_expr(my_id, expr);
+	if (!state || !estate_rl(state))
+		return 0;
+
+	*rl = estate_rl(state);
+	return 1;
+}
+
+void register_imaginary_absolute(int id)
+{
+	my_id = id;
+
+	add_unmatched_state_hook(my_id, &empty_state);
+	add_merge_hook(my_id, &merge_is_empty);
+	add_modification_hook(my_id, &reset);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_implied.c b/usr/src/tools/smatch/src/smatch_implied.c
new file mode 100644
index 0000000000..441920c17d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_implied.c
@@ -0,0 +1,1116 @@
+/*
+ * Copyright (C) 2008 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Imagine we have this code:
+ * foo = 1;
+ * if (bar)
+ *         foo = 99;
+ * else
+ *         frob();
+ *                   //  <-- point #1
+ * if (foo == 99)    //  <-- point #2
+ *         bar->baz; //  <-- point #3
+ *
+ *
+ * At point #3 bar is non null and can be dereferenced.
+ *
+ * It's smatch_implied.c which sets bar to non null at point #2.
+ *
+ * At point #1 merge_slist() stores the list of states from both
+ * the true and false paths.  On the true path foo == 99 and on
+ * the false path foo == 1.  merge_slist() sets their pool
+ * list to show the other states which were there when foo == 99.
+ *
+ * When it comes to the if (foo == 99) the smatch implied hook
+ * looks for all the pools where foo was not 99.  It makes a list
+ * of those.
+ *
+ * Then for bar (and all the other states) it says, ok bar is a
+ * merged state that came from these previous states.  We'll
+ * chop out all the states where it came from a pool where
+ * foo != 99 and merge it all back together.
+ *
+ * That is the implied state of bar.
+ *
+ * merge_slist() sets up ->pool.  An sm_state only has one ->pool and
+ *    that is the pool where it was first set.  The my pool gets set when
+ *    code paths merge.  States that have been set since the last merge do
+ *    not have a ->pool.
+ * merge_sm_state() sets ->left and ->right.  (These are the states which were
+ *    merged to form the current state.)
+ * a pool:  a pool is an slist that has been merged with another slist.
+ */
+
+#include <sys/time.h>
+#include <time.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+char *implied_debug_msg;
+#define DIMPLIED(msg...) do { if (option_debug_implied || option_debug) printf(msg); } while (0)
+
+int option_debug_implied = 0;
+
+/*
+ * tmp_range_list():
+ * It messes things up to free range list allocations.  This helper fuction
+ * lets us reuse memory instead of doing new allocations.
+ */
+static struct range_list *tmp_range_list(struct symbol *type, long long num)
+{
+	static struct range_list *my_list = NULL;
+	static struct data_range *my_range;
+
+	__free_ptr_list((struct ptr_list **)&my_list);
+	my_range = alloc_range(ll_to_sval(num), ll_to_sval(num));
+	add_ptr_list(&my_list, my_range);
+	return my_list;
+}
+
+static void print_debug_tf(struct sm_state *sm, int istrue, int isfalse)
+{
+	if (!option_debug_implied && !option_debug)
+		return;
+
+	if (istrue && isfalse) {
+		printf("%s: %d: does not exist.\n", show_sm(sm), sm->line);
+	} else if (istrue) {
+		printf("'%s = %s' from %d is true. %s[stree %d]\n", sm->name, show_state(sm->state),
+			sm->line, sm->merged ? "[merged]" : "[leaf]",
+			get_stree_id(sm->pool));
+	} else if (isfalse) {
+		printf("'%s = %s' from %d is false. %s[stree %d]\n", sm->name, show_state(sm->state),
+			sm->line,
+			sm->merged ? "[merged]" : "[leaf]",
+			get_stree_id(sm->pool));
+	} else {
+		printf("'%s = %s' from %d could be true or false. %s[stree %d]\n", sm->name,
+			show_state(sm->state), sm->line,
+			sm->merged ? "[merged]" : "[leaf]",
+			get_stree_id(sm->pool));
+	}
+}
+
+static int create_fake_history(struct sm_state *sm, int comparison, struct range_list *rl)
+{
+	struct range_list *orig_rl;
+	struct range_list *true_rl, *false_rl;
+	struct stree *true_stree, *false_stree;
+	struct sm_state *true_sm, *false_sm;
+	sval_t sval;
+
+	if (is_merged(sm) || sm->left || sm->right)
+		return 0;
+	if (!rl_to_sval(rl, &sval))
+		return 0;
+	if (!estate_rl(sm->state))
+		return 0;
+
+	orig_rl = cast_rl(rl_type(rl), estate_rl(sm->state));
+	split_comparison_rl(orig_rl, comparison, rl, &true_rl, &false_rl, NULL, NULL);
+
+	true_rl = rl_truncate_cast(estate_type(sm->state), true_rl);
+	false_rl = rl_truncate_cast(estate_type(sm->state), false_rl);
+	if (is_whole_rl(true_rl) || is_whole_rl(false_rl) ||
+	    !true_rl || !false_rl ||
+	    rl_equiv(orig_rl, true_rl) || rl_equiv(orig_rl, false_rl) ||
+	    rl_equiv(estate_rl(sm->state), true_rl) || rl_equiv(estate_rl(sm->state), false_rl))
+		return 0;
+
+	if (rl_intersection(true_rl, false_rl)) {
+		sm_perror("parsing (%s (%s) %s %s)",
+			sm->name, sm->state->name, show_special(comparison), show_rl(rl));
+		sm_msg("true_rl = %s false_rl = %s intersection = %s",
+		       show_rl(true_rl), show_rl(false_rl), show_rl(rl_intersection(true_rl, false_rl)));
+		return 0;
+	}
+
+	if (option_debug)
+		sm_info("fake_history: %s vs %s.  %s %s %s. --> T: %s F: %s",
+		       sm->name, show_rl(rl), sm->state->name, show_special(comparison), show_rl(rl),
+		       show_rl(true_rl), show_rl(false_rl));
+
+	true_sm = clone_sm(sm);
+	false_sm = clone_sm(sm);
+
+	true_sm->state = alloc_estate_rl(cast_rl(estate_type(sm->state), true_rl));
+	free_slist(&true_sm->possible);
+	add_possible_sm(true_sm, true_sm);
+	false_sm->state = alloc_estate_rl(cast_rl(estate_type(sm->state), false_rl));
+	free_slist(&false_sm->possible);
+	add_possible_sm(false_sm, false_sm);
+
+	true_stree = clone_stree(sm->pool);
+	false_stree = clone_stree(sm->pool);
+
+	overwrite_sm_state_stree(&true_stree, true_sm);
+	overwrite_sm_state_stree(&false_stree, false_sm);
+
+	true_sm->pool = true_stree;
+	false_sm->pool = false_stree;
+
+	sm->merged = 1;
+	sm->left = true_sm;
+	sm->right = false_sm;
+
+	return 1;
+}
+
+/*
+ * add_pool() adds a slist to *pools. If the slist has already been
+ * added earlier then it doesn't get added a second time.
+ */
+void add_pool(struct state_list **pools, struct sm_state *new)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(*pools, tmp) {
+		if (tmp->pool < new->pool)
+			continue;
+		else if (tmp->pool == new->pool) {
+			return;
+		} else {
+			INSERT_CURRENT(new, tmp);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+	add_ptr_list(pools, new);
+}
+
+static int pool_in_pools(struct stree *pool,
+			 const struct state_list *slist)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(slist, tmp) {
+		if (!tmp->pool)
+			continue;
+		if (tmp->pool == pool)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static int remove_pool(struct state_list **pools, struct stree *remove)
+{
+	struct sm_state *tmp;
+	int ret = 0;
+
+	FOR_EACH_PTR(*pools, tmp) {
+		if (tmp->pool == remove) {
+			DELETE_CURRENT_PTR(tmp);
+			ret = 1;
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+	return ret;
+}
+
+/*
+ * If 'foo' == 99 add it that pool to the true pools.  If it's false, add it to
+ * the false pools.  If we're not sure, then we don't add it to either.
+ */
+static void do_compare(struct sm_state *sm, int comparison, struct range_list *rl,
+			struct state_list **true_stack,
+			struct state_list **maybe_stack,
+			struct state_list **false_stack,
+			int *mixed, struct sm_state *gate_sm)
+{
+	int istrue;
+	int isfalse;
+	struct range_list *var_rl;
+
+	if (!sm->pool)
+		return;
+
+	var_rl = cast_rl(rl_type(rl), estate_rl(sm->state));
+
+	istrue = !possibly_false_rl(var_rl, comparison, rl);
+	isfalse = !possibly_true_rl(var_rl, comparison, rl);
+
+	print_debug_tf(sm, istrue, isfalse);
+
+	/* give up if we have borrowed implications (smatch_equiv.c) */
+	if (sm->sym != gate_sm->sym ||
+	    strcmp(sm->name, gate_sm->name) != 0) {
+		if (mixed)
+			*mixed = 1;
+	}
+
+	if (mixed && !*mixed && !is_merged(sm) && !istrue && !isfalse) {
+		if (!create_fake_history(sm, comparison, rl))
+			*mixed = 1;
+	}
+
+	if (istrue)
+		add_pool(true_stack, sm);
+	else if (isfalse)
+		add_pool(false_stack, sm);
+	else
+		add_pool(maybe_stack, sm);
+
+}
+
+static int is_checked(struct state_list *checked, struct sm_state *sm)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(checked, tmp) {
+		if (tmp == sm)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+/*
+ * separate_pools():
+ * Example code:  if (foo == 99) {
+ *
+ * Say 'foo' is a merged state that has many possible values.  It is the combination
+ * of merges.  separate_pools() iterates through the pools recursively and calls
+ * do_compare() for each time 'foo' was set.
+ */
+static void __separate_pools(struct sm_state *sm, int comparison, struct range_list *rl,
+			struct state_list **true_stack,
+			struct state_list **maybe_stack,
+			struct state_list **false_stack,
+			struct state_list **checked, int *mixed, struct sm_state *gate_sm)
+{
+	int free_checked = 0;
+	struct state_list *checked_states = NULL;
+
+	if (!sm)
+		return;
+
+	/*
+	 * If it looks like this is going to take too long as-is, then don't
+	 * create even more fake history.
+	 */
+	if (mixed && sm->nr_children > 100)
+		*mixed = 1;
+
+	/*
+	   Sometimes the implications are just too big to deal with
+	   so we bail.  Theoretically, bailing out here can cause more false
+	   positives but won't hide actual bugs.
+	*/
+	if (sm->nr_children > 4000) {
+		if (option_debug || option_debug_implied) {
+			static char buf[1028];
+			snprintf(buf, sizeof(buf), "debug: %s: nr_children over 4000 (%d). (%s %s)",
+				 __func__, sm->nr_children, sm->name, show_state(sm->state));
+			implied_debug_msg = buf;
+		}
+		return;
+	}
+
+	if (checked == NULL) {
+		checked = &checked_states;
+		free_checked = 1;
+	}
+	if (is_checked(*checked, sm))
+		return;
+	add_ptr_list(checked, sm);
+
+	do_compare(sm, comparison, rl, true_stack, maybe_stack, false_stack, mixed, gate_sm);
+
+	__separate_pools(sm->left, comparison, rl, true_stack, maybe_stack, false_stack, checked, mixed, gate_sm);
+	__separate_pools(sm->right, comparison, rl, true_stack, maybe_stack, false_stack, checked, mixed, gate_sm);
+	if (free_checked)
+		free_slist(checked);
+}
+
+static void separate_pools(struct sm_state *sm, int comparison, struct range_list *rl,
+			struct state_list **true_stack,
+			struct state_list **false_stack,
+			struct state_list **checked, int *mixed)
+{
+	struct state_list *maybe_stack = NULL;
+	struct sm_state *tmp;
+
+	__separate_pools(sm, comparison, rl, true_stack, &maybe_stack, false_stack, checked, mixed, sm);
+
+	if (option_debug) {
+		struct sm_state *sm;
+
+		FOR_EACH_PTR(*true_stack, sm) {
+			sm_msg("TRUE %s [stree %d]", show_sm(sm), get_stree_id(sm->pool));
+		} END_FOR_EACH_PTR(sm);
+
+		FOR_EACH_PTR(maybe_stack, sm) {
+			sm_msg("MAYBE %s [stree %d]", show_sm(sm), get_stree_id(sm->pool));
+		} END_FOR_EACH_PTR(sm);
+
+		FOR_EACH_PTR(*false_stack, sm) {
+			sm_msg("FALSE %s [stree %d]", show_sm(sm), get_stree_id(sm->pool));
+		} END_FOR_EACH_PTR(sm);
+	}
+	/* if it's a maybe then remove it */
+	FOR_EACH_PTR(maybe_stack, tmp) {
+		remove_pool(false_stack, tmp->pool);
+		remove_pool(true_stack, tmp->pool);
+	} END_FOR_EACH_PTR(tmp);
+
+	/* if it's both true and false remove it from both */
+	FOR_EACH_PTR(*true_stack, tmp) {
+		if (remove_pool(false_stack, tmp->pool))
+			DELETE_CURRENT_PTR(tmp);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static int sm_in_keep_leafs(struct sm_state *sm, const struct state_list *keep_gates)
+{
+	struct sm_state *tmp, *old;
+
+	FOR_EACH_PTR(keep_gates, tmp) {
+		if (is_merged(tmp))
+			continue;
+		old = get_sm_state_stree(tmp->pool, sm->owner, sm->name, sm->sym);
+		if (!old)
+			continue;
+		if (old == sm)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static int taking_too_long(void)
+{
+	static void *printed;
+
+	if (out_of_memory())
+		return 1;
+
+	if (time_parsing_function() < 60)
+		return 0;
+
+	if (!__inline_fn && printed != cur_func_sym) {
+		if (!is_skipped_function())
+			sm_perror("turning off implications after 60 seconds");
+		printed = cur_func_sym;
+	}
+	return 1;
+}
+
+/*
+ * NOTE: If a state is in both the keep stack and the remove stack then that is
+ * a bug.  Only add states which are definitely true or definitely false.  If
+ * you have a leaf state that could be both true and false, then create a fake
+ * split history where one side is true and one side is false.  Otherwise, if
+ * you can't do that, then don't add it to either list.
+ */
+struct sm_state *filter_pools(struct sm_state *sm,
+			      const struct state_list *remove_stack,
+			      const struct state_list *keep_stack,
+			      int *modified, int *recurse_cnt,
+			      struct timeval *start)
+{
+	struct sm_state *ret = NULL;
+	struct sm_state *left;
+	struct sm_state *right;
+	int removed = 0;
+	struct timeval now;
+
+	if (!sm)
+		return NULL;
+	if (sm->skip_implications)
+		return sm;
+	if (taking_too_long())
+		return sm;
+
+	gettimeofday(&now, NULL);
+	if ((*recurse_cnt)++ > 1000 || now.tv_sec - start->tv_sec > 5) {
+		if (local_debug || option_debug_implied) {
+			static char buf[1028];
+			snprintf(buf, sizeof(buf), "debug: %s: nr_children over 4000 (%d). (%s %s)",
+				 __func__, sm->nr_children, sm->name, show_state(sm->state));
+			implied_debug_msg = buf;
+		}
+		sm->skip_implications = 1;
+		return sm;
+	}
+
+	if (pool_in_pools(sm->pool, remove_stack)) {
+		DIMPLIED("removed [stree %d] %s from %d\n", get_stree_id(sm->pool), show_sm(sm), sm->line);
+		*modified = 1;
+		return NULL;
+	}
+
+	if (!is_merged(sm) || pool_in_pools(sm->pool, keep_stack) || sm_in_keep_leafs(sm, keep_stack)) {
+		DIMPLIED("kept [stree %d] %s from %d. %s. %s. %s.\n", get_stree_id(sm->pool), show_sm(sm), sm->line,
+			is_merged(sm) ? "merged" : "not merged",
+			pool_in_pools(sm->pool, keep_stack) ? "not in keep pools" : "in keep pools",
+			sm_in_keep_leafs(sm, keep_stack) ? "reachable keep leaf" : "no keep leaf");
+		return sm;
+	}
+
+	DIMPLIED("checking [stree %d] %s from %d (%d) left = %s [stree %d] right = %s [stree %d]\n",
+		 get_stree_id(sm->pool),
+		 show_sm(sm), sm->line, sm->nr_children,
+		 sm->left ? sm->left->state->name : "<none>", sm->left ? get_stree_id(sm->left->pool) : -1,
+		 sm->right ? sm->right->state->name : "<none>", sm->right ? get_stree_id(sm->right->pool) : -1);
+	left = filter_pools(sm->left, remove_stack, keep_stack, &removed, recurse_cnt, start);
+	right = filter_pools(sm->right, remove_stack, keep_stack, &removed, recurse_cnt, start);
+	if (!removed) {
+		DIMPLIED("kept [stree %d] %s from %d\n", get_stree_id(sm->pool), show_sm(sm), sm->line);
+		return sm;
+	}
+	*modified = 1;
+	if (!left && !right) {
+		DIMPLIED("removed [stree %d] %s from %d <none>\n", get_stree_id(sm->pool), show_sm(sm), sm->line);
+		return NULL;
+	}
+
+	if (!left) {
+		ret = clone_sm(right);
+		ret->merged = 1;
+		ret->right = right;
+		ret->left = NULL;
+	} else if (!right) {
+		ret = clone_sm(left);
+		ret->merged = 1;
+		ret->left = left;
+		ret->right = NULL;
+	} else {
+		if (left->sym != sm->sym || strcmp(left->name, sm->name) != 0) {
+			left = clone_sm(left);
+			left->sym = sm->sym;
+			left->name = sm->name;
+		}
+		if (right->sym != sm->sym || strcmp(right->name, sm->name) != 0) {
+			right = clone_sm(right);
+			right->sym = sm->sym;
+			right->name = sm->name;
+		}
+		ret = merge_sm_states(left, right);
+	}
+
+	ret->pool = sm->pool;
+
+	DIMPLIED("partial %s => ", show_sm(sm));
+	DIMPLIED("%s from %d [stree %d]\n", show_sm(ret), sm->line, get_stree_id(sm->pool));
+	return ret;
+}
+
+static struct stree *filter_stack(struct sm_state *gate_sm,
+				       struct stree *pre_stree,
+				       const struct state_list *remove_stack,
+				       const struct state_list *keep_stack)
+{
+	struct stree *ret = NULL;
+	struct sm_state *tmp;
+	struct sm_state *filtered_sm;
+	int modified;
+	int recurse_cnt;
+	struct timeval start;
+
+	if (!remove_stack)
+		return NULL;
+
+	if (taking_too_long())
+		return NULL;
+
+	FOR_EACH_SM(pre_stree, tmp) {
+		if (option_debug)
+			sm_msg("%s: %s", __func__, show_sm(tmp));
+		if (!tmp->merged)
+			continue;
+		if (sm_in_keep_leafs(tmp, keep_stack))
+			continue;
+		modified = 0;
+		recurse_cnt = 0;
+		gettimeofday(&start, NULL);
+		filtered_sm = filter_pools(tmp, remove_stack, keep_stack, &modified, &recurse_cnt, &start);
+		if (!filtered_sm || !modified)
+			continue;
+		/* the assignments here are for borrowed implications */
+		filtered_sm->name = tmp->name;
+		filtered_sm->sym = tmp->sym;
+		avl_insert(&ret, filtered_sm);
+		if (out_of_memory() || taking_too_long())
+			return NULL;
+
+	} END_FOR_EACH_SM(tmp);
+	return ret;
+}
+
+static void separate_and_filter(struct sm_state *sm, int comparison, struct range_list *rl,
+		struct stree *pre_stree,
+		struct stree **true_states,
+		struct stree **false_states,
+		int *mixed)
+{
+	struct state_list *true_stack = NULL;
+	struct state_list *false_stack = NULL;
+	struct timeval time_before;
+	struct timeval time_after;
+	int sec;
+
+	gettimeofday(&time_before, NULL);
+
+	if (!is_merged(sm)) {
+		DIMPLIED("%d '%s' is not merged.\n", get_lineno(), sm->name);
+		return;
+	}
+
+	if (option_debug_implied || option_debug) {
+		sm_msg("checking implications: (%s %s %s)",
+		       sm->name, show_special(comparison), show_rl(rl));
+	}
+
+	separate_pools(sm, comparison, rl, &true_stack, &false_stack, NULL, mixed);
+
+	DIMPLIED("filtering true stack.\n");
+	*true_states = filter_stack(sm, pre_stree, false_stack, true_stack);
+	DIMPLIED("filtering false stack.\n");
+	*false_states = filter_stack(sm, pre_stree, true_stack, false_stack);
+	free_slist(&true_stack);
+	free_slist(&false_stack);
+	if (option_debug_implied || option_debug) {
+		printf("These are the implied states for the true path: (%s %s %s)\n",
+		       sm->name, show_special(comparison), show_rl(rl));
+		__print_stree(*true_states);
+		printf("These are the implied states for the false path: (%s %s %s)\n",
+		       sm->name, show_special(comparison), show_rl(rl));
+		__print_stree(*false_states);
+	}
+
+	gettimeofday(&time_after, NULL);
+	sec = time_after.tv_sec - time_before.tv_sec;
+	if (sec > 20) {
+		sm->nr_children = 4000;
+		sm_perror("Function too hairy.  Ignoring implications after %d seconds.", sec);
+	}
+}
+
+static struct expression *get_last_expr(struct statement *stmt)
+{
+	struct statement *last;
+
+	last = last_ptr_list((struct ptr_list *)stmt->stmts);
+	if (last->type == STMT_EXPRESSION)
+		return last->expression;
+
+	if (last->type == STMT_LABEL) {
+		if (last->label_statement &&
+		    last->label_statement->type == STMT_EXPRESSION)
+			return last->label_statement->expression;
+	}
+
+	return NULL;
+}
+
+static struct expression *get_left_most_expr(struct expression *expr)
+{
+	struct statement *compound;
+
+	compound = get_expression_statement(expr);
+	if (compound)
+		return get_last_expr(compound);
+
+	expr = strip_parens(expr);
+	if (expr->type == EXPR_ASSIGNMENT)
+		return get_left_most_expr(expr->left);
+	return expr;
+}
+
+static int is_merged_expr(struct expression  *expr)
+{
+	struct sm_state *sm;
+	sval_t dummy;
+
+	if (get_value(expr, &dummy))
+		return 0;
+	sm = get_sm_state_expr(SMATCH_EXTRA, expr);
+	if (!sm)
+		return 0;
+	if (is_merged(sm))
+		return 1;
+	return 0;
+}
+
+static void delete_gate_sm_equiv(struct stree **stree, const char *name, struct symbol *sym)
+{
+	struct smatch_state *state;
+	struct relation *rel;
+
+	state = get_state(SMATCH_EXTRA, name, sym);
+	if (!state)
+		return;
+	FOR_EACH_PTR(estate_related(state), rel) {
+		delete_state_stree(stree, SMATCH_EXTRA, rel->name, rel->sym);
+	} END_FOR_EACH_PTR(rel);
+}
+
+static void delete_gate_sm(struct stree **stree, const char *name, struct symbol *sym)
+{
+	delete_state_stree(stree, SMATCH_EXTRA, name, sym);
+}
+
+static int handle_comparison(struct expression *expr,
+			      struct stree **implied_true,
+			      struct stree **implied_false)
+{
+	struct sm_state *sm = NULL;
+	struct range_list *rl = NULL;
+	struct expression *left;
+	struct expression *right;
+	struct symbol *type;
+	int comparison = expr->op;
+	int mixed = 0;
+
+	left = get_left_most_expr(expr->left);
+	right = get_left_most_expr(expr->right);
+
+	if (is_merged_expr(left)) {
+		sm = get_sm_state_expr(SMATCH_EXTRA, left);
+		get_implied_rl(right, &rl);
+	} else if (is_merged_expr(right)) {
+		sm = get_sm_state_expr(SMATCH_EXTRA, right);
+		get_implied_rl(left, &rl);
+		comparison = flip_comparison(comparison);
+	}
+
+	if (!rl || !sm)
+		return 0;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+	if (type_positive_bits(rl_type(rl)) > type_positive_bits(type))
+		type = rl_type(rl);
+	if (type_positive_bits(type) < 31)
+		type = &int_ctype;
+	rl = cast_rl(type, rl);
+
+	separate_and_filter(sm, comparison, rl, __get_cur_stree(), implied_true, implied_false, &mixed);
+
+	delete_gate_sm_equiv(implied_true, sm->name, sm->sym);
+	delete_gate_sm_equiv(implied_false, sm->name, sm->sym);
+	if (mixed) {
+		delete_gate_sm(implied_true, sm->name, sm->sym);
+		delete_gate_sm(implied_false, sm->name, sm->sym);
+	}
+
+	return 1;
+}
+
+static int handle_zero_comparison(struct expression *expr,
+				struct stree **implied_true,
+				struct stree **implied_false)
+{
+	struct symbol *sym;
+	char *name;
+	struct sm_state *sm;
+	int mixed = 0;
+	int ret = 0;
+
+	if (expr->type == EXPR_POSTOP)
+		expr = strip_expr(expr->unop);
+
+	if (expr->type == EXPR_ASSIGNMENT) {
+		/* most of the time ->pools will be empty here because we
+		   just set the state, but if have assigned a conditional
+		   function there are implications. */
+		expr = expr->left;
+	}
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	sm = get_sm_state(SMATCH_EXTRA, name, sym);
+	if (!sm)
+		goto free;
+
+	separate_and_filter(sm, SPECIAL_NOTEQUAL, tmp_range_list(estate_type(sm->state), 0), __get_cur_stree(), implied_true, implied_false, &mixed);
+	delete_gate_sm_equiv(implied_true, sm->name, sm->sym);
+	delete_gate_sm_equiv(implied_false, sm->name, sm->sym);
+	if (mixed) {
+		delete_gate_sm(implied_true, sm->name, sm->sym);
+		delete_gate_sm(implied_false, sm->name, sm->sym);
+	}
+
+	ret = 1;
+free:
+	free_string(name);
+	return ret;
+}
+
+static int handled_by_comparison_hook(struct expression *expr,
+				   struct stree **implied_true,
+				   struct stree **implied_false)
+{
+	struct state_list *true_stack = NULL;
+	struct state_list *false_stack = NULL;
+	struct stree *pre_stree;
+	struct sm_state *sm;
+
+	sm = comparison_implication_hook(expr, &true_stack, &false_stack);
+	if (!sm)
+		return 0;
+
+	pre_stree = clone_stree(__get_cur_stree());
+
+	*implied_true = filter_stack(sm, pre_stree, false_stack, true_stack);
+	*implied_false = filter_stack(sm, pre_stree, true_stack, false_stack);
+
+	free_stree(&pre_stree);
+	free_slist(&true_stack);
+	free_slist(&false_stack);
+
+	return 1;
+}
+
+static int handled_by_extra_states(struct expression *expr,
+				   struct stree **implied_true,
+				   struct stree **implied_false)
+{
+	if (expr->type == EXPR_COMPARE)
+		return handle_comparison(expr, implied_true, implied_false);
+	else
+		return handle_zero_comparison(expr, implied_true, implied_false);
+}
+
+static int handled_by_stored_conditions(struct expression *expr,
+					struct stree **implied_true,
+					struct stree **implied_false)
+{
+	struct state_list *true_stack = NULL;
+	struct state_list *false_stack = NULL;
+	struct stree *pre_stree;
+	struct sm_state *sm;
+
+	sm = stored_condition_implication_hook(expr, &true_stack, &false_stack);
+	if (!sm)
+		return 0;
+
+	pre_stree = clone_stree(__get_cur_stree());
+
+	*implied_true = filter_stack(sm, pre_stree, false_stack, true_stack);
+	*implied_false = filter_stack(sm, pre_stree, true_stack, false_stack);
+
+	free_stree(&pre_stree);
+	free_slist(&true_stack);
+	free_slist(&false_stack);
+
+	return 1;
+}
+
+static int found_implications;
+static struct stree *saved_implied_true;
+static struct stree *saved_implied_false;
+static struct stree *extra_saved_implied_true;
+static struct stree *extra_saved_implied_false;
+
+static void separate_extra_states(struct stree **implied_true,
+				  struct stree **implied_false)
+{
+	struct sm_state *sm;
+
+	/* We process extra states later to preserve the implications. */
+	FOR_EACH_SM(*implied_true, sm) {
+		if (sm->owner == SMATCH_EXTRA)
+			overwrite_sm_state_stree(&extra_saved_implied_true, sm);
+	} END_FOR_EACH_SM(sm);
+	FOR_EACH_SM(extra_saved_implied_true, sm) {
+		delete_state_stree(implied_true, sm->owner, sm->name, sm->sym);
+	} END_FOR_EACH_SM(sm);
+
+	FOR_EACH_SM(*implied_false, sm) {
+		if (sm->owner == SMATCH_EXTRA)
+			overwrite_sm_state_stree(&extra_saved_implied_false, sm);
+	} END_FOR_EACH_SM(sm);
+	FOR_EACH_SM(extra_saved_implied_false, sm) {
+		delete_state_stree(implied_false, sm->owner, sm->name, sm->sym);
+	} END_FOR_EACH_SM(sm);
+}
+
+static void get_tf_states(struct expression *expr,
+			  struct stree **implied_true,
+			  struct stree **implied_false)
+{
+	if (handled_by_comparison_hook(expr, implied_true, implied_false))
+		goto found;
+
+	if (handled_by_extra_states(expr, implied_true, implied_false)) {
+		separate_extra_states(implied_true, implied_false);
+		goto found;
+	}
+
+	if (handled_by_stored_conditions(expr, implied_true, implied_false))
+		goto found;
+
+	return;
+found:
+	found_implications = 1;
+}
+
+static void save_implications_hook(struct expression *expr)
+{
+	if (taking_too_long())
+		return;
+	get_tf_states(expr, &saved_implied_true, &saved_implied_false);
+}
+
+static void set_implied_states(struct expression *expr)
+{
+	struct sm_state *sm;
+
+	FOR_EACH_SM(saved_implied_true, sm) {
+		__set_true_false_sm(sm, NULL);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&saved_implied_true);
+
+	FOR_EACH_SM(saved_implied_false, sm) {
+		__set_true_false_sm(NULL, sm);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&saved_implied_false);
+}
+
+static void set_extra_implied_states(struct expression *expr)
+{
+	saved_implied_true = extra_saved_implied_true;
+	saved_implied_false = extra_saved_implied_false;
+	extra_saved_implied_true = NULL;
+	extra_saved_implied_false = NULL;
+	set_implied_states(NULL);
+}
+
+void param_limit_implications(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+	struct symbol *compare_type;
+	char *name;
+	struct symbol *sym;
+	struct sm_state *sm;
+	struct sm_state *tmp;
+	struct stree *implied_true = NULL;
+	struct stree *implied_false = NULL;
+	struct range_list *orig, *limit;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+
+	arg = strip_parens(arg);
+	while (arg->type == EXPR_ASSIGNMENT && arg->op == '=')
+		arg = strip_parens(arg->left);
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	sm = get_sm_state(SMATCH_EXTRA, name, sym);
+	if (!sm || !sm->merged)
+		goto free;
+
+	if (strcmp(key, "$") == 0)
+		compare_type = get_arg_type(expr->fn, param);
+	else
+		compare_type = get_member_type_from_key(arg, key);
+
+	orig = estate_rl(sm->state);
+	orig = cast_rl(compare_type, orig);
+
+	call_results_to_rl(expr, compare_type, value, &limit);
+
+	separate_and_filter(sm, SPECIAL_EQUAL, limit, __get_cur_stree(), &implied_true, &implied_false, NULL);
+
+	FOR_EACH_SM(implied_true, tmp) {
+		__set_sm_fake_stree(tmp);
+	} END_FOR_EACH_SM(tmp);
+
+	free_stree(&implied_true);
+	free_stree(&implied_false);
+free:
+	free_string(name);
+}
+
+struct stree *__implied_case_stree(struct expression *switch_expr,
+				   struct range_list *rl,
+				   struct range_list_stack **remaining_cases,
+				   struct stree **raw_stree)
+{
+	char *name;
+	struct symbol *sym;
+	struct var_sym_list *vsl;
+	struct sm_state *sm;
+	struct stree *true_states = NULL;
+	struct stree *false_states = NULL;
+	struct stree *extra_states;
+	struct stree *ret = clone_stree(*raw_stree);
+
+	name = expr_to_chunk_sym_vsl(switch_expr, &sym, &vsl);
+
+	if (rl)
+		filter_top_rl(remaining_cases, rl);
+	else
+		rl = clone_rl(top_rl(*remaining_cases));
+
+	if (name) {
+		sm = get_sm_state_stree(*raw_stree, SMATCH_EXTRA, name, sym);
+		if (sm)
+			separate_and_filter(sm, SPECIAL_EQUAL, rl, *raw_stree, &true_states, &false_states, NULL);
+	}
+
+	__push_fake_cur_stree();
+	__unnullify_path();
+	if (name)
+		set_extra_nomod_vsl(name, sym, vsl, NULL, alloc_estate_rl(rl));
+	__pass_case_to_client(switch_expr, rl);
+	extra_states = __pop_fake_cur_stree();
+	overwrite_stree(extra_states, &true_states);
+	overwrite_stree(true_states, &ret);
+	free_stree(&extra_states);
+	free_stree(&true_states);
+	free_stree(&false_states);
+
+	free_string(name);
+	return ret;
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	implied_debug_msg = NULL;
+}
+
+static void get_tf_stacks_from_pool(struct sm_state *gate_sm,
+				    struct sm_state *pool_sm,
+				    struct state_list **true_stack,
+				    struct state_list **false_stack)
+{
+	struct sm_state *tmp;
+	int possibly_true = 0;
+
+	if (!gate_sm)
+		return;
+
+	if (strcmp(gate_sm->state->name, pool_sm->state->name) == 0) {
+		add_ptr_list(true_stack, pool_sm);
+		return;
+	}
+
+	FOR_EACH_PTR(gate_sm->possible, tmp) {
+		if (strcmp(tmp->state->name, pool_sm->state->name) == 0) {
+			possibly_true = 1;
+			break;
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+	if (!possibly_true) {
+		add_ptr_list(false_stack, gate_sm);
+		return;
+	}
+
+	get_tf_stacks_from_pool(gate_sm->left, pool_sm, true_stack, false_stack);
+	get_tf_stacks_from_pool(gate_sm->right, pool_sm, true_stack, false_stack);
+}
+
+/*
+ * The situation is we have a SMATCH_EXTRA state and we want to break it into
+ * each of the ->possible states and find the implications of each.  The caller
+ * has to use __push_fake_cur_stree() to preserve the correct states so they
+ * can be restored later.
+ */
+void overwrite_states_using_pool(struct sm_state *gate_sm, struct sm_state *pool_sm)
+{
+	struct state_list *true_stack = NULL;
+	struct state_list *false_stack = NULL;
+	struct stree *pre_stree;
+	struct stree *implied_true;
+	struct sm_state *tmp;
+
+	if (!pool_sm->pool)
+		return;
+
+	get_tf_stacks_from_pool(gate_sm, pool_sm, &true_stack, &false_stack);
+
+	pre_stree = clone_stree(__get_cur_stree());
+
+	implied_true = filter_stack(gate_sm, pre_stree, false_stack, true_stack);
+
+	free_stree(&pre_stree);
+	free_slist(&true_stack);
+	free_slist(&false_stack);
+
+	FOR_EACH_SM(implied_true, tmp) {
+		set_state(tmp->owner, tmp->name, tmp->sym, tmp->state);
+	} END_FOR_EACH_SM(tmp);
+
+	free_stree(&implied_true);
+}
+
+int assume(struct expression *expr)
+{
+	int orig_final_pass = final_pass;
+
+	in_fake_env++;
+	final_pass = 0;
+	__push_fake_cur_stree();
+	found_implications = 0;
+	__split_whole_condition(expr);
+	final_pass = orig_final_pass;
+	in_fake_env--;
+
+	return 1;
+}
+
+void end_assume(void)
+{
+	__discard_false_states();
+	__free_fake_cur_stree();
+}
+
+int impossible_assumption(struct expression *left, int op, sval_t sval)
+{
+	struct expression *value;
+	struct expression *comparison;
+	int ret;
+
+	value = value_expr(sval.value);
+	comparison = compare_expression(left, op, value);
+
+	if (!assume(comparison))
+		return 0;
+	ret = is_impossible_path();
+	end_assume();
+
+	return ret;
+}
+
+void __extra_match_condition(struct expression *expr);
+void __comparison_match_condition(struct expression *expr);
+void __stored_condition(struct expression *expr);
+void register_implications(int id)
+{
+	add_hook(&save_implications_hook, CONDITION_HOOK);
+	add_hook(&set_implied_states, CONDITION_HOOK);
+	add_hook(&__extra_match_condition, CONDITION_HOOK);
+	add_hook(&set_extra_implied_states, CONDITION_HOOK);
+	add_hook(&__comparison_match_condition, CONDITION_HOOK);
+	add_hook(&__stored_condition, CONDITION_HOOK);
+	add_hook(&match_end_func, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_impossible.c b/usr/src/tools/smatch/src/smatch_impossible.c
new file mode 100644
index 0000000000..ee86eef7eb
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_impossible.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int my_id;
+static int my_return_id;
+
+STATE(impossible);
+
+int is_impossible_path(void)
+{
+	if (get_state(my_id, "impossible", NULL) == &impossible)
+		return 1;
+	return 0;
+}
+
+static void handle_compare(struct expression *left, int op, struct expression *right)
+{
+	int true_impossible = 0;
+	int false_impossible = 0;
+
+	left = strip_expr(left);
+	while (left && left->type == EXPR_ASSIGNMENT)
+		left = strip_expr(left->left);
+
+	if (!possibly_true(left, op, right))
+		true_impossible = 1;
+	if (!possibly_false(left, op, right))
+		false_impossible = 1;
+
+	if (!true_impossible && !false_impossible)
+		return;
+
+	set_true_false_states(my_id, "impossible", NULL,
+			      true_impossible ? &impossible : NULL,
+			      false_impossible ? &impossible : NULL);
+
+	if (inside_loop())
+		return;
+
+	set_true_false_states(my_return_id, "impossible", NULL,
+			      true_impossible ? &impossible : NULL,
+			      false_impossible ? &impossible : NULL);
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (expr->type == EXPR_COMPARE)
+		handle_compare(expr->left, expr->op, expr->right);
+	else
+		handle_compare(expr, SPECIAL_NOTEQUAL, zero_expr());
+}
+
+void set_path_impossible(void)
+{
+	set_state(my_id, "impossible", NULL, &impossible);
+
+	if (inside_loop())
+		return;
+
+	set_state(my_return_id, "impossible", NULL, &impossible);
+}
+
+static void match_case(struct expression *expr, struct range_list *rl)
+{
+	if (rl)
+		return;
+	set_path_impossible();
+}
+
+static void print_impossible_return(int return_id, char *return_ranges, struct expression *expr)
+{
+	if (get_state(my_return_id, "impossible", NULL) == &impossible) {
+		if (option_debug)
+			sm_msg("impossible return.  return_id = %d return ranges = %s", return_id, return_ranges);
+		sql_insert_return_states(return_id, return_ranges, CULL_PATH, -1, "", "");
+	}
+}
+
+void register_impossible(int id)
+{
+	my_id = id;
+
+	add_hook(&match_condition, CONDITION_HOOK);
+	add_hook(&match_case, CASE_HOOK);
+}
+
+void register_impossible_return(int id)
+{
+	my_return_id = id;
+
+	add_split_return_callback(&print_impossible_return);
+}
diff --git a/usr/src/tools/smatch/src/smatch_kernel_user_data.c b/usr/src/tools/smatch/src/smatch_kernel_user_data.c
new file mode 100644
index 0000000000..709958a666
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_kernel_user_data.c
@@ -0,0 +1,1259 @@
+/*
+ * Copyright (C) 2011 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * There are a couple checks that try to see if a variable
+ * comes from the user.  It would be better to unify them
+ * into one place.  Also it we should follow the data down
+ * the call paths.  Hence this file.
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+static int my_call_id;
+
+STATE(called);
+static bool func_gets_user_data;
+
+static const char * kstr_funcs[] = {
+	"kstrtoull", "kstrtoll", "kstrtoul", "kstrtol", "kstrtouint",
+	"kstrtoint", "kstrtou64", "kstrtos64", "kstrtou32", "kstrtos32",
+	"kstrtou16", "kstrtos16", "kstrtou8", "kstrtos8", "kstrtoull_from_user"
+	"kstrtoll_from_user", "kstrtoul_from_user", "kstrtol_from_user",
+	"kstrtouint_from_user", "kstrtoint_from_user", "kstrtou16_from_user",
+	"kstrtos16_from_user", "kstrtou8_from_user", "kstrtos8_from_user",
+	"kstrtou64_from_user", "kstrtos64_from_user", "kstrtou32_from_user",
+	"kstrtos32_from_user",
+};
+
+static const char *returns_user_data[] = {
+	"simple_strtol", "simple_strtoll", "simple_strtoul", "simple_strtoull",
+	"kvm_register_read", "nlmsg_data", "nla_data", "memdup_user",
+	"kmap_atomic", "skb_network_header",
+};
+
+static void set_points_to_user_data(struct expression *expr);
+
+static struct stree *start_states;
+static struct stree_stack *saved_stack;
+static void save_start_states(struct statement *stmt)
+{
+	start_states = clone_stree(__get_cur_stree());
+}
+
+static void free_start_states(void)
+{
+	free_stree(&start_states);
+}
+
+static void match_save_states(struct expression *expr)
+{
+	push_stree(&saved_stack, start_states);
+	start_states = NULL;
+}
+
+static void match_restore_states(struct expression *expr)
+{
+	free_stree(&start_states);
+	start_states = pop_stree(&saved_stack);
+}
+
+static struct smatch_state *empty_state(struct sm_state *sm)
+{
+	return alloc_estate_empty();
+}
+
+static void pre_merge_hook(struct sm_state *sm)
+{
+	struct smatch_state *user;
+	struct smatch_state *extra;
+	struct range_list *rl;
+	sval_t dummy;
+	sval_t sval_100;
+
+	sval_100.value = 100;
+	sval_100.type = &int_ctype;
+
+	user = get_state(my_id, sm->name, sm->sym);
+	if (!user)
+		return;
+	if (!__in_function_def && !estate_rl(sm->state)) {
+		/*
+		 * If the one side is capped and the other side is empty then
+		 * let's just mark it as not-user data because the information
+		 * isn't going to be useful.  How this looks is:
+		 *
+		 * if (user_var > trusted)
+		 *	user_var = trusted;  <-- empty state
+		 * else
+		 *	<-- capped
+		 *
+		 * The problem is that sometimes things are capped to a literal
+		 * and we'd like to keep the state in that case...  Ugh.  I've
+		 * added a check which assumes that everything less than 100 is
+		 * probably capped against a literal.
+		 *
+		 */
+		if (is_capped_var_sym(sm->name, sm->sym) &&
+		    sval_cmp(estate_max(user), sval_100) > 0)
+			set_state(my_id, sm->name, sm->sym, alloc_estate_empty());
+		return;
+	}
+	extra = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+	if (!extra || !estate_rl(extra))
+		return;
+	rl = rl_intersection(estate_rl(user), estate_rl(extra));
+	if (rl_to_sval(rl, &dummy))
+		rl = NULL;
+	set_state(my_id, sm->name, sm->sym, alloc_estate_rl(clone_rl(rl)));
+}
+
+static void extra_nomod_hook(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	struct smatch_state *user;
+	struct range_list *rl;
+
+	user = get_state(my_id, name, sym);
+	if (!user)
+		return;
+	rl = rl_intersection(estate_rl(user), estate_rl(state));
+	if (rl_equiv(rl, estate_rl(user)))
+		return;
+	set_state(my_id, name, sym, alloc_estate_rl(rl));
+}
+
+static void tag_inner_struct_members(struct expression *expr, struct symbol *member)
+{
+	struct expression *edge_member;
+	struct symbol *base = get_real_base_type(member);
+	struct symbol *tmp;
+
+	if (member->ident)
+		expr = member_expression(expr, '.', member->ident);
+
+	FOR_EACH_PTR(base->symbol_list, tmp) {
+		struct symbol *type;
+
+		type = get_real_base_type(tmp);
+		if (!type)
+			continue;
+
+		if (type->type == SYM_UNION || type->type == SYM_STRUCT) {
+			tag_inner_struct_members(expr, tmp);
+			continue;
+		}
+
+		if (!tmp->ident)
+			continue;
+
+		edge_member = member_expression(expr, '.', tmp->ident);
+		set_state_expr(my_id, edge_member, alloc_estate_whole(type));
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void tag_struct_members(struct symbol *type, struct expression *expr)
+{
+	struct symbol *tmp;
+	struct expression *member;
+	int op = '*';
+
+	if (expr->type == EXPR_PREOP && expr->op == '&') {
+		expr = strip_expr(expr->unop);
+		op = '.';
+	}
+
+	FOR_EACH_PTR(type->symbol_list, tmp) {
+		type = get_real_base_type(tmp);
+		if (!type)
+			continue;
+
+		if (type->type == SYM_UNION || type->type == SYM_STRUCT) {
+			tag_inner_struct_members(expr, tmp);
+			continue;
+		}
+
+		if (!tmp->ident)
+			continue;
+
+		member = member_expression(expr, op, tmp->ident);
+		set_state_expr(my_id, member, alloc_estate_whole(get_type(member)));
+
+		if (type->type == SYM_ARRAY)
+			set_points_to_user_data(member);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void tag_base_type(struct expression *expr)
+{
+	if (expr->type == EXPR_PREOP && expr->op == '&')
+		expr = strip_expr(expr->unop);
+	else
+		expr = deref_expression(expr);
+	set_state_expr(my_id, expr, alloc_estate_whole(get_type(expr)));
+}
+
+static void tag_as_user_data(struct expression *expr)
+{
+	struct symbol *type;
+
+	expr = strip_expr(expr);
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_PTR)
+		return;
+	type = get_real_base_type(type);
+	if (!type)
+		return;
+	if (type == &void_ctype) {
+		set_state_expr(my_id, deref_expression(expr), alloc_estate_whole(&ulong_ctype));
+		return;
+	}
+	if (type->type == SYM_BASETYPE)
+		tag_base_type(expr);
+	if (type->type == SYM_STRUCT || type->type == SYM_UNION) {
+		if (expr->type != EXPR_PREOP || expr->op != '&')
+			expr = deref_expression(expr);
+		else
+			set_state_expr(my_id, deref_expression(expr), alloc_estate_whole(&ulong_ctype));
+		tag_struct_members(type, expr);
+	}
+}
+
+static void match_user_copy(const char *fn, struct expression *expr, void *_param)
+{
+	int param = PTR_INT(_param);
+	struct expression *dest;
+
+	func_gets_user_data = true;
+
+	dest = get_argument_from_call_expr(expr->args, param);
+	dest = strip_expr(dest);
+	if (!dest)
+		return;
+	tag_as_user_data(dest);
+}
+
+static int is_dev_attr_name(struct expression *expr)
+{
+	char *name;
+	int ret = 0;
+
+	name = expr_to_str(expr);
+	if (!name)
+		return 0;
+	if (strstr(name, "->attr.name"))
+		ret = 1;
+	free_string(name);
+	return ret;
+}
+
+static int ends_in_n(struct expression *expr)
+{
+	struct string *str;
+
+	if (!expr)
+		return 0;
+	if (expr->type != EXPR_STRING || !expr->string)
+		return 0;
+
+	str = expr->string;
+	if (str->length < 3)
+		return 0;
+
+	if (str->data[str->length - 3] == '%' &&
+	    str->data[str->length - 2] == 'n')
+		return 1;
+	return 0;
+}
+
+static void match_sscanf(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *str, *format, *arg;
+	int i, last;
+
+	func_gets_user_data = true;
+
+	str = get_argument_from_call_expr(expr->args, 0);
+	if (is_dev_attr_name(str))
+		return;
+
+	format = get_argument_from_call_expr(expr->args, 1);
+	if (is_dev_attr_name(format))
+		return;
+
+	last = ptr_list_size((struct ptr_list *)expr->args) - 1;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+		if (i < 2)
+			continue;
+		if (i == last && ends_in_n(format))
+			continue;
+		tag_as_user_data(arg);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static int is_skb_data(struct expression *expr)
+{
+	struct symbol *sym;
+
+	if (!expr)
+		return 0;
+
+	if (expr->type == EXPR_BINOP && expr->op == '+')
+		return is_skb_data(expr->left);
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return 0;
+	if (expr->type != EXPR_DEREF || expr->op != '.')
+		return 0;
+
+	if (!expr->member)
+		return 0;
+	if (strcmp(expr->member->name, "data") != 0)
+		return 0;
+
+	sym = expr_to_sym(expr->deref);
+	if (!sym)
+		return 0;
+	sym = get_real_base_type(sym);
+	if (!sym || sym->type != SYM_PTR)
+		return 0;
+	sym = get_real_base_type(sym);
+	if (!sym || sym->type != SYM_STRUCT || !sym->ident)
+		return 0;
+	if (strcmp(sym->ident->name, "sk_buff") != 0)
+		return 0;
+
+	return 1;
+}
+
+static int get_rl_from_function(struct expression *expr, struct range_list **rl)
+{
+	int i;
+
+	if (expr->type != EXPR_CALL || expr->fn->type != EXPR_SYMBOL ||
+	    !expr->fn->symbol_name || !expr->fn->symbol_name->name)
+		return 0;
+
+	for (i = 0; i < ARRAY_SIZE(returns_user_data); i++) {
+		if (strcmp(expr->fn->symbol_name->name, returns_user_data[i]) == 0) {
+			*rl = alloc_whole_rl(get_type(expr));
+			return 1;
+		}
+	}
+	return 0;
+}
+
+int points_to_user_data(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct range_list *rl;
+	char buf[256];
+	struct symbol *sym;
+	char *name;
+	int ret = 0;
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return 0;
+	if (is_skb_data(expr))
+		return 1;
+	if (get_rl_from_function(expr, &rl))
+		return 1;
+
+	if (expr->type == EXPR_BINOP && expr->op == '+') {
+		if (points_to_user_data(expr->left))
+			return 1;
+		if (points_to_user_data(expr->right))
+			return 1;
+		return 0;
+	}
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	snprintf(buf, sizeof(buf), "*%s", name);
+	state = get_state(my_id, buf, sym);
+	if (state && estate_rl(state))
+		ret = 1;
+free:
+	free_string(name);
+	return ret;
+}
+
+static void set_points_to_user_data(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	char buf[256];
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	snprintf(buf, sizeof(buf), "*%s", name);
+	set_state(my_id, buf, sym, alloc_estate_whole(&llong_ctype));
+free:
+	free_string(name);
+}
+
+static int comes_from_skb_data(struct expression *expr)
+{
+	expr = strip_expr(expr);
+	if (!expr || expr->type != EXPR_PREOP || expr->op != '*')
+		return 0;
+
+	expr = strip_expr(expr->unop);
+	if (!expr)
+		return 0;
+	if (expr->type == EXPR_BINOP && expr->op == '+')
+		expr = strip_expr(expr->left);
+
+	return is_skb_data(expr);
+}
+
+static int handle_struct_assignment(struct expression *expr)
+{
+	struct expression *right;
+	struct symbol *left_type, *right_type;
+
+	left_type = get_type(expr->left);
+	if (!left_type || left_type->type != SYM_PTR)
+		return 0;
+	left_type = get_real_base_type(left_type);
+	if (!left_type)
+		return 0;
+	if (left_type->type != SYM_STRUCT &&
+	    left_type->type != SYM_UNION)
+		return 0;
+
+	/*
+	 * Ignore struct to struct assignments because for those we look at the
+	 * individual members.
+	 */
+	right = strip_expr(expr->right);
+	right_type = get_type(right);
+	if (!right_type || right_type->type != SYM_PTR)
+		return 0;
+
+	/* If we are assigning struct members then normally that is handled
+	 * by fake assignments, however if we cast one struct to a different
+	 * of struct then we handle that here.
+	 */
+	right_type = get_real_base_type(right_type);
+	if (right_type == left_type)
+		return 0;
+
+	if (!points_to_user_data(right))
+		return 0;
+
+	tag_as_user_data(expr->left);
+	return 1;
+}
+
+static int handle_get_user(struct expression *expr)
+{
+	char *name;
+	int ret = 0;
+
+	name = get_macro_name(expr->pos);
+	if (!name || strcmp(name, "get_user") != 0)
+		return 0;
+
+	name = expr_to_var(expr->right);
+	if (!name || strcmp(name, "__val_gu") != 0)
+		goto free;
+	set_state_expr(my_id, expr->left, alloc_estate_whole(get_type(expr->left)));
+	ret = 1;
+free:
+	free_string(name);
+	return ret;
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct range_list *rl;
+
+	if (is_fake_call(expr->right))
+		goto clear_old_state;
+	if (handle_get_user(expr))
+		return;
+	if (points_to_user_data(expr->right))
+		set_points_to_user_data(expr->left);
+	if (handle_struct_assignment(expr))
+		return;
+
+	if (!get_user_rl(expr->right, &rl))
+		goto clear_old_state;
+
+	rl = cast_rl(get_type(expr->left), rl);
+	set_state_expr(my_id, expr->left, alloc_estate_rl(rl));
+
+	return;
+
+clear_old_state:
+	if (get_state_expr(my_id, expr->left))
+		set_state_expr(my_id, expr->left, alloc_estate_empty());
+}
+
+static void handle_eq_noteq(struct expression *expr)
+{
+	struct smatch_state *left_orig, *right_orig;
+
+	left_orig = get_state_expr(my_id, expr->left);
+	right_orig = get_state_expr(my_id, expr->right);
+
+	if (!left_orig && !right_orig)
+		return;
+	if (left_orig && right_orig)
+		return;
+
+	if (left_orig) {
+		set_true_false_states_expr(my_id, expr->left,
+				expr->op == SPECIAL_EQUAL ? alloc_estate_empty() : NULL,
+				expr->op == SPECIAL_EQUAL ? NULL : alloc_estate_empty());
+	} else {
+		set_true_false_states_expr(my_id, expr->right,
+				expr->op == SPECIAL_EQUAL ? alloc_estate_empty() : NULL,
+				expr->op == SPECIAL_EQUAL ? NULL : alloc_estate_empty());
+	}
+}
+
+static void handle_unsigned_lt_gt(struct expression *expr)
+{
+	struct symbol *type;
+	struct range_list *left;
+	struct range_list *right;
+	struct range_list *non_negative;
+	sval_t min, minus_one;
+
+	/*
+	 * conditions are mostly handled by smatch_extra.c.  The special case
+	 * here is that say you have if (user_int < unknown_u32) {
+	 * In Smatch extra we say that, We have no idea what value
+	 * unknown_u32 is so the only thin we can say for sure is that
+	 * user_int is not -1 (UINT_MAX).  But in check_user_data2.c we should
+	 * assume that unless unknown_u32 is user data, it's probably less than
+	 * INT_MAX.
+	 *
+	 */
+
+	type = get_type(expr);
+	if (!type_unsigned(type))
+		return;
+
+	/*
+	 * Assume if (user < trusted) { ... because I am lazy and because this
+	 * is the correct way to write code.
+	 */
+	if (!get_user_rl(expr->left, &left))
+		return;
+	if (get_user_rl(expr->right, &right))
+		return;
+
+	if (!sval_is_negative(rl_min(left)))
+		return;
+	min = rl_min(left);
+	minus_one.type = rl_type(left);
+	minus_one.value = -1;
+	non_negative = remove_range(left, min, minus_one);
+
+	switch (expr->op) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+	case SPECIAL_LTE:
+	case SPECIAL_UNSIGNED_LTE:
+		set_true_false_states_expr(my_id, expr->left,
+					   alloc_estate_rl(non_negative), NULL);
+		break;
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+	case SPECIAL_GTE:
+	case SPECIAL_UNSIGNED_GTE:
+		set_true_false_states_expr(my_id, expr->left,
+					   NULL, alloc_estate_rl(non_negative));
+		break;
+	}
+}
+
+static void match_condition(struct expression *expr)
+{
+	if (expr->type != EXPR_COMPARE)
+		return;
+
+	if (expr->op == SPECIAL_EQUAL ||
+	    expr->op == SPECIAL_NOTEQUAL) {
+		handle_eq_noteq(expr);
+		return;
+	}
+
+	handle_unsigned_lt_gt(expr);
+}
+
+static void match_user_assign_function(const char *fn, struct expression *expr, void *unused)
+{
+	tag_as_user_data(expr->left);
+	set_points_to_user_data(expr->left);
+}
+
+static void match_returns_user_rl(const char *fn, struct expression *expr, void *unused)
+{
+	func_gets_user_data = true;
+}
+
+static int get_user_macro_rl(struct expression *expr, struct range_list **rl)
+{
+	struct expression *parent;
+	char *macro;
+
+	if (!expr)
+		return 0;
+
+	macro = get_macro_name(expr->pos);
+	if (!macro)
+		return 0;
+
+	/* handle ntohl(foo[i]) where "i" is trusted */
+	parent = expr_get_parent_expr(expr);
+	while (parent && parent->type != EXPR_BINOP)
+		parent = expr_get_parent_expr(parent);
+	if (parent && parent->type == EXPR_BINOP) {
+		char *parent_macro = get_macro_name(parent->pos);
+
+		if (parent_macro && strcmp(macro, parent_macro) == 0)
+			return 0;
+	}
+
+	if (strcmp(macro, "ntohl") == 0) {
+		*rl = alloc_whole_rl(&uint_ctype);
+		return 1;
+	}
+	if (strcmp(macro, "ntohs") == 0) {
+		*rl = alloc_whole_rl(&ushort_ctype);
+		return 1;
+	}
+	return 0;
+}
+
+struct db_info {
+	struct range_list *rl;
+	struct expression *call;
+};
+static int returned_rl_callback(void *_info, int argc, char **argv, char **azColName)
+{
+	struct db_info *db_info = _info;
+	struct range_list *rl;
+	char *return_ranges = argv[0];
+	char *user_ranges = argv[1];
+	struct expression *arg;
+	int comparison;
+
+	if (argc != 2)
+		return 0;
+
+	call_results_to_rl(db_info->call, get_type(db_info->call), user_ranges, &rl);
+	if (str_to_comparison_arg(return_ranges, db_info->call, &comparison, &arg) &&
+	    comparison == SPECIAL_EQUAL) {
+		struct range_list *orig_rl;
+
+		if (!get_user_rl(arg, &orig_rl))
+			return 0;
+		rl = rl_intersection(rl, orig_rl);
+		if (!rl)
+			return 0;
+	}
+	db_info->rl = rl_union(db_info->rl, rl);
+
+	return 0;
+}
+
+static int has_user_data(struct symbol *sym)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), tmp) {
+		if (tmp->sym == sym)
+			return 1;
+	} END_FOR_EACH_SM(tmp);
+	return 0;
+}
+
+static int we_pass_user_data(struct expression *call)
+{
+	struct expression *arg;
+	struct symbol *sym;
+
+	FOR_EACH_PTR(call->args, arg) {
+		sym = expr_to_sym(arg);
+		if (!sym)
+			continue;
+		if (has_user_data(sym))
+			return 1;
+	} END_FOR_EACH_PTR(arg);
+
+	return 0;
+}
+
+static int db_returned_user_rl(struct expression *call, struct range_list **rl)
+{
+	struct db_info db_info = {};
+
+	/* for function pointers assume everything is used */
+	if (call->fn->type != EXPR_SYMBOL)
+		return 0;
+	if (is_fake_call(call))
+		return 0;
+
+	db_info.call = call;
+	run_sql(&returned_rl_callback, &db_info,
+		"select return, value from return_states where %s and type = %d and parameter = -1 and key = '$';",
+		get_static_filter(call->fn->symbol), USER_DATA3_SET);
+	if (db_info.rl) {
+		func_gets_user_data = true;
+		*rl = db_info.rl;
+		return 1;
+	}
+
+	run_sql(&returned_rl_callback, &db_info,
+		"select return, value from return_states where %s and type = %d and parameter = -1 and key = '$';",
+		get_static_filter(call->fn->symbol), USER_DATA3);
+	if (db_info.rl) {
+		if (!we_pass_user_data(call))
+			return 0;
+		*rl = db_info.rl;
+		return 1;
+	}
+
+	return 0;
+}
+
+struct stree *get_user_stree(void)
+{
+	return get_all_states_stree(my_id);
+}
+
+static int user_data_flag;
+static int no_user_data_flag;
+static struct range_list *var_user_rl(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct range_list *rl;
+	struct range_list *absolute_rl;
+
+	if (expr->type == EXPR_BINOP && expr->op == '%') {
+		struct range_list *left, *right;
+
+		if (!get_user_rl(expr->right, &right))
+			return NULL;
+		get_absolute_rl(expr->left, &left);
+		rl = rl_binop(left, '%', right);
+		goto found;
+	}
+
+	if (!option_spammy && expr->type == EXPR_BINOP && expr->op == '/') {
+		struct range_list *left = NULL;
+		struct range_list *right = NULL;
+		struct range_list *abs_right;
+
+		/*
+		 * The specific bug I'm dealing with is:
+		 *
+		 * foo = capped_user / unknown;
+		 *
+		 * Instead of just saying foo is now entirely user_rl we should
+		 * probably say instead that it is not at all user data.
+		 *
+		 */
+
+		get_user_rl(expr->left, &left);
+		get_user_rl(expr->right, &right);
+		get_absolute_rl(expr->right, &abs_right);
+
+		if (left && !right) {
+			rl = rl_binop(left, '/', abs_right);
+			if (sval_cmp(rl_max(left), rl_max(rl)) < 0)
+				no_user_data_flag = 1;
+		}
+
+		return NULL;
+	}
+
+	if (get_rl_from_function(expr, &rl))
+		goto found;
+
+	if (get_user_macro_rl(expr, &rl))
+		goto found;
+
+	if (comes_from_skb_data(expr)) {
+		rl = alloc_whole_rl(get_type(expr));
+		goto found;
+	}
+
+	state = get_state_expr(my_id, expr);
+	if (state && estate_rl(state)) {
+		rl = estate_rl(state);
+		goto found;
+	}
+
+	if (expr->type == EXPR_CALL && db_returned_user_rl(expr, &rl))
+		goto found;
+
+	if (is_array(expr)) {
+		struct expression *array = get_array_base(expr);
+
+		if (!get_state_expr(my_id, array)) {
+			no_user_data_flag = 1;
+			return NULL;
+		}
+	}
+
+	if (expr->type == EXPR_PREOP && expr->op == '*' &&
+	    is_user_rl(expr->unop)) {
+		rl = var_to_absolute_rl(expr);
+		goto found;
+	}
+
+	return NULL;
+found:
+	user_data_flag = 1;
+	absolute_rl = var_to_absolute_rl(expr);
+	return clone_rl(rl_intersection(rl, absolute_rl));
+}
+
+int get_user_rl(struct expression *expr, struct range_list **rl)
+{
+	user_data_flag = 0;
+	no_user_data_flag = 0;
+	custom_get_absolute_rl(expr, &var_user_rl, rl);
+	if (!user_data_flag || no_user_data_flag)
+		*rl = NULL;
+
+	return !!*rl;
+}
+
+int get_user_rl_spammy(struct expression *expr, struct range_list **rl)
+{
+	int ret;
+
+	option_spammy++;
+	ret = get_user_rl(expr, rl);
+	option_spammy--;
+
+	return ret;
+}
+
+int is_user_rl(struct expression *expr)
+{
+	struct range_list *tmp;
+
+	return get_user_rl_spammy(expr, &tmp);
+}
+
+int get_user_rl_var_sym(const char *name, struct symbol *sym, struct range_list **rl)
+{
+	struct smatch_state *state;
+
+	state = get_state(my_id, name, sym);
+	if (state && estate_rl(state)) {
+		*rl = estate_rl(state);
+		return 1;
+	}
+	return 0;
+}
+
+static void match_call_info(struct expression *expr)
+{
+	struct range_list *rl;
+	struct expression *arg;
+	struct symbol *type;
+	int i = 0;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+		type = get_arg_type(expr->fn, i);
+
+		if (!get_user_rl(arg, &rl))
+			continue;
+
+		rl = cast_rl(type, rl);
+		sql_insert_caller_info(expr, USER_DATA3, i, "$", show_rl(rl));
+	} END_FOR_EACH_PTR(arg);
+}
+
+static int is_struct_ptr(struct symbol *sym)
+{
+	struct symbol *type;
+
+	if (!sym)
+		return 0;
+	type = get_real_base_type(sym);
+	if (!type || type->type != SYM_PTR)
+		return 0;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_STRUCT)
+		return 0;
+	return 1;
+}
+
+static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
+{
+	struct smatch_state *state;
+	struct range_list *rl;
+	struct symbol *type;
+
+	/*
+	 * Smatch uses a hack where if we get an unsigned long we say it's
+	 * both user data and it points to user data.  But if we pass it to a
+	 * function which takes an int, then it's just user data.  There's not
+	 * enough bytes for it to be a pointer.
+	 *
+	 */
+	type = get_arg_type(call->fn, param);
+	if (type && type_bits(type) < type_bits(&ptr_ctype))
+		return;
+
+	if (strcmp(sm->state->name, "") == 0)
+		return;
+
+	if (strcmp(printed_name, "*$") == 0 &&
+	    is_struct_ptr(sm->sym))
+		return;
+
+	state = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+	if (!state || !estate_rl(state))
+		rl = estate_rl(sm->state);
+	else
+		rl = rl_intersection(estate_rl(sm->state), estate_rl(state));
+
+	sql_insert_caller_info(call, USER_DATA3, param, printed_name, show_rl(rl));
+}
+
+static void set_param_user_data(const char *name, struct symbol *sym, char *key, char *value)
+{
+	struct range_list *rl = NULL;
+	struct smatch_state *state;
+	struct symbol *type;
+	char fullname[256];
+
+	if (strcmp(key, "*$") == 0)
+		snprintf(fullname, sizeof(fullname), "*%s", name);
+	else if (strncmp(key, "$", 1) == 0)
+		snprintf(fullname, 256, "%s%s", name, key + 1);
+	else
+		return;
+
+	type = get_member_type_from_key(symbol_expression(sym), key);
+
+	/* if the caller passes a void pointer with user data */
+	if (strcmp(key, "*$") == 0 && type && type != &void_ctype) {
+		struct expression *expr = symbol_expression(sym);
+
+		tag_as_user_data(expr);
+		set_points_to_user_data(expr);
+		return;
+	}
+	str_to_rl(type, value, &rl);
+	state = alloc_estate_rl(rl);
+	set_state(my_id, fullname, sym, state);
+}
+
+static void set_called(const char *name, struct symbol *sym, char *key, char *value)
+{
+	set_state(my_call_id, "this_function", NULL, &called);
+}
+
+static void match_syscall_definition(struct symbol *sym)
+{
+	struct symbol *arg;
+	char *macro;
+	char *name;
+	int is_syscall = 0;
+
+	macro = get_macro_name(sym->pos);
+	if (macro &&
+	    (strncmp("SYSCALL_DEFINE", macro, strlen("SYSCALL_DEFINE")) == 0 ||
+	     strncmp("COMPAT_SYSCALL_DEFINE", macro, strlen("COMPAT_SYSCALL_DEFINE")) == 0))
+		is_syscall = 1;
+
+	name = get_function();
+	if (!option_no_db && get_state(my_call_id, "this_function", NULL) != &called) {
+		if (name && strncmp(name, "sys_", 4) == 0)
+			is_syscall = 1;
+	}
+
+	if (name && strncmp(name, "compat_sys_", 11) == 0)
+		is_syscall = 1;
+
+	if (!is_syscall)
+		return;
+
+	FOR_EACH_PTR(sym->ctype.base_type->arguments, arg) {
+		set_state(my_id, arg->ident->name, arg, alloc_estate_whole(get_real_base_type(arg)));
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void set_to_user_data(struct expression *expr, char *key, char *value)
+{
+	char *name;
+	struct symbol *sym;
+	struct symbol *type;
+	struct range_list *rl = NULL;
+
+	type = get_member_type_from_key(expr, key);
+	name = get_variable_from_key(expr, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	call_results_to_rl(expr, type, value, &rl);
+
+	set_state(my_id, name, sym, alloc_estate_rl(rl));
+free:
+	free_string(name);
+
+}
+
+static void returns_param_user_data(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+	struct expression *call;
+
+	call = expr;
+	while (call->type == EXPR_ASSIGNMENT)
+		call = strip_expr(call->right);
+	if (call->type != EXPR_CALL)
+		return;
+
+	if (!we_pass_user_data(call))
+		return;
+
+	if (param == -1) {
+		if (expr->type != EXPR_ASSIGNMENT)
+			return;
+		set_to_user_data(expr->left, key, value);
+		return;
+	}
+
+	arg = get_argument_from_call_expr(call->args, param);
+	if (!arg)
+		return;
+	set_to_user_data(arg, key, value);
+}
+
+static void returns_param_user_data_set(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+
+	func_gets_user_data = true;
+
+	if (param == -1) {
+		if (expr->type != EXPR_ASSIGNMENT)
+			return;
+		if (strcmp(key, "*$") == 0) {
+			set_points_to_user_data(expr->left);
+			tag_as_user_data(expr->left);
+		} else {
+			set_to_user_data(expr->left, key, value);
+		}
+		return;
+	}
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+	set_to_user_data(arg, key, value);
+}
+
+static int has_empty_state(struct sm_state *sm)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (!estate_rl(tmp->state))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static void param_set_to_user_data(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *sm;
+	struct smatch_state *start_state;
+	struct range_list *rl;
+	int param;
+	char *return_str;
+	const char *param_name;
+	struct symbol *ret_sym;
+	bool return_found = false;
+
+	expr = strip_expr(expr);
+	return_str = expr_to_str(expr);
+	ret_sym = expr_to_sym(expr);
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (has_empty_state(sm))
+			continue;
+
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+
+		/* The logic here was that if we were passed in a user data then
+		 * we don't record that.  It's like the difference between
+		 * param_filter and param_set.  When I think about it, I'm not
+		 * sure it actually works.  It's probably harmless because we
+		 * checked earlier that we're not returning a parameter...
+		 * Let's mark this as a TODO.
+		 */
+		start_state = get_state_stree(start_states, my_id, sm->name, sm->sym);
+		if (start_state && rl_equiv(estate_rl(sm->state), estate_rl(start_state)))
+			continue;
+
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+		if (strcmp(param_name, "$") == 0)  /* The -1 param is handled after the loop */
+			continue;
+
+		sql_insert_return_states(return_id, return_ranges,
+					 func_gets_user_data ? USER_DATA3_SET : USER_DATA3,
+					 param, param_name, show_rl(estate_rl(sm->state)));
+	} END_FOR_EACH_SM(sm);
+
+	if (points_to_user_data(expr)) {
+		sql_insert_return_states(return_id, return_ranges,
+					 (is_skb_data(expr) || !func_gets_user_data) ?
+					 USER_DATA3_SET : USER_DATA3,
+					 -1, "*$", "");
+		goto free_string;
+	}
+
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (!ret_sym)
+			break;
+		if (ret_sym != sm->sym)
+			continue;
+
+		param_name = state_name_to_param_name(sm->name, return_str);
+		if (!param_name)
+			continue;
+		if (strcmp(param_name, "$") == 0)
+			return_found = true;
+		sql_insert_return_states(return_id, return_ranges,
+					 func_gets_user_data ? USER_DATA3_SET : USER_DATA3,
+					 -1, param_name, show_rl(estate_rl(sm->state)));
+	} END_FOR_EACH_SM(sm);
+
+
+	if (!return_found && get_user_rl(expr, &rl)) {
+		sql_insert_return_states(return_id, return_ranges,
+					 func_gets_user_data ? USER_DATA3_SET : USER_DATA3,
+					 -1, "$", show_rl(rl));
+		goto free_string;
+	}
+
+free_string:
+	free_string(return_str);
+}
+
+static struct int_stack *gets_data_stack;
+static void match_function_def(struct symbol *sym)
+{
+	func_gets_user_data = false;
+}
+
+static void match_inline_start(struct expression *expr)
+{
+	push_int(&gets_data_stack, func_gets_user_data);
+}
+
+static void match_inline_end(struct expression *expr)
+{
+	func_gets_user_data = pop_int(&gets_data_stack);
+}
+
+void register_kernel_user_data2(int id)
+{
+	int i;
+
+	my_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+	add_hook(&match_inline_start, INLINE_FN_START);
+	add_hook(&match_inline_end, INLINE_FN_END);
+
+	add_hook(&save_start_states, AFTER_DEF_HOOK);
+	add_hook(&free_start_states, AFTER_FUNC_HOOK);
+	add_hook(&match_save_states, INLINE_FN_START);
+	add_hook(&match_restore_states, INLINE_FN_END);
+
+	add_unmatched_state_hook(my_id, &empty_state);
+	add_extra_nomod_hook(&extra_nomod_hook);
+	add_pre_merge_hook(my_id, &pre_merge_hook);
+	add_merge_hook(my_id, &merge_estates);
+
+	add_function_hook("copy_from_user", &match_user_copy, INT_PTR(0));
+	add_function_hook("__copy_from_user", &match_user_copy, INT_PTR(0));
+	add_function_hook("memcpy_fromiovec", &match_user_copy, INT_PTR(0));
+	for (i = 0; i < ARRAY_SIZE(kstr_funcs); i++)
+		add_function_hook(kstr_funcs[i], &match_user_copy, INT_PTR(2));
+	add_function_hook("usb_control_msg", &match_user_copy, INT_PTR(6));
+
+	for (i = 0; i < ARRAY_SIZE(returns_user_data); i++) {
+		add_function_assign_hook(returns_user_data[i], &match_user_assign_function, NULL);
+		add_function_hook(returns_user_data[i], &match_returns_user_rl, NULL);
+	}
+
+	add_function_hook("sscanf", &match_sscanf, NULL);
+
+	add_hook(&match_syscall_definition, AFTER_DEF_HOOK);
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_condition, CONDITION_HOOK);
+
+	add_hook(&match_call_info, FUNCTION_CALL_HOOK);
+	add_member_info_callback(my_id, struct_member_callback);
+	select_caller_info_hook(set_param_user_data, USER_DATA3);
+	select_return_states_hook(USER_DATA3, &returns_param_user_data);
+	select_return_states_hook(USER_DATA3_SET, &returns_param_user_data_set);
+	add_split_return_callback(&param_set_to_user_data);
+}
+
+void register_kernel_user_data3(int id)
+{
+	my_call_id = id;
+
+	if (option_project != PROJ_KERNEL)
+		return;
+	select_caller_info_hook(set_called, INTERNAL);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_links.c b/usr/src/tools/smatch/src/smatch_links.c
new file mode 100644
index 0000000000..c24f0c220b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_links.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Some helper functions for managing links.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static struct smatch_state *alloc_link(struct var_sym_list *links)
+{
+	struct smatch_state *state;
+	static char buf[256];
+	struct var_sym *tmp;
+	int i;
+
+	state = __alloc_smatch_state(0);
+
+	i = 0;
+	FOR_EACH_PTR(links, tmp) {
+		if (!i++) {
+			snprintf(buf, sizeof(buf), "%s", tmp->var);
+		} else {
+			append(buf, ", ", sizeof(buf));
+			append(buf, tmp->var, sizeof(buf));
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+	state->name = alloc_sname(buf);
+	state->data = links;
+	return state;
+}
+
+struct smatch_state *merge_link_states(struct smatch_state *s1, struct smatch_state *s2)
+{
+	struct var_sym_list *new_links;
+
+	if (s1 == &undefined)
+		return s2;
+	if (s2 == &undefined)
+		return s1;
+
+	if (var_sym_lists_equiv(s1->data, s2->data))
+		return s1;
+
+	new_links = clone_var_sym_list(s1->data);
+	merge_var_sym_list(&new_links, s2->data);
+
+	return alloc_link(new_links);
+}
+
+void store_link(int link_id, const char *var, struct symbol *sym, const char *link_name, struct symbol *link_sym)
+{
+
+	struct smatch_state *old_state;
+	struct var_sym_list *links;
+
+	if (!cur_func_sym)
+		return;
+
+	old_state = get_state(link_id, var, sym);
+	if (old_state)
+		links = clone_var_sym_list(old_state->data);
+	else
+		links = NULL;
+
+	add_var_sym(&links, link_name, link_sym);
+	set_state(link_id, var, sym, alloc_link(links));
+}
+
+static void match_link_modify(struct sm_state *sm, struct expression *mod_expr)
+{
+	struct var_sym_list *links;
+	struct var_sym *tmp;
+
+	links = sm->state->data;
+
+	FOR_EACH_PTR(links, tmp) {
+		set_state(sm->owner - 1, tmp->var, tmp->sym, &undefined);
+	} END_FOR_EACH_PTR(tmp);
+	set_state(sm->owner, sm->name, sm->sym, &undefined);
+}
+
+void set_up_link_functions(int id, int link_id)
+{
+	if (id + 1 != link_id)
+		sm_fatal("FATAL ERROR: links need to be registered directly after the check");
+
+	add_merge_hook(link_id, &merge_link_states);
+	add_modification_hook(link_id, &match_link_modify);
+	// free link at the end of function
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_local_values.c b/usr/src/tools/smatch/src/smatch_local_values.c
new file mode 100644
index 0000000000..cffc206612
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_local_values.c
@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+/*
+ * I'm going to store the states of local data at the end of each function.
+ * Then at the end of the file, I'll combine the possible range lists for
+ * each state and store the value in the on-disk database.
+ *
+ * One issue is that when I read the data back from the in-memory database at
+ * the end of the file, then I don't have access to type information.  I'll just
+ * cast everything to "long long" for now, I guess.  We'll see how that works.
+ */
+
+static char *db_vals;
+static int get_vals(void *unused, int argc, char **argv, char **azColName)
+{
+	db_vals = alloc_string(argv[0]);
+	return 0;
+}
+
+static int is_array_symbol(struct expression *expr)
+{
+	struct symbol *type;
+
+	if (!expr || expr->type != EXPR_SYMBOL)
+		return 0;
+	type = get_type(expr);
+	if (!type)
+		return 0;
+	if (type->type == SYM_ARRAY)
+		return 1;
+	return 0;
+}
+
+int get_local_rl(struct expression *expr, struct range_list **rl)
+{
+	char *name;
+	struct range_list *tmp;
+
+	if (!is_static(expr))
+		return 0;
+	if (is_array_symbol(expr))
+		return 0;
+	name = expr_to_var(expr);
+	if (!name)
+		return 0;
+
+	db_vals = NULL;
+	run_sql(get_vals, NULL,
+		"select value from local_values where file = '%s' and variable = '%s';",
+		get_filename(), name);
+	free_string(name);
+	if (!db_vals)
+		return 0;
+	str_to_rl(&llong_ctype, db_vals, &tmp);
+	*rl = cast_rl(get_type(expr), tmp);
+	free_string(db_vals);
+
+	return 1;
+}
+
+int get_local_max_helper(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+
+	if (!get_local_rl(expr, &rl))
+		return 0;
+	*sval = rl_max(rl);
+	return 1;
+}
+
+int get_local_min_helper(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+
+	if (!get_local_rl(expr, &rl))
+		return 0;
+	*sval = rl_min(rl);
+	return 1;
+}
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	return alloc_estate_empty();
+}
+
+static void extra_mod_hook(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	struct smatch_state *old;
+	struct smatch_state *new;
+
+	if (!sym || !(sym->ctype.modifiers & MOD_STATIC))
+		return;
+	old = get_state(my_id, name, sym);
+	if (old)
+		new = merge_estates(old, state);
+	else
+		new = state;
+	set_state(my_id, name, sym, new);
+}
+
+static void process_states(void)
+{
+	struct sm_state *sm;
+	struct smatch_state *extra;
+	struct range_list *rl;
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (sm->owner != my_id)
+			continue;
+		extra = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+		if (extra && estate_rl(extra))
+			rl = rl_intersection(estate_rl(sm->state), estate_rl(extra));
+		else
+			rl = estate_rl(sm->state);
+		rl = cast_rl(&llong_ctype, rl);
+		mem_sql(NULL, NULL,
+			"insert into local_values values ('%s', '%s', '%s', %lu);",
+			get_filename(), sm->name, show_rl(rl),
+			(unsigned long)sm->sym);
+	} END_FOR_EACH_SM(sm);
+}
+
+static int get_initial_value_sym(struct symbol *sym, char *name, sval_t *sval)
+{
+	struct expression *expr_symbol, *deref, *tmp;
+	char *member_name;
+
+	if (!sym)
+		return 0;
+
+	if (!sym->initializer) {
+		*sval = sval_type_val(&llong_ctype, 0);
+		return 1;
+	}
+	if (sym->initializer->type != EXPR_INITIALIZER)
+		return get_value(sym->initializer, sval);
+
+	expr_symbol = symbol_expression(sym);
+	FOR_EACH_PTR(sym->initializer->expr_list, tmp) {
+		if (tmp->type != EXPR_IDENTIFIER) /* how to handle arrays?? */
+			continue;
+		deref = member_expression(expr_symbol, '.', tmp->expr_ident);
+		member_name = expr_to_var(deref);
+		if (!member_name)
+			continue;
+		if (strcmp(name, member_name) == 0) {
+			free_string(member_name);
+			return get_value(tmp->ident_expression, sval);
+		}
+		free_string(member_name);
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static char *cur_name;
+static struct symbol *cur_symbol;
+static struct range_list *cur_rl;
+static void add_current_local(void)
+{
+	sval_t initial;
+
+	if (!get_initial_value_sym(cur_symbol, cur_name, &initial)) {
+		free_string(cur_name);
+		cur_name = NULL;
+		cur_rl = NULL;
+		return;
+	}
+	add_range(&cur_rl, initial, initial);
+	if (!is_whole_rl(cur_rl))
+		sql_insert_local_values(cur_name, show_rl(cur_rl));
+	free_string(cur_name);
+	cur_name = NULL;
+	cur_rl = NULL;
+}
+
+static int save_final_values(void *unused, int argc, char **argv, char **azColName)
+{
+	char *name = argv[0];
+	char *sym_str = argv[1];
+	char *value = argv[2];
+	struct range_list *rl;
+
+	if (!cur_name) {
+		cur_name = alloc_string(name);
+		cur_symbol = (struct symbol *)strtoul(sym_str, NULL, 10);
+	} else if (strcmp(cur_name, name) != 0) {
+		add_current_local();
+		cur_name = alloc_string(name);
+		cur_symbol = (struct symbol *)strtoul(sym_str, NULL, 10);
+		cur_rl = NULL;
+	}
+
+	str_to_rl(&llong_ctype, value, &rl);
+	cur_rl = rl_union(cur_rl, rl);
+
+	return 0;
+}
+
+static void match_end_file(struct symbol_list *sym_list)
+{
+	mem_sql(save_final_values, NULL,
+		"select distinct variable, symbol, value from local_values order by variable;");
+	if (cur_name)
+		add_current_local();
+}
+
+void register_local_values(int id)
+{
+	my_id = id;
+
+	if (!option_info)
+		return;
+
+	add_extra_mod_hook(&extra_mod_hook);
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	add_merge_hook(my_id, &merge_estates);
+	all_return_states_hook(&process_states);
+	add_hook(match_end_file, END_FILE_HOOK);
+	mem_sql(NULL, NULL, "alter table local_values add column symbol integer;");
+}
diff --git a/usr/src/tools/smatch/src/smatch_math.c b/usr/src/tools/smatch/src/smatch_math.c
new file mode 100644
index 0000000000..04d3c0a4b4
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_math.c
@@ -0,0 +1,1597 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "symbol.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static struct range_list *_get_rl(struct expression *expr, int implied, int *recurse_cnt);
+static struct range_list *handle_variable(struct expression *expr, int implied, int *recurse_cnt);
+static struct range_list *(*custom_handle_variable)(struct expression *expr);
+
+static int get_implied_value_internal(struct expression *expr, sval_t *sval, int *recurse_cnt);
+static int get_absolute_rl_internal(struct expression *expr, struct range_list **rl, int *recurse_cnt);
+
+static sval_t zero  = {.type = &int_ctype, {.value = 0} };
+static sval_t one   = {.type = &int_ctype, {.value = 1} };
+
+struct range_list *rl_zero(void)
+{
+	static struct range_list *zero_perm;
+
+	if (!zero_perm)
+		zero_perm = clone_rl_permanent(alloc_rl(zero, zero));
+	return zero_perm;
+}
+
+struct range_list *rl_one(void)
+{
+	static struct range_list *one_perm;
+
+	if (!one_perm)
+		one_perm = clone_rl_permanent(alloc_rl(one, one));
+
+	return one_perm;
+}
+
+enum {
+	RL_EXACT,
+	RL_HARD,
+	RL_FUZZY,
+	RL_IMPLIED,
+	RL_ABSOLUTE,
+	RL_REAL_ABSOLUTE,
+};
+
+static struct range_list *last_stmt_rl(struct statement *stmt, int implied, int *recurse_cnt)
+{
+	struct expression *expr;
+
+	if (!stmt)
+		return NULL;
+
+	stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
+	if (stmt->type == STMT_LABEL) {
+		if (stmt->label_statement &&
+		    stmt->label_statement->type == STMT_EXPRESSION)
+			expr = stmt->label_statement->expression;
+		else
+			return NULL;
+	} else if (stmt->type == STMT_EXPRESSION) {
+		expr = stmt->expression;
+	} else {
+		return NULL;
+	}
+	return _get_rl(expr, implied, recurse_cnt);
+}
+
+static struct range_list *handle_expression_statement_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	return last_stmt_rl(get_expression_statement(expr), implied, recurse_cnt);
+}
+
+static struct range_list *handle_ampersand_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *rl;
+	sval_t sval;
+
+	if (implied == RL_EXACT || implied == RL_HARD)
+		return NULL;
+	if (get_mtag_sval(expr, &sval))
+		return alloc_rl(sval, sval);
+	if (get_address_rl(expr, &rl))
+		return rl;
+	return alloc_rl(valid_ptr_min_sval, valid_ptr_max_sval);
+}
+
+static struct range_list *handle_negate_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	if (known_condition_true(expr->unop))
+		return rl_zero();
+	if (known_condition_false(expr->unop))
+		return rl_one();
+
+	if (implied == RL_EXACT)
+		return NULL;
+
+	if (implied_condition_true(expr->unop))
+		return rl_zero();
+	if (implied_condition_false(expr->unop))
+		return rl_one();
+	return alloc_rl(zero, one);
+}
+
+static struct range_list *handle_bitwise_negate(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *rl;
+	sval_t sval;
+
+	rl = _get_rl(expr->unop, implied, recurse_cnt);
+	if (!rl_to_sval(rl, &sval))
+		return NULL;
+	sval = sval_preop(sval, '~');
+	sval_cast(get_type(expr->unop), sval);
+	return alloc_rl(sval, sval);
+}
+
+static struct range_list *handle_minus_preop(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *rl;
+	sval_t min, max;
+
+	rl = _get_rl(expr->unop, implied, recurse_cnt);
+	min = sval_preop(rl_max(rl), '-');
+	max = sval_preop(rl_min(rl), '-');
+	return alloc_rl(min, max);
+}
+
+static struct range_list *handle_preop_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	switch (expr->op) {
+	case '&':
+		return handle_ampersand_rl(expr, implied, recurse_cnt);
+	case '!':
+		return handle_negate_rl(expr, implied, recurse_cnt);
+	case '~':
+		return handle_bitwise_negate(expr, implied, recurse_cnt);
+	case '-':
+		return handle_minus_preop(expr, implied, recurse_cnt);
+	case '*':
+		return handle_variable(expr, implied, recurse_cnt);
+	case '(':
+		return handle_expression_statement_rl(expr, implied, recurse_cnt);
+	default:
+		return NULL;
+	}
+}
+
+static struct range_list *handle_divide_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *left_rl, *right_rl;
+	struct symbol *type;
+
+	type = get_type(expr);
+
+	left_rl = _get_rl(expr->left, implied, recurse_cnt);
+	left_rl = cast_rl(type, left_rl);
+	right_rl = _get_rl(expr->right, implied, recurse_cnt);
+	right_rl = cast_rl(type, right_rl);
+
+	if (!left_rl || !right_rl)
+		return NULL;
+
+	if (implied != RL_REAL_ABSOLUTE) {
+		if (is_whole_rl(left_rl) || is_whole_rl(right_rl))
+			return NULL;
+	}
+
+	return rl_binop(left_rl, '/', right_rl);
+}
+
+static int handle_offset_subtraction(struct expression *expr)
+{
+	struct expression *left, *right;
+	struct symbol *left_sym, *right_sym;
+	struct symbol *type;
+	int left_offset, right_offset;
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_PTR)
+		return -1;
+	type = get_real_base_type(type);
+	if (!type || (type_bits(type) != 8 && (type != &void_ctype)))
+		return -1;
+
+	left = strip_expr(expr->left);
+	right = strip_expr(expr->right);
+
+	if (left->type != EXPR_PREOP || left->op != '&')
+		return -1;
+	left = strip_expr(left->unop);
+
+	left_sym = expr_to_sym(left);
+	right_sym = expr_to_sym(right);
+	if (!left_sym || left_sym != right_sym)
+		return -1;
+
+	left_offset = get_member_offset_from_deref(left);
+	if (right->type == EXPR_SYMBOL)
+		right_offset = 0;
+	else {
+		if (right->type != EXPR_PREOP || right->op != '&')
+			return -1;
+		right = strip_expr(right->unop);
+		right_offset = get_member_offset_from_deref(right);
+	}
+	if (left_offset < 0 || right_offset < 0)
+		return -1;
+
+	return left_offset - right_offset;
+}
+
+static struct range_list *handle_subtract_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct symbol *type;
+	struct range_list *left_orig, *right_orig;
+	struct range_list *left_rl, *right_rl;
+	sval_t max, min, tmp;
+	int comparison;
+	int offset;
+
+	type = get_type(expr);
+
+	offset = handle_offset_subtraction(expr);
+	if (offset >= 0) {
+		tmp.type = type;
+		tmp.value = offset;
+
+		return alloc_rl(tmp, tmp);
+	}
+
+	comparison = get_comparison(expr->left, expr->right);
+
+	left_orig = _get_rl(expr->left, implied, recurse_cnt);
+	left_rl = cast_rl(type, left_orig);
+	right_orig = _get_rl(expr->right, implied, recurse_cnt);
+	right_rl = cast_rl(type, right_orig);
+
+	if ((!left_rl || !right_rl) &&
+	    (implied == RL_EXACT || implied == RL_HARD || implied == RL_FUZZY))
+		return NULL;
+
+	if (!left_rl)
+		left_rl = alloc_whole_rl(type);
+	if (!right_rl)
+		right_rl = alloc_whole_rl(type);
+
+	/* negative values complicate everything fix this later */
+	if (sval_is_negative(rl_min(right_rl)))
+		return NULL;
+	max = rl_max(left_rl);
+	min = sval_type_min(type);
+
+	switch (comparison) {
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+		min = sval_type_val(type, 1);
+		max = rl_max(left_rl);
+		break;
+	case SPECIAL_GTE:
+	case SPECIAL_UNSIGNED_GTE:
+		min = sval_type_val(type, 0);
+		max = rl_max(left_rl);
+		break;
+	case SPECIAL_EQUAL:
+		min = sval_type_val(type, 0);
+		max = sval_type_val(type, 0);
+		break;
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+		max = sval_type_val(type, -1);
+		break;
+	case SPECIAL_LTE:
+	case SPECIAL_UNSIGNED_LTE:
+		max = sval_type_val(type, 0);
+		break;
+	default:
+		if (!left_orig || !right_orig)
+			return NULL;
+		return rl_binop(left_rl, '-', right_rl);
+	}
+
+	if (!sval_binop_overflows(rl_min(left_rl), '-', rl_max(right_rl))) {
+		tmp = sval_binop(rl_min(left_rl), '-', rl_max(right_rl));
+		if (sval_cmp(tmp, min) > 0)
+			min = tmp;
+	}
+
+	if (!sval_is_max(rl_max(left_rl))) {
+		tmp = sval_binop(rl_max(left_rl), '-', rl_min(right_rl));
+		if (sval_cmp(tmp, max) < 0)
+			max = tmp;
+	}
+
+	if (sval_is_min(min) && sval_is_max(max))
+		return NULL;
+
+	return cast_rl(type, alloc_rl(min, max));
+}
+
+static struct range_list *handle_mod_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *rl;
+	sval_t left, right, sval;
+
+	if (implied == RL_EXACT) {
+		if (!get_implied_value(expr->right, &right))
+			return NULL;
+		if (!get_implied_value(expr->left, &left))
+			return NULL;
+		sval = sval_binop(left, '%', right);
+		return alloc_rl(sval, sval);
+	}
+	/* if we can't figure out the right side it's probably hopeless */
+	if (!get_implied_value_internal(expr->right, &right, recurse_cnt))
+		return NULL;
+
+	right = sval_cast(get_type(expr), right);
+	right.value--;
+
+	rl = _get_rl(expr->left, implied, recurse_cnt);
+	if (rl && rl_max(rl).uvalue < right.uvalue)
+		right.uvalue = rl_max(rl).uvalue;
+
+	return alloc_rl(sval_cast(right.type, zero), right);
+}
+
+static sval_t sval_lowest_set_bit(sval_t sval)
+{
+	int i;
+	int found = 0;
+
+	for (i = 0; i < 64; i++) {
+		if (sval.uvalue & 1ULL << i) {
+			if (!found++)
+				continue;
+			sval.uvalue &= ~(1ULL << i);
+		}
+	}
+	return sval;
+}
+
+static struct range_list *handle_bitwise_AND(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct symbol *type;
+	struct range_list *left_rl, *right_rl;
+	sval_t known;
+	int new_recurse;
+
+	if (implied != RL_IMPLIED && implied != RL_ABSOLUTE && implied != RL_REAL_ABSOLUTE)
+		return NULL;
+
+	type = get_type(expr);
+
+	if (get_implied_value_internal(expr->left, &known, recurse_cnt)) {
+		sval_t min;
+
+		min = sval_lowest_set_bit(known);
+		left_rl = alloc_rl(min, known);
+		left_rl = cast_rl(type, left_rl);
+		add_range(&left_rl, sval_type_val(type, 0), sval_type_val(type, 0));
+	} else {
+		left_rl = _get_rl(expr->left, implied, recurse_cnt);
+		if (left_rl) {
+			left_rl = cast_rl(type, left_rl);
+			left_rl = alloc_rl(sval_type_val(type, 0), rl_max(left_rl));
+		} else {
+			if (implied == RL_HARD)
+				return NULL;
+			left_rl = alloc_whole_rl(type);
+		}
+	}
+
+	new_recurse = *recurse_cnt;
+	if (*recurse_cnt >= 200)
+		new_recurse = 100;  /* Let's try super hard to get the mask */
+	if (get_implied_value_internal(expr->right, &known, &new_recurse)) {
+		sval_t min, left_max, mod;
+
+		*recurse_cnt = new_recurse;
+
+		min = sval_lowest_set_bit(known);
+		right_rl = alloc_rl(min, known);
+		right_rl = cast_rl(type, right_rl);
+		add_range(&right_rl, sval_type_val(type, 0), sval_type_val(type, 0));
+
+		if (min.value != 0) {
+			left_max = rl_max(left_rl);
+			mod = sval_binop(left_max, '%', min);
+			if (mod.value) {
+				left_max = sval_binop(left_max, '-', mod);
+				left_max.value++;
+				if (left_max.value > 0 && sval_cmp(left_max, rl_max(left_rl)) < 0)
+					left_rl = remove_range(left_rl, left_max, rl_max(left_rl));
+			}
+		}
+	} else {
+		right_rl = _get_rl(expr->right, implied, recurse_cnt);
+		if (right_rl) {
+			right_rl = cast_rl(type, right_rl);
+			right_rl = alloc_rl(sval_type_val(type, 0), rl_max(right_rl));
+		} else {
+			if (implied == RL_HARD)
+				return NULL;
+			right_rl = alloc_whole_rl(type);
+		}
+	}
+
+	return rl_intersection(left_rl, right_rl);
+}
+
+static struct range_list *use_rl_binop(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct symbol *type;
+	struct range_list *left_rl, *right_rl;
+
+	if (implied != RL_IMPLIED && implied != RL_ABSOLUTE && implied != RL_REAL_ABSOLUTE)
+		return NULL;
+
+	type = get_type(expr);
+
+	get_absolute_rl_internal(expr->left, &left_rl, recurse_cnt);
+	get_absolute_rl_internal(expr->right, &right_rl, recurse_cnt);
+	left_rl = cast_rl(type, left_rl);
+	right_rl = cast_rl(type, right_rl);
+	if (!left_rl || !right_rl)
+		return NULL;
+
+	return rl_binop(left_rl, expr->op, right_rl);
+}
+
+static struct range_list *handle_right_shift(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *left_rl;
+	sval_t right;
+	sval_t min, max;
+
+	if (implied == RL_EXACT || implied == RL_HARD)
+		return NULL;
+
+	left_rl = _get_rl(expr->left, implied, recurse_cnt);
+	if (left_rl) {
+		max = rl_max(left_rl);
+		min = rl_min(left_rl);
+	} else {
+		if (implied == RL_FUZZY)
+			return NULL;
+		max = sval_type_max(get_type(expr->left));
+		min = sval_type_val(get_type(expr->left), 0);
+	}
+
+	if (get_implied_value_internal(expr->right, &right, recurse_cnt)) {
+		min = sval_binop(min, SPECIAL_RIGHTSHIFT, right);
+		max = sval_binop(max, SPECIAL_RIGHTSHIFT, right);
+	} else if (!sval_is_negative(min)) {
+		min.value = 0;
+		max = sval_type_max(max.type);
+	} else {
+		return NULL;
+	}
+
+	return alloc_rl(min, max);
+}
+
+static struct range_list *handle_left_shift(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *left_rl, *res;
+	sval_t right;
+	sval_t min, max;
+	int add_zero = 0;
+
+	if (implied == RL_EXACT || implied == RL_HARD)
+		return NULL;
+	/* this is hopeless without the right side */
+	if (!get_implied_value_internal(expr->right, &right, recurse_cnt))
+		return NULL;
+	left_rl = _get_rl(expr->left, implied, recurse_cnt);
+	if (left_rl) {
+		max = rl_max(left_rl);
+		min = rl_min(left_rl);
+		if (min.value == 0) {
+			min.value = 1;
+			add_zero = 1;
+		}
+	} else {
+		if (implied == RL_FUZZY)
+			return NULL;
+		max = sval_type_max(get_type(expr->left));
+		min = sval_type_val(get_type(expr->left), 1);
+		add_zero = 1;
+	}
+
+	max = sval_binop(max, SPECIAL_LEFTSHIFT, right);
+	min = sval_binop(min, SPECIAL_LEFTSHIFT, right);
+	res = alloc_rl(min, max);
+	if (add_zero)
+		res = rl_union(res, rl_zero());
+	return res;
+}
+
+static struct range_list *handle_known_binop(struct expression *expr)
+{
+	sval_t left, right;
+
+	if (!get_value(expr->left, &left))
+		return NULL;
+	if (!get_value(expr->right, &right))
+		return NULL;
+	left = sval_binop(left, expr->op, right);
+	return alloc_rl(left, left);
+}
+
+static int has_actual_ranges(struct range_list *rl)
+{
+	struct data_range *tmp;
+
+	FOR_EACH_PTR(rl, tmp) {
+		if (sval_cmp(tmp->min, tmp->max) != 0)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+static struct range_list *handle_implied_binop(struct range_list *left_rl, int op, struct range_list *right_rl)
+{
+	struct range_list *res_rl;
+	struct data_range *left_drange, *right_drange;
+	sval_t res;
+
+	if (!left_rl || !right_rl)
+		return NULL;
+	if (has_actual_ranges(left_rl))
+		return NULL;
+	if (has_actual_ranges(right_rl))
+		return NULL;
+
+	if (ptr_list_size((struct ptr_list *)left_rl) * ptr_list_size((struct ptr_list *)right_rl) > 20)
+		return NULL;
+
+	res_rl = NULL;
+
+	FOR_EACH_PTR(left_rl, left_drange) {
+		FOR_EACH_PTR(right_rl, right_drange) {
+			if ((op == '%' || op == '/') &&
+			    right_drange->min.value == 0)
+				return NULL;
+			res = sval_binop(left_drange->min, op, right_drange->min);
+			add_range(&res_rl, res, res);
+		} END_FOR_EACH_PTR(right_drange);
+	} END_FOR_EACH_PTR(left_drange);
+
+	return res_rl;
+}
+
+static struct range_list *handle_binop_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct smatch_state *state;
+	struct symbol *type;
+	struct range_list *left_rl, *right_rl, *rl;
+	sval_t min, max;
+
+	rl = handle_known_binop(expr);
+	if (rl)
+		return rl;
+	if (implied == RL_EXACT)
+		return NULL;
+
+	if (custom_handle_variable) {
+		rl = custom_handle_variable(expr);
+		if (rl)
+			return rl;
+	}
+
+	state = get_extra_state(expr);
+	if (state && !is_whole_rl(estate_rl(state))) {
+		if (implied != RL_HARD || estate_has_hard_max(state))
+			return clone_rl(estate_rl(state));
+	}
+
+	type = get_type(expr);
+	left_rl = _get_rl(expr->left, implied, recurse_cnt);
+	left_rl = cast_rl(type, left_rl);
+	right_rl = _get_rl(expr->right, implied, recurse_cnt);
+	right_rl = cast_rl(type, right_rl);
+
+	if (!left_rl && !right_rl)
+		return NULL;
+
+	rl = handle_implied_binop(left_rl, expr->op, right_rl);
+	if (rl)
+		return rl;
+
+	switch (expr->op) {
+	case '%':
+		return handle_mod_rl(expr, implied, recurse_cnt);
+	case '&':
+		return handle_bitwise_AND(expr, implied, recurse_cnt);
+	case '|':
+	case '^':
+		return use_rl_binop(expr, implied, recurse_cnt);
+	case SPECIAL_RIGHTSHIFT:
+		return handle_right_shift(expr, implied, recurse_cnt);
+	case SPECIAL_LEFTSHIFT:
+		return handle_left_shift(expr, implied, recurse_cnt);
+	case '-':
+		return handle_subtract_rl(expr, implied, recurse_cnt);
+	case '/':
+		return handle_divide_rl(expr, implied, recurse_cnt);
+	}
+
+	if (!left_rl || !right_rl)
+		return NULL;
+
+	if (sval_binop_overflows(rl_min(left_rl), expr->op, rl_min(right_rl)))
+		return NULL;
+	if (sval_binop_overflows(rl_max(left_rl), expr->op, rl_max(right_rl)))
+		return NULL;
+
+	min = sval_binop(rl_min(left_rl), expr->op, rl_min(right_rl));
+	max = sval_binop(rl_max(left_rl), expr->op, rl_max(right_rl));
+
+	return alloc_rl(min, max);
+}
+
+static int do_comparison(struct expression *expr)
+{
+	struct range_list *left_ranges = NULL;
+	struct range_list *right_ranges = NULL;
+	int poss_true, poss_false;
+	struct symbol *type;
+
+	type = get_type(expr);
+	get_absolute_rl(expr->left, &left_ranges);
+	get_absolute_rl(expr->right, &right_ranges);
+
+	left_ranges = cast_rl(type, left_ranges);
+	right_ranges = cast_rl(type, right_ranges);
+
+	poss_true = possibly_true_rl(left_ranges, expr->op, right_ranges);
+	poss_false = possibly_false_rl(left_ranges, expr->op, right_ranges);
+
+	if (!poss_true && !poss_false)
+		return 0x0;
+	if (poss_true && !poss_false)
+		return 0x1;
+	if (!poss_true && poss_false)
+		return 0x2;
+	return 0x3;
+}
+
+static struct range_list *handle_comparison_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	sval_t left, right;
+	int res;
+
+	if (expr->op == SPECIAL_EQUAL && expr->left->type == EXPR_TYPE) {
+		struct symbol *left, *right;
+
+		left = get_real_base_type(expr->left->symbol);
+		right = get_real_base_type(expr->left->symbol);
+		if (left == right)
+			return rl_one();
+		return rl_zero();
+	}
+
+	if (get_value(expr->left, &left) && get_value(expr->right, &right)) {
+		struct data_range tmp_left, tmp_right;
+
+		tmp_left.min = left;
+		tmp_left.max = left;
+		tmp_right.min = right;
+		tmp_right.max = right;
+		if (true_comparison_range(&tmp_left, expr->op, &tmp_right))
+			return rl_one();
+		return rl_zero();
+	}
+
+	if (implied == RL_EXACT)
+		return NULL;
+
+	res = do_comparison(expr);
+	if (res == 1)
+		return rl_one();
+	if (res == 2)
+		return rl_zero();
+
+	return alloc_rl(zero, one);
+}
+
+static struct range_list *handle_logical_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	sval_t left, right;
+	int left_known = 0;
+	int right_known = 0;
+
+	if (implied == RL_EXACT) {
+		if (get_value(expr->left, &left))
+			left_known = 1;
+		if (get_value(expr->right, &right))
+			right_known = 1;
+	} else {
+		if (get_implied_value_internal(expr->left, &left, recurse_cnt))
+			left_known = 1;
+		if (get_implied_value_internal(expr->right, &right, recurse_cnt))
+			right_known = 1;
+	}
+
+	switch (expr->op) {
+	case SPECIAL_LOGICAL_OR:
+		if (left_known && left.value)
+			return rl_one();
+		if (right_known && right.value)
+			return rl_one();
+		if (left_known && right_known)
+			return rl_zero();
+		break;
+	case SPECIAL_LOGICAL_AND:
+		if (left_known && right_known) {
+			if (left.value && right.value)
+				return rl_one();
+			return rl_zero();
+		}
+		break;
+	default:
+		return NULL;
+	}
+
+	if (implied == RL_EXACT)
+		return NULL;
+
+	return alloc_rl(zero, one);
+}
+
+static struct range_list *handle_conditional_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct expression *cond_true;
+	struct range_list *true_rl, *false_rl;
+	struct symbol *type;
+	int final_pass_orig = final_pass;
+
+	cond_true = expr->cond_true;
+	if (!cond_true)
+		cond_true = expr->conditional;
+
+	if (known_condition_true(expr->conditional))
+		return _get_rl(cond_true, implied, recurse_cnt);
+	if (known_condition_false(expr->conditional))
+		return _get_rl(expr->cond_false, implied, recurse_cnt);
+
+	if (implied == RL_EXACT)
+		return NULL;
+
+	if (implied_condition_true(expr->conditional))
+		return _get_rl(cond_true, implied, recurse_cnt);
+	if (implied_condition_false(expr->conditional))
+		return _get_rl(expr->cond_false, implied, recurse_cnt);
+
+
+	/* this becomes a problem with deeply nested conditional statements */
+	if (low_on_memory())
+		return NULL;
+
+	type = get_type(expr);
+
+	__push_fake_cur_stree();
+	final_pass = 0;
+	__split_whole_condition(expr->conditional);
+	true_rl = _get_rl(cond_true, implied, recurse_cnt);
+	__push_true_states();
+	__use_false_states();
+	false_rl = _get_rl(expr->cond_false, implied, recurse_cnt);
+	__merge_true_states();
+	__free_fake_cur_stree();
+	final_pass = final_pass_orig;
+
+	if (!true_rl || !false_rl)
+		return NULL;
+	true_rl = cast_rl(type, true_rl);
+	false_rl = cast_rl(type, false_rl);
+
+	return rl_union(true_rl, false_rl);
+}
+
+static int get_fuzzy_max_helper(struct expression *expr, sval_t *max)
+{
+	struct smatch_state *state;
+	sval_t sval;
+
+	if (get_hard_max(expr, &sval)) {
+		*max = sval;
+		return 1;
+	}
+
+	state = get_extra_state(expr);
+	if (!state || !estate_has_fuzzy_max(state))
+		return 0;
+	*max = sval_cast(get_type(expr), estate_get_fuzzy_max(state));
+	return 1;
+}
+
+static int get_fuzzy_min_helper(struct expression *expr, sval_t *min)
+{
+	struct smatch_state *state;
+	sval_t sval;
+
+	state = get_extra_state(expr);
+	if (!state || !estate_rl(state))
+		return 0;
+
+	sval = estate_min(state);
+	if (sval_is_negative(sval) && sval_is_min(sval))
+		return 0;
+
+	if (sval_is_max(sval))
+		return 0;
+
+	*min = sval_cast(get_type(expr), sval);
+	return 1;
+}
+
+int get_const_value(struct expression *expr, sval_t *sval)
+{
+	struct symbol *sym;
+	sval_t right;
+
+	if (expr->type != EXPR_SYMBOL || !expr->symbol)
+		return 0;
+	sym = expr->symbol;
+	if (!(sym->ctype.modifiers & MOD_CONST))
+		return 0;
+	if (get_value(sym->initializer, &right)) {
+		*sval = sval_cast(get_type(expr), right);
+		return 1;
+	}
+	return 0;
+}
+
+struct range_list *var_to_absolute_rl(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct range_list *rl;
+
+	state = get_extra_state(expr);
+	if (!state || is_whole_rl(estate_rl(state))) {
+		state = get_real_absolute_state(expr);
+		if (state && state->data && !estate_is_whole(state))
+			return clone_rl(estate_rl(state));
+		if (get_local_rl(expr, &rl) && !is_whole_rl(rl))
+			return rl;
+		if (get_mtag_rl(expr, &rl))
+			return rl;
+		if (get_db_type_rl(expr, &rl) && !is_whole_rl(rl))
+			return rl;
+		return alloc_whole_rl(get_type(expr));
+	}
+	/* err on the side of saying things are possible */
+	if (!estate_rl(state))
+		return alloc_whole_rl(get_type(expr));
+	return clone_rl(estate_rl(state));
+}
+
+static struct range_list *handle_variable(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct smatch_state *state;
+	struct range_list *rl;
+	sval_t sval, min, max;
+	struct symbol *type;
+
+	if (get_const_value(expr, &sval))
+		return alloc_rl(sval, sval);
+
+	if (custom_handle_variable) {
+		rl = custom_handle_variable(expr);
+		if (!rl)
+			return var_to_absolute_rl(expr);
+		return rl;
+	}
+
+	if (implied == RL_EXACT)
+		return NULL;
+
+	if (get_mtag_sval(expr, &sval))
+		return alloc_rl(sval, sval);
+
+	type = get_type(expr);
+	if (type && type->type == SYM_FN)
+		return alloc_rl(fn_ptr_min, fn_ptr_max);
+
+	switch (implied) {
+	case RL_HARD:
+	case RL_IMPLIED:
+	case RL_ABSOLUTE:
+		state = get_extra_state(expr);
+		if (!state || !state->data) {
+			if (implied == RL_HARD)
+				return NULL;
+			if (get_local_rl(expr, &rl))
+				return rl;
+			if (get_mtag_rl(expr, &rl))
+				return rl;
+			if (get_db_type_rl(expr, &rl))
+				return rl;
+			if (is_array(expr) && get_array_rl(expr, &rl))
+				return rl;
+			return NULL;
+		}
+		if (implied == RL_HARD && !estate_has_hard_max(state))
+			return NULL;
+		return clone_rl(estate_rl(state));
+	case RL_REAL_ABSOLUTE: {
+		struct smatch_state *abs_state;
+
+		state = get_extra_state(expr);
+		abs_state = get_real_absolute_state(expr);
+
+		if (estate_rl(state) && estate_rl(abs_state)) {
+			return clone_rl(rl_intersection(estate_rl(state),
+							estate_rl(abs_state)));
+		} else if (estate_rl(state)) {
+			return clone_rl(estate_rl(state));
+		} else if (estate_is_empty(state)) {
+			/*
+			 * FIXME: we don't handle empty extra states correctly.
+			 *
+			 * The real abs rl is supposed to be filtered by the
+			 * extra state if there is one.  We don't bother keeping
+			 * the abs state in sync all the time because we know it
+			 * will be filtered later.
+			 *
+			 * It's not totally obvious to me how they should be
+			 * handled.  Perhaps we should take the whole rl and
+			 * filter by the imaginary states.  Perhaps we should
+			 * just go with the empty state.
+			 *
+			 * Anyway what we currently do is return NULL here and
+			 * that gets translated into the whole range in
+			 * get_real_absolute_rl().
+			 *
+			 */
+			return NULL;
+		} else if (estate_rl(abs_state)) {
+			return clone_rl(estate_rl(abs_state));
+		}
+
+		if (get_local_rl(expr, &rl))
+			return rl;
+		if (get_mtag_rl(expr, &rl))
+			return rl;
+		if (get_db_type_rl(expr, &rl))
+			return rl;
+		if (is_array(expr) && get_array_rl(expr, &rl))
+			return rl;
+		return NULL;
+	}
+	case RL_FUZZY:
+		if (!get_fuzzy_min_helper(expr, &min))
+			min = sval_type_min(get_type(expr));
+		if (!get_fuzzy_max_helper(expr, &max))
+			return NULL;
+		/* fuzzy ranges are often inverted */
+		if (sval_cmp(min, max) > 0) {
+			sval = min;
+			min = max;
+			max = sval;
+		}
+		return alloc_rl(min, max);
+	}
+	return NULL;
+}
+
+static sval_t handle_sizeof(struct expression *expr)
+{
+	struct symbol *sym;
+	sval_t ret;
+
+	ret = sval_blank(expr);
+	sym = expr->cast_type;
+	if (!sym) {
+		sym = evaluate_expression(expr->cast_expression);
+		if (!sym) {
+			__silence_warnings_for_stmt = true;
+			sym = &int_ctype;
+		}
+#if 0
+		/*
+		 * Expressions of restricted types will possibly get
+		 * promoted - check that here.  I'm not sure how this works,
+		 * the problem is that sizeof(le16) shouldn't be promoted and
+		 * the original code did that...  Let's if zero this out and
+		 * see what breaks.
+		 */
+
+		if (is_restricted_type(sym)) {
+			if (type_bits(sym) < bits_in_int)
+				sym = &int_ctype;
+		}
+#endif
+		if (is_fouled_type(sym))
+			sym = &int_ctype;
+	}
+	examine_symbol_type(sym);
+
+	ret.type = size_t_ctype;
+	if (type_bits(sym) <= 0) /* sizeof(void) */ {
+		if (get_real_base_type(sym) == &void_ctype)
+			ret.value = 1;
+		else
+			ret.value = 0;
+	} else
+		ret.value = type_bytes(sym);
+
+	return ret;
+}
+
+static struct range_list *handle_strlen(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *rl;
+	struct expression *arg, *tmp;
+	sval_t tag;
+	sval_t ret = { .type = &ulong_ctype };
+
+	if (implied == RL_EXACT)
+		return NULL;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	if (!arg)
+		return NULL;
+	if (arg->type == EXPR_STRING) {
+		ret.value = arg->string->length - 1;
+		return alloc_rl(ret, ret);
+	}
+	if (get_implied_value(arg, &tag) &&
+	    (tmp = fake_string_from_mtag(tag.uvalue))) {
+		ret.value = tmp->string->length - 1;
+		return alloc_rl(ret, ret);
+	}
+
+	if (implied == RL_HARD || implied == RL_FUZZY)
+		return NULL;
+
+	if (get_implied_return(expr, &rl))
+		return rl;
+
+	return NULL;
+}
+
+static struct range_list *handle_builtin_constant_p(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct expression *arg;
+	struct range_list *rl;
+	sval_t sval;
+
+	arg = get_argument_from_call_expr(expr->args, 0);
+	rl = _get_rl(arg, RL_EXACT, recurse_cnt);
+	if (rl_to_sval(rl, &sval))
+		return rl_one();
+	return rl_zero();
+}
+
+static struct range_list *handle__builtin_choose_expr(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct expression *const_expr, *expr1, *expr2;
+	sval_t sval;
+
+	const_expr = get_argument_from_call_expr(expr->args, 0);
+	expr1 = get_argument_from_call_expr(expr->args, 1);
+	expr2 = get_argument_from_call_expr(expr->args, 2);
+
+	if (!get_value(const_expr, &sval) || !expr1 || !expr2)
+		return NULL;
+	if (sval.value)
+		return _get_rl(expr1, implied, recurse_cnt);
+	return _get_rl(expr2, implied, recurse_cnt);
+}
+
+static struct range_list *handle_call_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *rl;
+
+	if (sym_name_is("__builtin_constant_p", expr->fn))
+		return handle_builtin_constant_p(expr, implied, recurse_cnt);
+
+	if (sym_name_is("__builtin_choose_expr", expr->fn))
+		return handle__builtin_choose_expr(expr, implied, recurse_cnt);
+
+	if (sym_name_is("__builtin_expect", expr->fn) ||
+	    sym_name_is("__builtin_bswap16", expr->fn) ||
+	    sym_name_is("__builtin_bswap32", expr->fn) ||
+	    sym_name_is("__builtin_bswap64", expr->fn)) {
+		struct expression *arg;
+
+		arg = get_argument_from_call_expr(expr->args, 0);
+		return _get_rl(arg, implied, recurse_cnt);
+	}
+
+	if (sym_name_is("strlen", expr->fn))
+		return handle_strlen(expr, implied, recurse_cnt);
+
+	if (implied == RL_EXACT || implied == RL_HARD || implied == RL_FUZZY)
+		return NULL;
+
+	if (custom_handle_variable) {
+		rl = custom_handle_variable(expr);
+		if (rl)
+			return rl;
+	}
+
+	if (get_implied_return(expr, &rl))
+		return rl;
+	return db_return_vals(expr);
+}
+
+static struct range_list *handle_cast(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *rl;
+	struct symbol *type;
+
+	type = get_type(expr);
+	rl = _get_rl(expr->cast_expression, implied, recurse_cnt);
+	if (rl)
+		return cast_rl(type, rl);
+	if (implied == RL_ABSOLUTE || implied == RL_REAL_ABSOLUTE)
+		return alloc_whole_rl(type);
+	if (implied == RL_IMPLIED && type &&
+	    type_bits(type) > 0 && type_bits(type) < 32)
+		return alloc_whole_rl(type);
+	return NULL;
+}
+
+static struct range_list *_get_rl(struct expression *expr, int implied, int *recurse_cnt)
+{
+	struct range_list *rl;
+	struct symbol *type;
+	sval_t sval;
+
+	type = get_type(expr);
+	expr = strip_parens(expr);
+	if (!expr)
+		return NULL;
+
+	if (++(*recurse_cnt) >= 200)
+		return NULL;
+
+	switch(expr->type) {
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+	case EXPR_IMPLIED_CAST:
+		rl = handle_cast(expr, implied, recurse_cnt);
+		goto out_cast;
+	}
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return NULL;
+
+	switch (expr->type) {
+	case EXPR_VALUE:
+		sval = sval_from_val(expr, expr->value);
+		rl = alloc_rl(sval, sval);
+		break;
+	case EXPR_PREOP:
+		rl = handle_preop_rl(expr, implied, recurse_cnt);
+		break;
+	case EXPR_POSTOP:
+		rl = _get_rl(expr->unop, implied, recurse_cnt);
+		break;
+	case EXPR_BINOP:
+		rl = handle_binop_rl(expr, implied, recurse_cnt);
+		break;
+	case EXPR_COMPARE:
+		rl = handle_comparison_rl(expr, implied, recurse_cnt);
+		break;
+	case EXPR_LOGICAL:
+		rl = handle_logical_rl(expr, implied, recurse_cnt);
+		break;
+	case EXPR_PTRSIZEOF:
+	case EXPR_SIZEOF:
+		sval = handle_sizeof(expr);
+		rl = alloc_rl(sval, sval);
+		break;
+	case EXPR_SELECT:
+	case EXPR_CONDITIONAL:
+		rl = handle_conditional_rl(expr, implied, recurse_cnt);
+		break;
+	case EXPR_CALL:
+		rl = handle_call_rl(expr, implied, recurse_cnt);
+		break;
+	case EXPR_STRING:
+		rl = NULL;
+		if (get_mtag_sval(expr, &sval))
+			rl = alloc_rl(sval, sval);
+		break;
+	default:
+		rl = handle_variable(expr, implied, recurse_cnt);
+	}
+
+out_cast:
+	if (rl)
+		return rl;
+	if (type && (implied == RL_ABSOLUTE || implied == RL_REAL_ABSOLUTE))
+		return alloc_whole_rl(type);
+	return NULL;
+}
+
+struct {
+	struct expression *expr;
+	struct range_list *rl;
+} cached_results[24];
+static int cache_idx;
+
+void clear_math_cache(void)
+{
+	memset(cached_results, 0, sizeof(cached_results));
+}
+
+/* returns 1 if it can get a value literal or else returns 0 */
+int get_value(struct expression *expr, sval_t *sval)
+{
+	struct range_list *(*orig_custom_fn)(struct expression *expr);
+	struct range_list *rl;
+	int recurse_cnt = 0;
+	sval_t tmp;
+	int i;
+
+	/*
+	 * This only handles RL_EXACT because other expr statements can be
+	 * different at different points.  Like the list iterator, for example.
+	 */
+	for (i = 0; i < ARRAY_SIZE(cached_results); i++) {
+		if (expr == cached_results[i].expr)
+			return rl_to_sval(cached_results[i].rl, sval);
+	}
+
+	orig_custom_fn = custom_handle_variable;
+	custom_handle_variable = NULL;
+	rl = _get_rl(expr, RL_EXACT, &recurse_cnt);
+	if (!rl_to_sval(rl, &tmp))
+		rl = NULL;
+	custom_handle_variable = orig_custom_fn;
+
+	cached_results[cache_idx].expr = expr;
+	cached_results[cache_idx].rl = rl;
+	cache_idx = (cache_idx + 1) % ARRAY_SIZE(cached_results);
+
+	if (!rl)
+		return 0;
+
+	*sval = tmp;
+	return 1;
+}
+
+static int get_implied_value_internal(struct expression *expr, sval_t *sval, int *recurse_cnt)
+{
+	struct range_list *rl;
+
+	rl =  _get_rl(expr, RL_IMPLIED, recurse_cnt);
+	if (!rl_to_sval(rl, sval))
+		return 0;
+	return 1;
+}
+
+int get_implied_value(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+	int recurse_cnt = 0;
+
+	rl =  _get_rl(expr, RL_IMPLIED, &recurse_cnt);
+	if (!rl_to_sval(rl, sval))
+		return 0;
+	return 1;
+}
+
+int get_implied_min(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+	int recurse_cnt = 0;
+
+	rl =  _get_rl(expr, RL_IMPLIED, &recurse_cnt);
+	if (!rl)
+		return 0;
+	*sval = rl_min(rl);
+	return 1;
+}
+
+int get_implied_max(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+	int recurse_cnt = 0;
+
+	rl =  _get_rl(expr, RL_IMPLIED, &recurse_cnt);
+	if (!rl)
+		return 0;
+	*sval = rl_max(rl);
+	return 1;
+}
+
+int get_implied_rl(struct expression *expr, struct range_list **rl)
+{
+	int recurse_cnt = 0;
+
+	*rl = _get_rl(expr, RL_IMPLIED, &recurse_cnt);
+	if (*rl)
+		return 1;
+	return 0;
+}
+
+static int get_absolute_rl_internal(struct expression *expr, struct range_list **rl, int *recurse_cnt)
+{
+	*rl = _get_rl(expr, RL_ABSOLUTE, recurse_cnt);
+	if (!*rl)
+		*rl = alloc_whole_rl(get_type(expr));
+	return 1;
+}
+
+int get_absolute_rl(struct expression *expr, struct range_list **rl)
+{
+	int recurse_cnt = 0;
+
+	*rl = _get_rl(expr, RL_ABSOLUTE, &recurse_cnt);
+	if (!*rl)
+		*rl = alloc_whole_rl(get_type(expr));
+	return 1;
+}
+
+int get_real_absolute_rl(struct expression *expr, struct range_list **rl)
+{
+	int recurse_cnt = 0;
+
+	*rl = _get_rl(expr, RL_REAL_ABSOLUTE, &recurse_cnt);
+	if (!*rl)
+		*rl = alloc_whole_rl(get_type(expr));
+	return 1;
+}
+
+int custom_get_absolute_rl(struct expression *expr,
+			   struct range_list *(*fn)(struct expression *expr),
+			   struct range_list **rl)
+{
+	int recurse_cnt = 0;
+
+	*rl = NULL;
+	custom_handle_variable = fn;
+	*rl = _get_rl(expr, RL_REAL_ABSOLUTE, &recurse_cnt);
+	custom_handle_variable = NULL;
+	return 1;
+}
+
+int get_implied_rl_var_sym(const char *var, struct symbol *sym, struct range_list **rl)
+{
+	struct smatch_state *state;
+
+	state = get_state(SMATCH_EXTRA, var, sym);
+	*rl = estate_rl(state);
+	if (*rl)
+		return 1;
+	return 0;
+}
+
+int get_hard_max(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+	int recurse_cnt = 0;
+
+	rl =  _get_rl(expr, RL_HARD, &recurse_cnt);
+	if (!rl)
+		return 0;
+	*sval = rl_max(rl);
+	return 1;
+}
+
+int get_fuzzy_min(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+	sval_t tmp;
+	int recurse_cnt = 0;
+
+	rl =  _get_rl(expr, RL_FUZZY, &recurse_cnt);
+	if (!rl)
+		return 0;
+	tmp = rl_min(rl);
+	if (sval_is_negative(tmp) && sval_is_min(tmp))
+		return 0;
+	*sval = tmp;
+	return 1;
+}
+
+int get_fuzzy_max(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+	sval_t max;
+	int recurse_cnt = 0;
+
+	rl =  _get_rl(expr, RL_FUZZY, &recurse_cnt);
+	if (!rl)
+		return 0;
+	max = rl_max(rl);
+	if (max.uvalue > INT_MAX - 10000)
+		return 0;
+	*sval = max;
+	return 1;
+}
+
+int get_absolute_min(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+	struct symbol *type;
+	int recurse_cnt = 0;
+
+	type = get_type(expr);
+	if (!type)
+		type = &llong_ctype;  // FIXME: this is wrong but places assume get type can't fail.
+	rl = _get_rl(expr, RL_REAL_ABSOLUTE, &recurse_cnt);
+	if (rl)
+		*sval = rl_min(rl);
+	else
+		*sval = sval_type_min(type);
+
+	if (sval_cmp(*sval, sval_type_min(type)) < 0)
+		*sval = sval_type_min(type);
+	return 1;
+}
+
+int get_absolute_max(struct expression *expr, sval_t *sval)
+{
+	struct range_list *rl;
+	struct symbol *type;
+	int recurse_cnt = 0;
+
+	type = get_type(expr);
+	if (!type)
+		type = &llong_ctype;
+	rl = _get_rl(expr, RL_REAL_ABSOLUTE, &recurse_cnt);
+	if (rl)
+		*sval = rl_max(rl);
+	else
+		*sval = sval_type_max(type);
+
+	if (sval_cmp(sval_type_max(type), *sval) < 0)
+		*sval = sval_type_max(type);
+	return 1;
+}
+
+int known_condition_true(struct expression *expr)
+{
+	sval_t tmp;
+
+	if (!expr)
+		return 0;
+
+	if (get_value(expr, &tmp) && tmp.value)
+		return 1;
+
+	return 0;
+}
+
+int known_condition_false(struct expression *expr)
+{
+	if (!expr)
+		return 0;
+
+	if (is_zero(expr))
+		return 1;
+
+	return 0;
+}
+
+int implied_condition_true(struct expression *expr)
+{
+	sval_t tmp;
+
+	if (!expr)
+		return 0;
+
+	if (known_condition_true(expr))
+		return 1;
+	if (get_implied_value(expr, &tmp) && tmp.value)
+		return 1;
+
+	if (expr->type == EXPR_POSTOP)
+		return implied_condition_true(expr->unop);
+
+	if (expr->type == EXPR_PREOP && expr->op == SPECIAL_DECREMENT)
+		return implied_not_equal(expr->unop, 1);
+	if (expr->type == EXPR_PREOP && expr->op == SPECIAL_INCREMENT)
+		return implied_not_equal(expr->unop, -1);
+
+	expr = strip_expr(expr);
+	switch (expr->type) {
+	case EXPR_COMPARE:
+		if (do_comparison(expr) == 1)
+			return 1;
+		break;
+	case EXPR_PREOP:
+		if (expr->op == '!') {
+			if (implied_condition_false(expr->unop))
+				return 1;
+			break;
+		}
+		break;
+	default:
+		if (implied_not_equal(expr, 0) == 1)
+			return 1;
+		break;
+	}
+	return 0;
+}
+
+int implied_condition_false(struct expression *expr)
+{
+	struct expression *tmp;
+	sval_t sval;
+
+	if (!expr)
+		return 0;
+
+	if (known_condition_false(expr))
+		return 1;
+
+	switch (expr->type) {
+	case EXPR_COMPARE:
+		if (do_comparison(expr) == 2)
+			return 1;
+	case EXPR_PREOP:
+		if (expr->op == '!') {
+			if (implied_condition_true(expr->unop))
+				return 1;
+			break;
+		}
+		tmp = strip_expr(expr);
+		if (tmp != expr)
+			return implied_condition_false(tmp);
+		break;
+	default:
+		if (get_implied_value(expr, &sval) && sval.value == 0)
+			return 1;
+		break;
+	}
+	return 0;
+}
+
+int can_integer_overflow(struct symbol *type, struct expression *expr)
+{
+	int op;
+	sval_t lmax, rmax, res;
+
+	if (!type)
+		type = &int_ctype;
+
+	expr = strip_expr(expr);
+
+	if (expr->type == EXPR_ASSIGNMENT) {
+		switch(expr->op) {
+		case SPECIAL_MUL_ASSIGN:
+			op = '*';
+			break;
+		case SPECIAL_ADD_ASSIGN:
+			op = '+';
+			break;
+		case SPECIAL_SHL_ASSIGN:
+			op = SPECIAL_LEFTSHIFT;
+			break;
+		default:
+			return 0;
+		}
+	} else if (expr->type == EXPR_BINOP) {
+		if (expr->op != '*' && expr->op != '+' && expr->op != SPECIAL_LEFTSHIFT)
+			return 0;
+		op = expr->op;
+	} else {
+		return 0;
+	}
+
+	get_absolute_max(expr->left, &lmax);
+	get_absolute_max(expr->right, &rmax);
+
+	if (sval_binop_overflows(lmax, op, rmax))
+		return 1;
+
+	res = sval_binop(lmax, op, rmax);
+	if (sval_cmp(res, sval_type_max(type)) > 0)
+		return 1;
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/smatch_mem_tracker.c b/usr/src/tools/smatch/src/smatch_mem_tracker.c
new file mode 100644
index 0000000000..31081139f1
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_mem_tracker.c
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2018 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include <unistd.h>
+
+static int my_id;
+
+static unsigned long max_size;
+
+static void match_end_func(struct symbol *sym)
+{
+	FILE *file;
+	char buf[1024];
+	unsigned long size;
+
+	file = fopen("/proc/self/statm", "r");
+	if (!file)
+		return;
+	fread(buf, 1, sizeof(buf), file);
+	fclose(file);
+
+	size = strtoul(buf, NULL, 10);
+	size = size * sysconf(_SC_PAGESIZE) / 1024;
+	if (size > max_size)
+		max_size = size;
+}
+
+unsigned long get_max_memory(void)
+{
+	return max_size;
+}
+
+void register_mem_tracker(int id)
+{
+	my_id = id;
+
+	add_hook(&match_end_func, END_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_modification_hooks.c b/usr/src/tools/smatch/src/smatch_modification_hooks.c
new file mode 100644
index 0000000000..b4f9e62fe3
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_modification_hooks.c
@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * There are a number of ways that variables are modified:
+ * 1) assignment
+ * 2) increment/decrement
+ * 3) assembly
+ * 4) inside functions.
+ *
+ * For setting stuff inside a function then, of course, it's more accurate if
+ * you have the cross function database built.  Otherwise we are super
+ * aggressive about marking things as modified and if you have "frob(foo);" then
+ * we assume "foo->bar" is modified.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+enum {
+	EARLY = 0,
+	LATE = 1,
+	BOTH = 2
+};
+
+static modification_hook **hooks;
+static modification_hook **hooks_late;
+
+ALLOCATOR(modification_data, "modification data");
+
+static int my_id;
+static struct smatch_state *alloc_my_state(struct expression *expr, struct smatch_state *prev)
+{
+	struct smatch_state *state;
+	struct modification_data *data;
+	char *name;
+
+	state = __alloc_smatch_state(0);
+	expr = strip_expr(expr);
+	name = expr_to_str(expr);
+	state->name = alloc_sname(name);
+	free_string(name);
+
+	data = __alloc_modification_data(0);
+	data->prev = prev;
+	data->cur = expr;
+	state->data = data;
+
+	return state;
+}
+
+void add_modification_hook(int owner, modification_hook *call_back)
+{
+	if (hooks[owner])
+		sm_fatal("multiple modification hooks for %s", check_name(owner));
+	hooks[owner] = call_back;
+}
+
+void add_modification_hook_late(int owner, modification_hook *call_back)
+{
+	if (hooks_late[owner])
+		sm_fatal("multiple late modification hooks for %s", check_name(owner));
+	hooks_late[owner] = call_back;
+}
+
+static int matches(char *name, struct symbol *sym, struct sm_state *sm)
+{
+	int len;
+
+	if (sym != sm->sym)
+		return false;
+
+	len = strlen(name);
+	if (strncmp(sm->name, name, len) == 0) {
+		if (sm->name[len] == '\0')
+			return true;
+		if (sm->name[len] == '-' || sm->name[len] == '.')
+			return true;
+	}
+	if (sm->name[0] != '*')
+		return false;
+	if (strncmp(sm->name + 1, name, len) == 0) {
+		if (sm->name[len + 1] == '\0')
+			return true;
+		if (sm->name[len + 1] == '-' || sm->name[len + 1] == '.')
+			return true;
+	}
+	return false;
+}
+
+static void call_modification_hooks_name_sym(char *name, struct symbol *sym, struct expression *mod_expr, int late)
+{
+	struct sm_state *sm;
+	struct smatch_state *prev;
+	int match;
+
+	prev = get_state(my_id, name, sym);
+
+	if (cur_func_sym && !__in_fake_assign)
+		set_state(my_id, name, sym, alloc_my_state(mod_expr, prev));
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (sm->owner > num_checks)
+			continue;
+		match = matches(name, sym, sm);
+		if (!match)
+			continue;
+
+		if (late == EARLY || late == BOTH) {
+			if (hooks[sm->owner])
+				(hooks[sm->owner])(sm, mod_expr);
+		}
+		if (late == LATE || late == BOTH) {
+			if (hooks_late[sm->owner])
+				(hooks_late[sm->owner])(sm, mod_expr);
+		}
+
+	} END_FOR_EACH_SM(sm);
+}
+
+static void call_modification_hooks(struct expression *expr, struct expression *mod_expr, int late)
+{
+	char *name;
+	struct symbol *sym;
+
+	if (late == LATE)
+		update_mtag_data(expr);
+
+	name = expr_to_known_chunk_sym(expr, &sym);
+	if (!name)
+		goto free;
+	call_modification_hooks_name_sym(name, sym, mod_expr, late);
+free:
+	free_string(name);
+}
+
+static void db_param_add(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg, *gen_expr;
+	char *name, *other_name;
+	struct symbol *sym, *other_sym;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+
+	gen_expr = gen_expression_from_key(arg, key);
+	if (gen_expr)
+		update_mtag_data(gen_expr);
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	__in_fake_assign++;
+	call_modification_hooks_name_sym(name, sym, expr, BOTH);
+	__in_fake_assign--;
+
+	other_name = map_long_to_short_name_sym(name, sym, &other_sym);
+	if (other_name) {
+		__in_fake_assign++;
+		call_modification_hooks_name_sym(other_name, other_sym, expr, BOTH);
+		__in_fake_assign--;
+		free_string(other_name);
+	}
+
+free:
+	free_string(name);
+}
+
+static void match_assign(struct expression *expr, int late)
+{
+	call_modification_hooks(expr->left, expr, late);
+}
+
+static void unop_expr(struct expression *expr, int late)
+{
+	if (expr->op != SPECIAL_DECREMENT && expr->op != SPECIAL_INCREMENT)
+		return;
+
+	call_modification_hooks(expr->unop, expr, late);
+}
+
+static void match_call(struct expression *expr)
+{
+	struct expression *arg, *tmp;
+
+	/* If we have the DB then trust the DB */
+	if (!option_no_db)
+		return;
+
+	FOR_EACH_PTR(expr->args, arg) {
+		tmp = strip_expr(arg);
+		if (tmp->type == EXPR_PREOP && tmp->op == '&')
+			call_modification_hooks(tmp->unop, expr, BOTH);
+		else
+			call_modification_hooks(deref_expression(tmp), expr, BOTH);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void asm_expr(struct statement *stmt, int late)
+{
+	struct expression *expr;
+	int state = 0;
+
+	FOR_EACH_PTR(stmt->asm_outputs, expr) {
+		switch (state) {
+		case 0: /* identifier */
+		case 1: /* constraint */
+			state++;
+			continue;
+		case 2: /* expression */
+			state = 0;
+			call_modification_hooks(expr, NULL, late);
+			continue;
+		}
+	} END_FOR_EACH_PTR(expr);
+}
+
+
+static void match_assign_early(struct expression *expr)
+{
+	match_assign(expr, EARLY);
+}
+
+static void unop_expr_early(struct expression *expr)
+{
+	unop_expr(expr, EARLY);
+}
+
+static void asm_expr_early(struct statement *stmt)
+{
+	asm_expr(stmt, EARLY);
+}
+
+static void match_assign_late(struct expression *expr)
+{
+	match_assign(expr, LATE);
+}
+
+static void unop_expr_late(struct expression *expr)
+{
+	unop_expr(expr, LATE);
+}
+
+static void asm_expr_late(struct statement *stmt)
+{
+	asm_expr(stmt, LATE);
+}
+
+struct smatch_state *get_modification_state(struct expression *expr)
+{
+	return get_state_expr(my_id, expr);
+}
+
+void register_modification_hooks(int id)
+{
+	my_id = id;
+
+	hooks = malloc((num_checks + 1) * sizeof(*hooks));
+	memset(hooks, 0, (num_checks + 1) * sizeof(*hooks));
+	hooks_late = malloc((num_checks + 1) * sizeof(*hooks));
+	memset(hooks_late, 0, (num_checks + 1) * sizeof(*hooks));
+
+	add_hook(&match_assign_early, ASSIGNMENT_HOOK);
+	add_hook(&unop_expr_early, OP_HOOK);
+	add_hook(&asm_expr_early, ASM_HOOK);
+}
+
+void register_modification_hooks_late(int id)
+{
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+
+	select_return_states_hook(PARAM_ADD, &db_param_add);
+	select_return_states_hook(PARAM_SET, &db_param_add);
+
+	add_hook(&match_assign_late, ASSIGNMENT_HOOK_AFTER);
+	add_hook(&unop_expr_late, OP_HOOK);
+	add_hook(&asm_expr_late, ASM_HOOK);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_mtag.c b/usr/src/tools/smatch/src/smatch_mtag.c
new file mode 100644
index 0000000000..c499c8f923
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_mtag.c
@@ -0,0 +1,559 @@
+/*
+ * Copyright (C) 2017 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * One problem that I have is that it's really hard to track how pointers are
+ * passed around.  For example, it would be nice to know that the probe() and
+ * remove() functions get the same pci_dev pointer.  It would be good to know
+ * what pointers we're passing to the open() and close() functions.  But that
+ * information gets lost in a call tree full of function pointer calls.
+ *
+ * I think the first step is to start naming specific pointers.  So when a
+ * pointer is allocated, then it gets a tag.  So calls to kmalloc() generate a
+ * tag.  But we might not use that, because there might be a better name like
+ * framebuffer_alloc(). The framebuffer_alloc() is interesting because there is
+ * one per driver and it's passed around to all the file operations.
+ *
+ * Perhaps we could make a list of functions like framebuffer_alloc() which take
+ * a size and say that those are the interesting alloc functions.
+ *
+ * Another place where we would maybe name the pointer is when they are passed
+ * to the probe().  Because that's an important pointer, since there is one
+ * per driver (sort of).
+ *
+ * My vision is that you could take a pointer and trace it back to a global.  So
+ * I'm going to track that pointer_tag - 28 bytes takes you to another pointer
+ * tag.  You could follow that one back and so on.  Also when we pass a pointer
+ * to a function that would be recorded as sort of a link or path or something.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+#include <openssl/md5.h>
+
+static int my_id;
+
+static struct smatch_state *alloc_tag_state(mtag_t tag)
+{
+	struct smatch_state *state;
+	char buf[64];
+
+	state = __alloc_smatch_state(0);
+	snprintf(buf, sizeof(buf), "%lld", tag);
+	state->name = alloc_sname(buf);
+	state->data = malloc(sizeof(mtag_t));
+	*(mtag_t *)state->data = tag;
+
+	return state;
+}
+
+static mtag_t str_to_tag(const char *str)
+{
+	unsigned char c[MD5_DIGEST_LENGTH];
+	unsigned long long *tag = (unsigned long long *)&c;
+	MD5_CTX mdContext;
+	int len;
+
+	len = strlen(str);
+	MD5_Init(&mdContext);
+	MD5_Update(&mdContext, str, len);
+	MD5_Final(c, &mdContext);
+
+	*tag &= ~MTAG_ALIAS_BIT;
+	*tag &= ~MTAG_OFFSET_MASK;
+
+	return *tag;
+}
+
+static void alloc_assign(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *left, *right;
+	char *left_name, *right_name;
+	struct symbol *left_sym;
+	char buf[256];
+	mtag_t tag;
+
+
+	// FIXME:  This should only happen when the size is not a paramter of
+	// the caller
+	return;
+
+	if (expr->type != EXPR_ASSIGNMENT || expr->op != '=')
+		return;
+	left = strip_expr(expr->left);
+	right = strip_expr(expr->right);
+	if (right->type != EXPR_CALL || right->fn->type != EXPR_SYMBOL)
+		return;
+
+	left_name = expr_to_str_sym(left, &left_sym);
+	right_name = expr_to_str(right);
+
+	snprintf(buf, sizeof(buf), "%s %s %s %s", get_filename(), get_function(),
+		 left_name, right_name);
+	tag = str_to_tag(buf);
+
+	sql_insert_mtag_about(tag, left_name, right_name);
+
+	if (left_name && left_sym)
+		set_state(my_id, left_name, left_sym, alloc_tag_state(tag));
+
+	free_string(left_name);
+	free_string(right_name);
+}
+
+int get_string_mtag(struct expression *expr, mtag_t *tag)
+{
+	mtag_t xor;
+
+	if (expr->type != EXPR_STRING || !expr->string)
+		return 0;
+
+	/* I was worried about collisions so I added a xor */
+	xor = str_to_tag("__smatch string");
+	*tag = str_to_tag(expr->string->data);
+	*tag = *tag ^ xor;
+
+	return 1;
+}
+
+int get_toplevel_mtag(struct symbol *sym, mtag_t *tag)
+{
+	char buf[256];
+
+	if (!sym)
+		return 0;
+
+	if (!sym->ident ||
+	    !(sym->ctype.modifiers & MOD_TOPLEVEL))
+		return 0;
+
+	snprintf(buf, sizeof(buf), "%s %s",
+		 (sym->ctype.modifiers & MOD_STATIC) ? get_filename() : "extern",
+		 sym->ident->name);
+	*tag = str_to_tag(buf);
+	return 1;
+}
+
+int get_deref_mtag(struct expression *expr, mtag_t *tag)
+{
+	mtag_t container_tag, member_tag;
+	int offset;
+
+	/*
+	 * I'm not totally sure what I'm doing...
+	 *
+	 * This is supposed to get something like "global_var->ptr", but I don't
+	 * feel like it's complete at all.
+	 *
+	 */
+
+	if (!get_mtag(expr->unop, &container_tag))
+		return 0;
+
+	offset = get_member_offset_from_deref(expr);
+	if (offset < 0)
+		return 0;
+
+	if (!mtag_map_select_tag(container_tag, -offset, &member_tag))
+		return 0;
+
+	*tag = member_tag;
+	return 1;
+}
+
+static void global_variable(struct symbol *sym)
+{
+	mtag_t tag;
+
+	if (!get_toplevel_mtag(sym, &tag))
+		return;
+
+	sql_insert_mtag_about(tag,
+			      sym->ident->name,
+			      (sym->ctype.modifiers & MOD_STATIC) ? get_filename() : "extern");
+}
+
+static void db_returns_buf_size(struct expression *expr, int param, char *unused, char *math)
+{
+	struct expression *call;
+	struct range_list *rl;
+
+	if (expr->type != EXPR_ASSIGNMENT)
+		return;
+	call = strip_expr(expr->right);
+
+	if (!parse_call_math_rl(call, math, &rl))
+		return;
+//	rl = cast_rl(&int_ctype, rl);
+//	set_state_expr(my_size_id, expr->left, alloc_estate_rl(rl));
+}
+
+static void db_returns_memory_tag(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *call, *arg;
+	mtag_t tag, alias;
+	char *name;
+	struct symbol *sym;
+
+	call = strip_expr(expr);
+	while (call->type == EXPR_ASSIGNMENT)
+		call = strip_expr(call->right);
+	if (call->type != EXPR_CALL)
+		return;
+
+	tag = strtoul(value, NULL, 10);
+
+	if (!create_mtag_alias(tag, call, &alias))
+		return;
+
+	arg = get_argument_from_call_expr(call->args, param);
+	if (!arg)
+		return;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	set_state(my_id, name, sym, alloc_tag_state(alias));
+free:
+	free_string(name);
+}
+
+static void match_call_info(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct expression *arg;
+	int i = -1;
+
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+		state = get_state_expr(my_id, arg);
+		if (!state || !state->data)
+			continue;
+		sql_insert_caller_info(expr, MEMORY_TAG, i, "$", state->name);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void save_caller_info(const char *name, struct symbol *sym, char *key, char *value)
+{
+	struct smatch_state *state;
+	char fullname[256];
+	mtag_t tag;
+
+	if (strncmp(key, "$", 1) != 0)
+		return;
+
+	tag = atoll(value);
+	snprintf(fullname, 256, "%s%s", name, key + 1);
+	state = alloc_tag_state(tag);
+	set_state(my_id, fullname, sym, state);
+}
+
+static int get_array_mtag_offset(struct expression *expr, mtag_t *tag, int *offset)
+{
+	struct expression *array, *offset_expr;
+	struct symbol *type;
+	sval_t sval;
+
+	if (!is_array(expr))
+		return 0;
+
+	array = get_array_base(expr);
+	if (!array)
+		return 0;
+	type = get_type(array);
+	if (!type || type->type != SYM_ARRAY)
+		return 0;
+	type = get_real_base_type(type);
+	if (!type_bytes(type))
+		return 0;
+
+	if (!get_mtag(array, tag))
+		return 0;
+
+	offset_expr = get_array_offset(expr);
+	if (!get_value(offset_expr, &sval))
+		return 0;
+	*offset = sval.value * type_bytes(type);
+
+	return 1;
+}
+
+static int get_implied_mtag_offset(struct expression *expr, mtag_t *tag, int *offset)
+{
+	struct smatch_state *state;
+	struct symbol *type;
+	sval_t sval;
+
+	type = get_type(expr);
+	if (!type_is_ptr(type))
+		return 0;
+	state = get_extra_state(expr);
+	if (!state || !estate_get_single_value(state, &sval) || sval.value == 0)
+		return 0;
+
+	*tag = sval.uvalue & ~MTAG_OFFSET_MASK;
+	*offset = sval.uvalue & MTAG_OFFSET_MASK;
+	return 1;
+}
+
+static int get_mtag_cnt;
+int get_mtag(struct expression *expr, mtag_t *tag)
+{
+	struct smatch_state *state;
+	int ret = 0;
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return 0;
+
+	if (get_mtag_cnt > 0)
+		return 0;
+
+	get_mtag_cnt++;
+
+	switch (expr->type) {
+	case EXPR_STRING:
+		if (get_string_mtag(expr, tag)) {
+			ret = 1;
+			goto dec_cnt;
+		}
+		break;
+	case EXPR_SYMBOL:
+		if (get_toplevel_mtag(expr->symbol, tag)) {
+			ret = 1;
+			goto dec_cnt;
+		}
+		break;
+	case EXPR_DEREF:
+		if (get_deref_mtag(expr, tag)) {
+			ret = 1;
+			goto dec_cnt;
+		}
+		break;
+	}
+
+	state = get_state_expr(my_id, expr);
+	if (!state)
+		goto dec_cnt;
+	if (state->data) {
+		*tag = *(mtag_t *)state->data;
+		ret = 1;
+		goto dec_cnt;
+	}
+
+dec_cnt:
+	get_mtag_cnt--;
+	return ret;
+}
+
+int get_mtag_offset(struct expression *expr, mtag_t *tag, int *offset)
+{
+	int val;
+
+	if (!expr)
+		return 0;
+	if (expr->type == EXPR_PREOP && expr->op == '*')
+		return get_mtag_offset(expr->unop, tag, offset);
+	if (get_implied_mtag_offset(expr, tag, offset))
+		return 1;
+	if (!get_mtag(expr, tag))
+		return 0;
+	expr = strip_expr(expr);
+	if (expr->type == EXPR_SYMBOL) {
+		*offset = 0;
+		return 1;
+	}
+	val = get_member_offset_from_deref(expr);
+	if (val < 0)
+		return 0;
+	*offset = val;
+	return 1;
+}
+
+int create_mtag_alias(mtag_t tag, struct expression *expr, mtag_t *new)
+{
+	char buf[256];
+	int lines_from_start;
+	char *str;
+
+	/*
+	 * We need the alias to be unique.  It's not totally required that it
+	 * be the same from one DB build to then next, but it makes debugging
+	 * a bit simpler.
+	 *
+	 */
+
+	if (!cur_func_sym)
+		return 0;
+
+	lines_from_start = expr->pos.line - cur_func_sym->pos.line;
+	str = expr_to_str(expr);
+	snprintf(buf, sizeof(buf), "%lld %d %s", tag, lines_from_start, str);
+	free_string(str);
+
+	*new = str_to_tag(buf);
+	sql_insert_mtag_alias(tag, *new);
+
+	return 1;
+}
+
+int expr_to_mtag_offset(struct expression *expr, mtag_t *tag, int *offset)
+{
+	*offset = 0;
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return 0;
+
+	if (is_array(expr))
+		return get_array_mtag_offset(expr, tag, offset);
+
+	if (expr->type ==  EXPR_DEREF) {
+		*offset = get_member_offset_from_deref(expr);
+		if (*offset < 0)
+			return 0;
+		return get_mtag(expr->deref, tag);
+	}
+
+	if (get_implied_mtag_offset(expr, tag, offset))
+		return 1;
+
+	return get_mtag(expr, tag);
+}
+
+int get_mtag_sval(struct expression *expr, sval_t *sval)
+{
+	struct symbol *type;
+	mtag_t tag;
+	int offset = 0;
+
+	if (bits_in_pointer != 64)
+		return 0;
+
+	expr = strip_expr(expr);
+
+	type = get_type(expr);
+	if (!type_is_ptr(type))
+		return 0;
+	/*
+	 * There are only three options:
+	 *
+	 * 1) An array address:
+	 *    p = array;
+	 * 2) An address like so:
+	 *    p = &my_struct->member;
+	 * 3) A pointer:
+	 *    p = pointer;
+	 *
+	 */
+
+	if (expr->type == EXPR_STRING && get_string_mtag(expr, &tag))
+		goto found;
+
+	if (type->type == SYM_ARRAY && get_toplevel_mtag(expr->symbol, &tag))
+		goto found;
+
+	if (get_implied_mtag_offset(expr, &tag, &offset))
+		goto found;
+
+	if (expr->type != EXPR_PREOP || expr->op != '&')
+		return 0;
+	expr = strip_expr(expr->unop);
+
+	if (!expr_to_mtag_offset(expr, &tag, &offset))
+		return 0;
+	if (offset > MTAG_OFFSET_MASK)
+		offset = MTAG_OFFSET_MASK;
+
+found:
+	sval->type = type;
+	sval->uvalue = tag | offset;
+
+	return 1;
+}
+
+static struct expression *remove_dereference(struct expression *expr)
+{
+	expr = strip_expr(expr);
+
+	if (expr->type == EXPR_PREOP && expr->op == '*')
+		return strip_expr(expr->unop);
+	return preop_expression(expr, '&');
+}
+
+int get_mtag_addr_sval(struct expression *expr, sval_t *sval)
+{
+	return get_mtag_sval(remove_dereference(expr), sval);
+}
+
+static void print_stored_to_mtag(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *sm;
+	char buf[256];
+	const char *param_name;
+	int param;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (!sm->state->data)
+			continue;
+
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+		if (strcmp(param_name, "$") == 0)
+			continue;
+
+		snprintf(buf, sizeof(buf), "%lld", *(mtag_t *)sm->state->data);
+		sql_insert_return_states(return_id, return_ranges, MEMORY_TAG, param, param_name, buf);
+	} END_FOR_EACH_SM(sm);
+}
+
+void register_mtag(int id)
+{
+	my_id = id;
+
+
+	/*
+	 * The mtag stuff only works on 64 systems because we store the
+	 * information in the pointer itself.
+	 * bit 63   : set for alias mtags
+	 * bit 62-12: mtag hash
+	 * bit 11-0 : offset
+	 *
+	 */
+	if (bits_in_pointer != 64)
+		return;
+
+	add_hook(&global_variable, BASE_HOOK);
+
+	add_function_assign_hook("kmalloc", &alloc_assign, NULL);
+	add_function_assign_hook("kzalloc", &alloc_assign, NULL);
+
+	select_return_states_hook(BUF_SIZE, &db_returns_buf_size);
+
+	add_hook(&match_call_info, FUNCTION_CALL_HOOK);
+	select_caller_info_hook(save_caller_info, MEMORY_TAG);
+	add_split_return_callback(&print_stored_to_mtag);
+	select_return_states_hook(MEMORY_TAG, db_returns_memory_tag);
+}
diff --git a/usr/src/tools/smatch/src/smatch_mtag_data.c b/usr/src/tools/smatch/src/smatch_mtag_data.c
new file mode 100644
index 0000000000..0396730390
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_mtag_data.c
@@ -0,0 +1,257 @@
+/*
+ * Copyright (C) 2016 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * What we're doing here is saving all the possible values for static variables.
+ * Later on we might do globals as well.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+static struct stree *vals;
+
+static int save_rl(void *_rl, int argc, char **argv, char **azColName)
+{
+	unsigned long *rl = _rl;
+
+	*rl = strtoul(argv[0], NULL, 10);
+	return 0;
+}
+
+static struct range_list *select_orig_rl(sval_t sval)
+{
+	struct range_list *rl = NULL;
+	mtag_t tag = sval.uvalue & ~MTAG_OFFSET_MASK;
+	int offset = sval.uvalue & MTAG_OFFSET_MASK;
+
+	mem_sql(&save_rl, &rl, "select value from mtag_data where tag = %lld and offset = %d;",
+		tag, offset);
+	return rl;
+}
+
+static int is_kernel_param(const char *name)
+{
+	struct sm_state *tmp;
+	char buf[256];
+
+	/*
+	 * I'm ignoring these because otherwise Smatch thinks that kernel
+	 * parameters are always set to the default.
+	 *
+	 */
+
+	if (option_project != PROJ_KERNEL)
+		return 0;
+
+	snprintf(buf, sizeof(buf), "__param_%s.arg", name);
+
+	FOR_EACH_SM(vals, tmp) {
+		if (strcmp(tmp->name, buf) == 0)
+			return 1;
+	} END_FOR_EACH_SM(tmp);
+
+	return 0;
+}
+
+void insert_mtag_data(sval_t sval, struct range_list *rl)
+{
+	mtag_t tag = sval.uvalue & ~MTAG_OFFSET_MASK;
+	int offset = sval.uvalue & MTAG_OFFSET_MASK;
+
+	rl = clone_rl_permanent(rl);
+
+	mem_sql(NULL, NULL, "delete from mtag_data where tag = %lld and offset = %d and type = %d",
+		tag, offset, DATA_VALUE);
+	mem_sql(NULL, NULL, "insert into mtag_data values (%lld, %d, %d, '%lu');",
+		tag, offset, DATA_VALUE, (unsigned long)rl);
+}
+
+void update_mtag_data(struct expression *expr)
+{
+	struct range_list *orig, *new, *rl;
+	char *name;
+	sval_t sval;
+
+	name = expr_to_var(expr);
+	if (is_kernel_param(name)) {
+		free_string(name);
+		return;
+	}
+	free_string(name);
+
+	if (!get_mtag_addr_sval(expr, &sval))
+		return;
+
+	get_absolute_rl(expr, &rl);
+
+	orig = select_orig_rl(sval);
+	new = rl_union(orig, rl);
+	insert_mtag_data(sval, new);
+}
+
+static void match_global_assign(struct expression *expr)
+{
+	struct range_list *rl;
+	sval_t sval;
+	char *name;
+
+	name = expr_to_var(expr->left);
+	if (is_kernel_param(name)) {
+		free_string(name);
+		return;
+	}
+	free_string(name);
+
+	if (!get_mtag_addr_sval(expr->left, &sval))
+		return;
+
+	get_absolute_rl(expr->right, &rl);
+	insert_mtag_data(sval, rl);
+}
+
+static int save_mtag_data(void *_unused, int argc, char **argv, char **azColName)
+{
+	struct range_list *rl;
+
+	if (argc != 4) {
+		sm_msg("Error saving mtag data");
+		return 0;
+	}
+	if (!option_info)
+		return 0;
+
+	rl = (struct range_list *)strtoul(argv[3], NULL, 10);
+	sm_msg("SQL: insert into mtag_data values ('%s', '%s', '%s', '%s');",
+	       argv[0], argv[1], argv[2], show_rl(rl));
+
+	return 0;
+}
+
+static void match_end_file(struct symbol_list *sym_list)
+{
+	mem_sql(&save_mtag_data, NULL, "select * from mtag_data where type = %d;",
+		DATA_VALUE);
+}
+
+struct db_info {
+	struct symbol *type;
+	struct range_list *rl;
+};
+
+static int get_vals(void *_db_info, int argc, char **argv, char **azColName)
+{
+	struct db_info *db_info = _db_info;
+	struct range_list *tmp;
+
+	str_to_rl(db_info->type, argv[0], &tmp);
+	if (db_info->rl)
+		db_info->rl = rl_union(db_info->rl, tmp);
+	else
+		db_info->rl = tmp;
+
+	return 0;
+}
+
+struct db_cache_results {
+	sval_t sval;
+	struct range_list *rl;
+};
+static struct db_cache_results cached_results[8];
+
+static int get_rl_from_mtag_sval(sval_t sval, struct symbol *type, struct range_list **rl)
+{
+	struct db_info db_info = {};
+	mtag_t tag;
+	int offset;
+	static int idx;
+	int ret;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(cached_results); i++) {
+		if (sval.uvalue == cached_results[i].sval.uvalue) {
+			if (cached_results[i].rl) {
+				*rl = cached_results[i].rl;
+				return 1;
+			}
+			return 0;
+		}
+	}
+
+	tag = sval.uvalue & ~MTAG_OFFSET_MASK;
+	offset = sval.uvalue & MTAG_OFFSET_MASK;
+	if (offset == MTAG_OFFSET_MASK) {
+		ret = 0;
+		goto update_cache;
+	}
+	db_info.type = type;
+
+	run_sql(get_vals, &db_info,
+		"select value from mtag_data where tag = %lld and offset = %d and type = %d;",
+		tag, offset, DATA_VALUE);
+	if (!db_info.rl || is_whole_rl(db_info.rl)) {
+		db_info.rl = NULL;
+		ret = 0;
+		goto update_cache;
+	}
+
+	*rl = db_info.rl;
+	ret = 1;
+
+update_cache:
+	cached_results[idx].sval = sval;
+	cached_results[idx].rl = db_info.rl;
+	idx = (idx + 1) % ARRAY_SIZE(cached_results);
+
+	return ret;
+}
+
+static void clear_cache(struct symbol *sym)
+{
+	memset(cached_results, 0, sizeof(cached_results));
+}
+
+int get_mtag_rl(struct expression *expr, struct range_list **rl)
+{
+	struct symbol *type;
+	sval_t sval;
+
+	if (!get_mtag_addr_sval(expr, &sval))
+		return 0;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+
+	return get_rl_from_mtag_sval(sval, type, rl);
+}
+
+void register_mtag_data(int id)
+{
+	my_id = id;
+
+	add_hook(&clear_cache, FUNC_DEF_HOOK);
+
+//	if (!option_info)
+//		return;
+	add_hook(&match_global_assign, GLOBAL_ASSIGNMENT_HOOK);
+	add_hook(&match_end_file, END_FILE_HOOK);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_mtag_map.c b/usr/src/tools/smatch/src/smatch_mtag_map.c
new file mode 100644
index 0000000000..8384a9908f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_mtag_map.c
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2017 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This basically stores when a pointer is stored as a struct member.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *left, *right;
+	mtag_t left_tag, right_tag;
+	int offset;
+
+	if (expr->op != '=')
+		return;
+
+	left = strip_expr(expr->left);
+	right = strip_expr(expr->right);
+
+	if (left->type != EXPR_DEREF)
+		return;
+
+	offset = get_member_offset_from_deref(left);
+	if (offset < 0)
+		return;
+
+	if (!get_mtag(left->deref, &left_tag))
+		return;
+	if (!get_mtag(right, &right_tag))
+		return;
+
+	sql_insert_mtag_map(right_tag, -offset, left_tag);
+}
+
+void register_mtag_map(int id)
+{
+	my_id = id;
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_assign, GLOBAL_ASSIGNMENT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_nul_terminator.c b/usr/src/tools/smatch/src/smatch_nul_terminator.c
new file mode 100644
index 0000000000..845c75661f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_nul_terminator.c
@@ -0,0 +1,268 @@
+/*
+ * Copyright (C) 2018 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+static int param_set_id;
+
+STATE(terminated);
+STATE(unterminated);
+STATE(set);
+
+static void set_terminated_var_sym(const char *name, struct symbol *sym, struct smatch_state *state)
+{
+	if (get_param_num_from_sym(sym) >= 0)
+		set_state(param_set_id, name, sym, &set);
+	set_state(my_id, name, sym, state);
+}
+
+static void set_terminated(struct expression *expr, struct smatch_state *state)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		return;
+	set_terminated_var_sym(name, sym, state);
+	free_string(name);
+}
+
+static void match_nul_assign(struct expression *expr)
+{
+	struct expression *array;
+	struct symbol *type;
+	sval_t sval;
+
+	if (expr->op != '=')
+		return;
+
+	if (!get_value(expr->right, &sval) || sval.value != 0)
+		return;
+
+	array = get_array_base(expr->left);
+	if (!array)
+		return;
+
+	type = get_type(array);
+	if (!type)
+		return;
+	type = get_real_base_type(type);
+	if (type != &char_ctype)
+		return;
+	set_terminated(array, &terminated);
+}
+
+static struct smatch_state *get_terminated_state(struct expression *expr)
+{
+	struct sm_state *sm, *tmp;
+
+	if (!expr)
+		return NULL;
+	if (expr->type == EXPR_STRING)
+		return &terminated;
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return NULL;
+	if (sm->state == &terminated || sm->state == &unterminated)
+		return sm->state;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->state == &unterminated)
+			return &unterminated;
+	} END_FOR_EACH_PTR(tmp);
+
+	return NULL;
+}
+
+static void match_string_assign(struct expression *expr)
+{
+	struct smatch_state *state;
+
+	if (expr->op != '=')
+		return;
+	state = get_terminated_state(expr->right);
+	if (!state)
+		return;
+	set_terminated(expr->left, state);
+}
+
+static int sm_to_term(struct sm_state *sm)
+{
+	struct sm_state *tmp;
+
+	if (!sm)
+		return -1;
+	if (sm->state == &terminated)
+		return 1;
+
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (tmp->state == &unterminated)
+			return 0;
+	} END_FOR_EACH_PTR(tmp);
+
+	return -1;
+}
+
+static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
+{
+	int term;
+
+	term = sm_to_term(sm);
+	if (term < 0)
+		return;
+
+	sql_insert_caller_info(call, TERMINATED, param, printed_name, term ? "1" : "0");
+}
+
+static void match_call_info(struct expression *expr)
+{
+	struct smatch_state *state;
+	struct expression *arg;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+
+		state = get_terminated_state(arg);
+		if (!state)
+			continue;
+		sql_insert_caller_info(expr, TERMINATED, i, "$",
+				       (state == &terminated) ? "1" : "0");
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void caller_info_terminated(const char *name, struct symbol *sym, char *key, char *value)
+{
+	char fullname[256];
+
+	if (strcmp(key, "*$") == 0)
+		snprintf(fullname, sizeof(fullname), "*%s", name);
+	else if (strncmp(key, "$", 1) == 0)
+		snprintf(fullname, 256, "%s%s", name, key + 1);
+	else
+		return;
+
+	set_state(my_id, fullname, sym, (*value == '1') ? &terminated : &unterminated);
+}
+
+static void split_return_info(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct symbol *returned_sym;
+	struct sm_state *tmp, *sm;
+	const char *param_name;
+	int param;
+	int term;
+
+	FOR_EACH_MY_SM(param_set_id, __get_cur_stree(), tmp) {
+		sm = get_sm_state(my_id, tmp->name, tmp->sym);
+		if (!sm)
+			continue;
+		term = sm_to_term(sm);
+		if (term < 0)
+			continue;
+		param = get_param_num_from_sym(tmp->sym);
+		if (param < 0)
+			continue;
+
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+		if (strcmp(param_name, "$") == 0)
+			continue;
+
+		sql_insert_return_states(return_id, return_ranges, TERMINATED,
+					 param, param_name, term ? "1" : "0");
+	} END_FOR_EACH_SM(tmp);
+
+	returned_sym = expr_to_sym(expr);
+	if (!returned_sym)
+		return;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (sm->sym != returned_sym)
+			continue;
+		term = sm_to_term(sm);
+		if (term < 0)
+			continue;
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+		sql_insert_return_states(return_id, return_ranges, TERMINATED,
+					 -1, param_name, term ? "1" : "0");
+	} END_FOR_EACH_SM(sm);
+}
+
+static void return_info_terminated(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+	char *name;
+	struct symbol *sym;
+
+	if (param == -1) {
+		arg = expr->left;
+	} else {
+		struct expression *call = expr;
+
+		while (call->type == EXPR_ASSIGNMENT)
+			call = strip_expr(call->right);
+		if (call->type != EXPR_CALL)
+			return;
+
+		arg = get_argument_from_call_expr(call->args, param);
+		if (!arg)
+			return;
+	}
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	set_terminated_var_sym(name, sym, (*value == '1') ? &terminated : &unterminated);
+free:
+	free_string(name);
+}
+
+bool is_nul_terminated(struct expression *expr)
+{
+	if (get_terminated_state(expr) == &terminated)
+		return 1;
+	return 0;
+}
+
+void register_nul_terminator(int id)
+{
+	my_id = id;
+
+	add_hook(&match_nul_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_string_assign, ASSIGNMENT_HOOK);
+
+	add_hook(&match_call_info, FUNCTION_CALL_HOOK);
+	add_member_info_callback(my_id, struct_member_callback);
+	add_split_return_callback(&split_return_info);
+
+	select_caller_info_hook(caller_info_terminated, TERMINATED);
+	select_return_states_hook(TERMINATED, return_info_terminated);
+}
+
+void register_nul_terminator_param_set(int id)
+{
+	param_set_id = id;
+}
diff --git a/usr/src/tools/smatch/src/smatch_param_cleared.c b/usr/src/tools/smatch/src/smatch_param_cleared.c
new file mode 100644
index 0000000000..0abd02eebe
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_param_cleared.c
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This works together with smatch_clear_buffer.c.  This one is only for
+ * tracking the information and smatch_clear_buffer.c changes SMATCH_EXTRA.
+ *
+ * This tracks functions like memset() which clear out a chunk of memory.
+ * It fills in a gap that smatch_param_set.c can't handle.  It only handles
+ * void pointers because smatch_param_set.c should handle the rest.  Oh.  And
+ * also it handles arrays because Smatch sucks at handling arrays.
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+STATE(cleared);
+STATE(zeroed);
+
+static void db_param_cleared(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+	char *name;
+	struct symbol *sym;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	arg = strip_expr(arg);
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	if (strcmp(value, "0") == 0)
+		set_state(my_id, name, sym, &zeroed);
+	else
+		set_state(my_id, name, sym, &cleared);
+free:
+	free_string(name);
+}
+
+static void match_memset(const char *fn, struct expression *expr, void *arg)
+{
+	db_param_cleared(expr, PTR_INT(arg), (char *)"$", (char *)"0");
+}
+
+static void match_memcpy(const char *fn, struct expression *expr, void *arg)
+{
+	db_param_cleared(expr, PTR_INT(arg), (char *)"$", (char *)"");
+}
+
+static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct stree *stree;
+	struct sm_state *sm;
+	int param;
+	const char *param_name;
+
+	stree = __get_cur_stree();
+
+	FOR_EACH_MY_SM(my_id, stree, sm) {
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+
+		if (sm->state == &zeroed) {
+			sql_insert_return_states(return_id, return_ranges,
+						 PARAM_CLEARED, param, param_name, "0");
+		}
+
+		if (sm->state == &cleared) {
+			sql_insert_return_states(return_id, return_ranges,
+						 PARAM_CLEARED, param, param_name, "");
+		}
+	} END_FOR_EACH_SM(sm);
+}
+
+static void register_clears_param(void)
+{
+	struct token *token;
+	char name[256];
+	const char *function;
+	int param;
+
+	if (option_project == PROJ_NONE)
+		return;
+
+	snprintf(name, 256, "%s.clears_argument", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		function = show_ident(token->ident);
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		param = atoi(token->number);
+		add_function_hook(function, &match_memcpy, INT_PTR(param));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+#define USB_DIR_IN 0x80
+static void match_usb_control_msg(const char *fn, struct expression *expr, void *_size_arg)
+{
+	struct expression *inout;
+	sval_t sval;
+
+	inout = get_argument_from_call_expr(expr->args, 3);
+
+	if (get_value(inout, &sval) && !(sval.uvalue & USB_DIR_IN))
+		return;
+
+	db_param_cleared(expr, 6, (char *)"$", (char *)"");
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct symbol *type;
+
+	/*
+	 * If we have struct foo x, y; and we say that x = y; then it
+	 * initializes the struct holes.  So we record that here.
+	 */
+	type = get_type(expr->left);
+	if (!type || type->type != SYM_STRUCT)
+		return;
+	set_state_expr(my_id, expr->left, &cleared);
+}
+
+static void match_array_assign(struct expression *expr)
+{
+	struct expression *array_expr;
+
+	if (!is_array(expr->left))
+		return;
+
+	array_expr = get_array_base(expr->left);
+	set_state_expr(my_id, array_expr, &cleared);
+}
+
+void register_param_cleared(int id)
+{
+	my_id = id;
+
+	add_function_hook("memset", &match_memset, INT_PTR(0));
+	add_function_hook("memzero", &match_memset, INT_PTR(0));
+	add_function_hook("__memset", &match_memset, INT_PTR(0));
+	add_function_hook("__memzero", &match_memset, INT_PTR(0));
+
+	add_function_hook("memcpy", &match_memcpy, INT_PTR(0));
+	add_function_hook("memmove", &match_memcpy, INT_PTR(0));
+	add_function_hook("__memcpy", &match_memcpy, INT_PTR(0));
+	add_function_hook("__memmove", &match_memcpy, INT_PTR(0));
+	add_function_hook("strcpy", &match_memcpy, INT_PTR(0));
+	add_function_hook("strncpy", &match_memcpy, INT_PTR(0));
+	add_function_hook("sprintf", &match_memcpy, INT_PTR(0));
+	add_function_hook("snprintf", &match_memcpy, INT_PTR(0));
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_array_assign, ASSIGNMENT_HOOK);
+
+	register_clears_param();
+
+	select_return_states_hook(PARAM_CLEARED, &db_param_cleared);
+	add_split_return_callback(&print_return_value_param);
+
+	if (option_project == PROJ_KERNEL) {
+		add_function_hook("usb_control_msg", &match_usb_control_msg, NULL);
+	}
+
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_param_compare_limit.c b/usr/src/tools/smatch/src/smatch_param_compare_limit.c
new file mode 100644
index 0000000000..1539e06249
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_param_compare_limit.c
@@ -0,0 +1,373 @@
+/*
+ * Copyright (C) 2016 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The point here is to store the relationships between two variables.
+ * Ie:  y > x.
+ * To do that we create a state with the two variables in alphabetical order:
+ * ->name = "x vs y" and the state would be "<".  On the false path the state
+ * would be ">=".
+ *
+ * Part of the trick of it is that if x or y is modified then we need to reset
+ * the state.  We need to keep a list of all the states which depend on x and
+ * all the states which depend on y.  The link_id code handles this.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int compare_id;
+static int link_id;
+
+static struct smatch_state *alloc_link_state(struct string_list *links)
+{
+	struct smatch_state *state;
+	static char buf[256];
+	char *tmp;
+	int i;
+
+	state = __alloc_smatch_state(0);
+
+	i = 0;
+	FOR_EACH_PTR(links, tmp) {
+		if (!i++) {
+			snprintf(buf, sizeof(buf), "%s", tmp);
+		} else {
+			append(buf, ", ", sizeof(buf));
+			append(buf, tmp, sizeof(buf));
+		}
+	} END_FOR_EACH_PTR(tmp);
+
+	state->name = alloc_sname(buf);
+	state->data = links;
+	return state;
+}
+
+static struct smatch_state *merge_links(struct smatch_state *s1, struct smatch_state *s2)
+{
+	struct smatch_state *ret;
+	struct string_list *links;
+
+	links = combine_string_lists(s1->data, s2->data);
+	ret = alloc_link_state(links);
+	return ret;
+}
+
+static void save_link_var_sym(const char *var, struct symbol *sym, const char *link)
+{
+	struct smatch_state *old_state, *new_state;
+	struct string_list *links;
+	char *new;
+
+	old_state = get_state(link_id, var, sym);
+	if (old_state)
+		links = clone_str_list(old_state->data);
+	else
+		links = NULL;
+
+	new = alloc_sname(link);
+	insert_string(&links, new);
+
+	new_state = alloc_link_state(links);
+	set_state(link_id, var, sym, new_state);
+}
+
+static void add_comparison_var_sym(const char *left_name,
+		struct var_sym_list *left_vsl,
+		int comparison,
+		const char *right_name, struct var_sym_list *right_vsl)
+{
+	struct smatch_state *state;
+	struct var_sym *vs;
+	char state_name[256];
+
+	if (strcmp(left_name, right_name) > 0) {
+		const char *tmp_name = left_name;
+		struct var_sym_list *tmp_vsl = left_vsl;
+
+		left_name = right_name;
+		left_vsl = right_vsl;
+		right_name = tmp_name;
+		right_vsl = tmp_vsl;
+		comparison = flip_comparison(comparison);
+	}
+	snprintf(state_name, sizeof(state_name), "%s vs %s", left_name, right_name);
+	state = alloc_compare_state(NULL, left_name, left_vsl, comparison, NULL, right_name, right_vsl);
+
+	set_state(compare_id, state_name, NULL, state);
+
+	FOR_EACH_PTR(left_vsl, vs) {
+		save_link_var_sym(vs->var, vs->sym, state_name);
+	} END_FOR_EACH_PTR(vs);
+	FOR_EACH_PTR(right_vsl, vs) {
+		save_link_var_sym(vs->var, vs->sym, state_name);
+	} END_FOR_EACH_PTR(vs);
+}
+
+/*
+ * This is quite a bit more limitted, less ambitious, simpler compared to
+ * smatch_camparison.c.
+ */
+void __compare_param_limit_hook(struct expression *left_expr, struct expression *right_expr,
+				const char *state_name,
+				struct smatch_state *true_state, struct smatch_state *false_state)
+{
+	char *left_name = NULL;
+	char *right_name = NULL;
+	char *tmp_name = NULL;
+	struct symbol *left_sym, *right_sym, *tmp_sym;
+
+	left_name = expr_to_var_sym(left_expr, &left_sym);
+	if (!left_name || !left_sym)
+		goto free;
+	right_name = expr_to_var_sym(right_expr, &right_sym);
+	if (!right_name || !right_sym)
+		goto free;
+
+	if (get_param_num_from_sym(left_sym) < 0 ||
+	    get_param_num_from_sym(right_sym) < 0)
+		return;
+
+	tmp_name = get_other_name_sym(left_name, left_sym, &tmp_sym);
+	if (tmp_name) {
+		free_string(left_name);
+		left_name = tmp_name;
+		left_sym = tmp_sym;
+	}
+
+	tmp_name = get_other_name_sym(right_name, right_sym, &tmp_sym);
+	if (tmp_name) {
+		free_string(right_name);
+		right_name = tmp_name;
+		right_sym = tmp_sym;
+	}
+
+	if (param_was_set_var_sym(left_name, left_sym))
+		return;
+	if (param_was_set_var_sym(right_name, right_sym))
+		return;
+
+	set_true_false_states(compare_id, state_name, NULL, true_state, false_state);
+	save_link_var_sym(left_name, left_sym, state_name);
+	save_link_var_sym(right_name, right_sym, state_name);
+free:
+	free_string(left_name);
+	free_string(right_name);
+}
+
+static void print_return_comparison(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *tmp;
+	struct string_list *links;
+	char *link;
+	struct sm_state *sm;
+	struct compare_data *data;
+	struct var_sym *left, *right;
+	int left_param, right_param;
+	static char left_buf[256];
+	static char right_buf[256];
+	static char info_buf[256];
+	const char *tmp_name;
+
+	FOR_EACH_MY_SM(link_id, __get_cur_stree(), tmp) {
+		links = tmp->state->data;
+		FOR_EACH_PTR(links, link) {
+			sm = get_sm_state(compare_id, link, NULL);
+			if (!sm)
+				continue;
+			data = sm->state->data;
+			if (!data || !data->comparison)
+				continue;
+			if (ptr_list_size((struct ptr_list *)data->left_vsl) != 1 ||
+			    ptr_list_size((struct ptr_list *)data->right_vsl) != 1)
+				continue;
+			left = first_ptr_list((struct ptr_list *)data->left_vsl);
+			right = first_ptr_list((struct ptr_list *)data->right_vsl);
+			if (left->sym == right->sym &&
+			    strcmp(left->var, right->var) == 0)
+				continue;
+			/*
+			 * Both parameters link to this comparison so only
+			 * record the first one.
+			 */
+			if (left->sym != tmp->sym ||
+			    strcmp(left->var, tmp->name) != 0)
+				continue;
+
+			left_param = get_param_num_from_sym(left->sym);
+			right_param = get_param_num_from_sym(right->sym);
+			if (left_param < 0 || right_param < 0) /* can't happen hopefully */
+				continue;
+
+			tmp_name = get_param_name_var_sym(left->var, left->sym);
+			if (!tmp_name)
+				continue;
+			snprintf(left_buf, sizeof(left_buf), "%s", tmp_name);
+
+			tmp_name = get_param_name_var_sym(right->var, right->sym);
+			if (!tmp_name || tmp_name[0] != '$')
+				continue;
+			snprintf(right_buf, sizeof(right_buf), "$%d%s", right_param, tmp_name + 1);
+
+			snprintf(info_buf, sizeof(info_buf), "%s %s", show_special(data->comparison), right_buf);
+			sql_insert_return_states(return_id, return_ranges,
+					COMPARE_LIMIT, left_param, left_buf, info_buf);
+		} END_FOR_EACH_PTR(link);
+
+	} END_FOR_EACH_SM(tmp);
+}
+
+static int parse_comparison(char **value, int *op)
+{
+
+	*op = **value;
+
+	switch (*op) {
+	case '<':
+		(*value)++;
+		if (**value == '=') {
+			(*value)++;
+			*op = SPECIAL_LTE;
+		}
+		break;
+	case '=':
+		(*value)++;
+		(*value)++;
+		*op = SPECIAL_EQUAL;
+		break;
+	case '!':
+		(*value)++;
+		(*value)++;
+		*op = SPECIAL_NOTEQUAL;
+		break;
+	case '>':
+		(*value)++;
+		if (**value == '=') {
+			(*value)++;
+			*op = SPECIAL_GTE;
+		}
+		break;
+	default:
+		return 0;
+	}
+
+	if (**value != ' ') {
+		sm_perror("parsing comparison.  %s", *value);
+		return 0;
+	}
+
+	(*value)++;
+	return 1;
+}
+
+static int split_op_param_key(char *value, int *op, int *param, char **key)
+{
+	static char buf[256];
+	char *p;
+
+	if (!parse_comparison(&value, op))
+		return 0;
+
+	snprintf(buf, sizeof(buf), value);
+
+	p = buf;
+	if (*p++ != '$')
+		return 0;
+
+	*param = atoi(p);
+	if (*param < 0 || *param > 99)
+		return 0;
+	p++;
+	if (*param > 9)
+		p++;
+	p--;
+	*p = '$';
+	*key = p;
+
+	return 1;
+}
+
+static void db_return_comparison(struct expression *expr, int left_param, char *key, char *value)
+{
+	struct expression *left_arg, *right_arg;
+	char *left_name = NULL;
+	struct symbol *left_sym;
+	char *right_name = NULL;
+	struct symbol *right_sym;
+	int op;
+	int right_param;
+	char *right_key;
+	struct var_sym_list *left_vsl = NULL, *right_vsl = NULL;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	if (!split_op_param_key(value, &op, &right_param, &right_key))
+		return;
+
+	left_arg = get_argument_from_call_expr(expr->args, left_param);
+	if (!left_arg)
+		return;
+
+	right_arg = get_argument_from_call_expr(expr->args, right_param);
+	if (!right_arg)
+		return;
+
+	left_name = get_variable_from_key(left_arg, key, &left_sym);
+	if (!left_name || !left_sym)
+		goto free;
+	if (get_param_num_from_sym(left_sym) < 0)
+		goto free;
+
+	right_name = get_variable_from_key(right_arg, right_key, &right_sym);
+	if (!right_name || !right_sym)
+		goto free;
+	if (get_param_num_from_sym(right_sym) < 0)
+		goto free;
+
+	add_var_sym(&left_vsl, left_name, left_sym);
+	add_var_sym(&right_vsl, right_name, right_sym);
+
+	add_comparison_var_sym(left_name, left_vsl, op, right_name, right_vsl);
+
+free:
+	free_string(left_name);
+	free_string(right_name);
+}
+
+void register_param_compare_limit(int id)
+{
+	compare_id = id;
+
+	add_merge_hook(compare_id, &merge_compare_states);
+	add_split_return_callback(&print_return_comparison);
+
+	select_return_states_hook(COMPARE_LIMIT, &db_return_comparison);
+}
+
+void register_param_compare_limit_links(int id)
+{
+	link_id = id;
+
+	add_merge_hook(link_id, &merge_links);
+
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_param_filter.c b/usr/src/tools/smatch/src/smatch_param_filter.c
new file mode 100644
index 0000000000..01a9920f57
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_param_filter.c
@@ -0,0 +1,214 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is for functions like:
+ *
+ * void foo(int *x)
+ * {
+ * 	if (*x == 42)
+ *		*x = 0;
+ * }
+ *
+ * The final value of *x depends on the input to the function but with *x == 42
+ * filtered out.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static struct stree *start_states;
+static struct stree_stack *saved_stack;
+static void save_start_states(struct statement *stmt)
+{
+	start_states = get_all_states_stree(SMATCH_EXTRA);
+}
+
+static void free_start_states(void)
+{
+	free_stree(&start_states);
+}
+
+static void match_save_states(struct expression *expr)
+{
+	push_stree(&saved_stack, start_states);
+	start_states = NULL;
+}
+
+static void match_restore_states(struct expression *expr)
+{
+	free_stree(&start_states);
+	start_states = pop_stree(&saved_stack);
+}
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	struct smatch_state *state;
+
+	if (parent_is_gone_var_sym(sm->name, sm->sym))
+		return alloc_estate_empty();
+
+	state = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+	if (state)
+		return state;
+	return alloc_estate_whole(estate_type(sm->state));
+}
+
+static void pre_merge_hook(struct sm_state *sm)
+{
+	struct smatch_state *extra, *mine;
+	struct range_list *rl;
+
+	if (estate_rl(sm->state))
+		return;
+
+	extra = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+	if (!extra)
+		return;
+	mine = get_state(my_id, sm->name, sm->sym);
+
+	rl = rl_intersection(estate_rl(extra), estate_rl(mine));
+	if (rl_equiv(rl, estate_rl(mine)))
+		return;
+	set_state(my_id, sm->name, sm->sym, alloc_estate_rl(clone_rl(rl)));
+}
+
+static void extra_mod_hook(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	int param;
+
+	if (__in_fake_assign)
+		return;
+
+	param = get_param_num_from_sym(sym);
+	if (param < 0)
+		return;
+
+	/* on stack parameters are handled in smatch_param_limit.c */
+	if (sym->ident && strcmp(sym->ident->name, name) == 0)
+		return;
+
+	set_state(my_id, name, sym, alloc_estate_empty());
+}
+
+/*
+ * This relies on the fact that these states are stored so that
+ * foo->bar is before foo->bar->baz.
+ */
+static int parent_set(struct string_list *list, const char *name)
+{
+	char *tmp;
+	int len;
+	int ret;
+
+	FOR_EACH_PTR(list, tmp) {
+		len = strlen(tmp);
+		ret = strncmp(tmp, name, len);
+		if (ret < 0)
+			continue;
+		if (ret > 0)
+			return 0;
+		if (name[len] == '-')
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static void print_one_mod_param(int return_id, char *return_ranges,
+			int param, struct sm_state *sm, struct string_list **totally_filtered)
+{
+	const char *param_name;
+
+	param_name = get_param_name(sm);
+	if (!param_name)
+		return;
+	if (is_whole_rl(estate_rl(sm->state)))
+		return;
+	if (!estate_rl(sm->state)) {
+		insert_string(totally_filtered, (char *)sm->name);
+		return;
+	}
+
+	sql_insert_return_states(return_id, return_ranges, PARAM_FILTER, param,
+			param_name, show_rl(estate_rl(sm->state)));
+}
+
+static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *tmp;
+	struct sm_state *sm;
+	struct string_list *totally_filtered = NULL;
+	int param;
+
+	FOR_EACH_MY_SM(SMATCH_EXTRA, __get_cur_stree(), tmp) {
+		param = get_param_num_from_sym(tmp->sym);
+		if (param < 0)
+			continue;
+
+		/* on stack parameters are handled in smatch_param_limit.c */
+		if (tmp->sym->ident && strcmp(tmp->sym->ident->name, tmp->name) == 0)
+			continue;
+
+		if (parent_set(totally_filtered, tmp->name))
+			continue;
+
+		sm = get_sm_state(my_id, tmp->name, tmp->sym);
+		if (sm)
+			print_one_mod_param(return_id, return_ranges, param, sm, &totally_filtered);
+	} END_FOR_EACH_SM(tmp);
+
+	free_ptr_list((struct ptr_list **)&totally_filtered);
+}
+
+int param_has_filter_data(struct sm_state *sm)
+{
+	struct smatch_state *state;
+
+	state = get_state(my_id, sm->name, sm->sym);
+	if (!state) {
+		if (get_assigned_expr_name_sym(sm->name, sm->sym))
+			return 0;
+		return 1;
+	}
+	if (estate_rl(state))
+		return 1;
+	return 0;
+}
+
+void register_param_filter(int id)
+{
+	my_id = id;
+
+	add_hook(&save_start_states, AFTER_DEF_HOOK);
+	add_hook(&free_start_states, AFTER_FUNC_HOOK);
+
+	add_extra_mod_hook(&extra_mod_hook);
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	add_pre_merge_hook(my_id, &pre_merge_hook);
+	add_merge_hook(my_id, &merge_estates);
+
+	add_hook(&match_save_states, INLINE_FN_START);
+	add_hook(&match_restore_states, INLINE_FN_END);
+
+	add_split_return_callback(&print_return_value_param);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_param_limit.c b/usr/src/tools/smatch/src/smatch_param_limit.c
new file mode 100644
index 0000000000..6ed3259b40
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_param_limit.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is almost the same as smatch_param_filter.c.  The difference is that
+ * this only deals with values passed on the stack and param filter only deals
+ * with values changed so that the caller sees the new value.  It other words
+ * the key for these should always be "$" and the key for param_filter should
+ * never be "$".  Also smatch_param_set() should never use "$" as the key.
+ * Param set should work together with param_filter to determine the value that
+ * the caller sees at the end.
+ *
+ * This is for functions like this:
+ *
+ * int foo(int a)
+ * {
+ *        if (a >= 0 && a < 10) {
+ *                 a = 42;
+ *                 return 1;
+ *        }
+ *        return 0;
+ * }
+ *
+ * If we pass in 5, it returns 1.
+ *
+ * It's a bit complicated because we can't just consider the final value, we
+ * have to always consider the passed in value.
+ *
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static struct stree *start_states;
+static struct stree_stack *saved_stack;
+
+static void save_start_states(struct statement *stmt)
+{
+	start_states = get_all_states_stree(SMATCH_EXTRA);
+}
+
+static void free_start_states(void)
+{
+	free_stree(&start_states);
+}
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	struct smatch_state *state;
+
+	state = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+	if (state)
+		return state;
+	return alloc_estate_whole(estate_type(sm->state));
+}
+
+struct smatch_state *get_orig_estate(const char *name, struct symbol *sym)
+{
+	struct smatch_state *state;
+
+	state = get_state(my_id, name, sym);
+	if (state)
+		return state;
+
+	state = get_state(SMATCH_EXTRA, name, sym);
+	if (state)
+		return state;
+	return alloc_estate_rl(alloc_whole_rl(get_real_base_type(sym)));
+}
+
+struct smatch_state *get_orig_estate_type(const char *name, struct symbol *sym, struct symbol *type)
+{
+	struct smatch_state *state;
+
+	state = get_state(my_id, name, sym);
+	if (state)
+		return state;
+
+	state = get_state(SMATCH_EXTRA, name, sym);
+	if (state)
+		return state;
+	return alloc_estate_rl(alloc_whole_rl(type));
+}
+
+static struct range_list *generify_mtag_range(struct smatch_state *state)
+{
+	struct range_list *rl;
+	struct data_range *drange;
+
+	if (!estate_type(state) || estate_type(state)->type != SYM_PTR)
+		return estate_rl(state);
+
+	/*
+	 * The problem is that we get too specific on our param limits when we
+	 * know exactly what pointers are passed to a function.  It gets to the
+	 * point where we say "pointer x will succeed, but everything else will
+	 * fail."  And then we introduce a new caller which passes a different
+	 * pointer and it's like, "Sorry bro, that's not possible."
+	 *
+	 */
+	rl = rl_intersection(estate_rl(state), valid_ptr_rl);
+	if (!rl)
+		return estate_rl(state);
+
+	FOR_EACH_PTR(rl, drange) {
+		if (drange->min.value != drange->max.value)
+			continue;
+		if (drange->min.value > -4096 && drange->min.value <= 0)
+			continue;
+		return rl_union(valid_ptr_rl, rl);
+	} END_FOR_EACH_PTR(drange);
+
+	return estate_rl(state);
+}
+
+static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct smatch_state *state, *old;
+	struct sm_state *tmp;
+	struct range_list *rl;
+	const char *param_name;
+	int param;
+
+	FOR_EACH_MY_SM(SMATCH_EXTRA, __get_cur_stree(), tmp) {
+		param = get_param_num_from_sym(tmp->sym);
+		if (param < 0)
+			continue;
+
+		param_name = get_param_name(tmp);
+		if (!param_name)
+			continue;
+
+		state = __get_state(my_id, tmp->name, tmp->sym);
+		if (!state)
+			state = tmp->state;
+
+		if (estate_is_whole(state) || estate_is_empty(state))
+			continue;
+		old = get_state_stree(start_states, SMATCH_EXTRA, tmp->name, tmp->sym);
+		if (old && rl_equiv(estate_rl(old), estate_rl(state)))
+			continue;
+
+		rl = generify_mtag_range(state);
+		sql_insert_return_states(return_id, return_ranges, PARAM_LIMIT,
+					 param, param_name, show_rl(rl));
+	} END_FOR_EACH_SM(tmp);
+}
+
+static void extra_mod_hook(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	struct smatch_state *orig_vals;
+	int param;
+
+	param = get_param_num_from_sym(sym);
+	if (param < 0)
+		return;
+
+	orig_vals = get_orig_estate_type(name, sym, estate_type(state));
+	set_state(my_id, name, sym, orig_vals);
+}
+
+static void match_save_states(struct expression *expr)
+{
+	push_stree(&saved_stack, start_states);
+	start_states = NULL;
+}
+
+static void match_restore_states(struct expression *expr)
+{
+	free_stree(&start_states);
+	start_states = pop_stree(&saved_stack);
+}
+
+void register_param_limit(int id)
+{
+	my_id = id;
+
+	add_hook(&save_start_states, AFTER_DEF_HOOK);
+	add_hook(&free_start_states, AFTER_FUNC_HOOK);
+
+	add_extra_mod_hook(&extra_mod_hook);
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	add_merge_hook(my_id, &merge_estates);
+
+	add_hook(&match_save_states, INLINE_FN_START);
+	add_hook(&match_restore_states, INLINE_FN_END);
+
+	add_split_return_callback(&print_return_value_param);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_param_set.c b/usr/src/tools/smatch/src/smatch_param_set.c
new file mode 100644
index 0000000000..21456057ce
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_param_set.c
@@ -0,0 +1,269 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is for functions like:
+ *
+ * int foo(int *x)
+ * {
+ * 	if (*x == 42) {
+ *		*x = 0;
+ *		return 1;
+ *	}
+ * 	return 0;
+ * }
+ *
+ * If we return 1 that means the value of *x has been set to 0.  If we return
+ * 0 then we have left *x alone.
+ *
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static struct smatch_state *unmatched_state(struct sm_state *sm)
+{
+	return alloc_estate_empty();
+}
+
+static int parent_is_set(const char *name, struct symbol *sym, struct smatch_state *state)
+{
+	struct expression *faked;
+	char *left_name;
+	int ret = 0;
+	int len;
+
+	if (!__in_fake_assign)
+		return 0;
+	if (!is_whole_rl(estate_rl(state)))
+		return 0;
+	if (get_state(my_id, name, sym))
+		return 0;
+
+	faked = get_faked_expression();
+	if (!faked)
+		return 0;
+	if ((faked->type == EXPR_PREOP || faked->type == EXPR_POSTOP) &&
+	    (faked->op == SPECIAL_INCREMENT || faked->op == SPECIAL_DECREMENT)) {
+		faked = strip_expr(faked->unop);
+		if (faked->type == EXPR_SYMBOL)
+			return 1;
+		return 0;
+	}
+	if (faked->type != EXPR_ASSIGNMENT)
+		return 0;
+
+	left_name = expr_to_var(faked->left);
+	if (!left_name)
+		return 0;
+
+	len = strlen(left_name);
+	if (strncmp(name, left_name, len) == 0 && name[len] == '-')
+		ret = 1;
+	free_string(left_name);
+
+	return ret;
+}
+
+static void extra_mod_hook(const char *name, struct symbol *sym, struct expression *expr, struct smatch_state *state)
+{
+	if (parent_is_set(name, sym, state))
+		return;
+	if (get_param_num_from_sym(sym) < 0)
+		return;
+	set_state(my_id, name, sym, state);
+}
+
+/*
+ * This function is is a dirty hack because extra_mod_hook is giving us a NULL
+ *  sym instead of a vsl.
+ */
+static void match_array_assignment(struct expression *expr)
+{
+	struct expression *array, *offset;
+	char *name;
+	struct symbol *sym;
+	struct range_list *rl;
+	sval_t sval;
+	char buf[256];
+
+	if (__in_fake_assign)
+		return;
+
+	if (!is_array(expr->left))
+		return;
+	array = get_array_base(expr->left);
+	offset = get_array_offset(expr->left);
+
+	/* These are handled by extra_mod_hook() */
+	if (get_value(offset, &sval))
+		return;
+	name = expr_to_var_sym(array, &sym);
+	if (!name || !sym)
+		goto free;
+	if (get_param_num_from_sym(sym) < 0)
+		goto free;
+	get_absolute_rl(expr->right, &rl);
+	rl = cast_rl(get_type(expr->left), rl);
+
+	snprintf(buf, sizeof(buf), "*%s", name);
+	set_state(my_id, buf, sym, alloc_estate_rl(rl));
+free:
+	free_string(name);
+}
+
+/*
+ * This relies on the fact that these states are stored so that
+ * foo->bar is before foo->bar->baz.
+ */
+static int parent_set(struct string_list *list, const char *name)
+{
+	char *tmp;
+	int len;
+	int ret;
+
+	FOR_EACH_PTR(list, tmp) {
+		len = strlen(tmp);
+		ret = strncmp(tmp, name, len);
+		if (ret < 0)
+			continue;
+		if (ret > 0)
+			return 0;
+		if (name[len] == '-')
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 0;
+}
+
+static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *sm;
+	struct smatch_state *extra;
+	int param;
+	struct range_list *rl;
+	const char *param_name;
+	struct string_list *set_list = NULL;
+	char *math_str;
+	char buf[256];
+	sval_t sval;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (!estate_rl(sm->state))
+			continue;
+		extra = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+		if (extra) {
+			rl = rl_intersection(estate_rl(sm->state), estate_rl(extra));
+			if (!rl)
+				continue;
+		} else {
+			rl = estate_rl(sm->state);
+		}
+
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+		if (strcmp(param_name, "$") == 0) {
+			insert_string(&set_list, (char *)sm->name);
+			continue;
+		}
+
+		if (rl_to_sval(rl, &sval)) {
+			insert_string(&set_list, (char *)sm->name);
+			sql_insert_return_states(return_id, return_ranges,
+					param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,
+					param, param_name, show_rl(rl));
+			continue;
+		}
+
+		math_str = get_value_in_terms_of_parameter_math_var_sym(sm->name, sm->sym);
+		if (math_str) {
+			snprintf(buf, sizeof(buf), "%s[%s]", show_rl(rl), math_str);
+			insert_string(&set_list, (char *)sm->name);
+			sql_insert_return_states(return_id, return_ranges,
+					param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,
+					param, param_name, buf);
+			continue;
+		}
+
+		/* no useful information here. */
+		if (is_whole_rl(rl) && parent_set(set_list, sm->name))
+			continue;
+		insert_string(&set_list, (char *)sm->name);
+
+		sql_insert_return_states(return_id, return_ranges,
+					 param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,
+					 param, param_name, show_rl(rl));
+
+	} END_FOR_EACH_SM(sm);
+
+	free_ptr_list((struct ptr_list **)&set_list);
+}
+
+int param_was_set_var_sym(const char *name, struct symbol *sym)
+{
+	struct sm_state *sm;
+	int len;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (sm->sym != sym)
+			continue;
+		len = strlen(sm->name);
+		if (strncmp(sm->name, name, len) != 0)
+			continue;
+		if (name[len] == '\0' ||
+		    name[len] == '-')
+			return 1;
+	} END_FOR_EACH_SM(sm);
+
+	return 0;
+}
+
+int param_was_set(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	int ret = 0;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+
+	ret = param_was_set_var_sym(name, sym);
+free:
+	free_string(name);
+	return ret;
+}
+
+void register_param_set(int id)
+{
+	my_id = id;
+
+	add_extra_mod_hook(&extra_mod_hook);
+	add_hook(match_array_assignment, ASSIGNMENT_HOOK);
+	add_unmatched_state_hook(my_id, &unmatched_state);
+	add_merge_hook(my_id, &merge_estates);
+	add_split_return_callback(&print_return_value_param);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_param_to_mtag_data.c b/usr/src/tools/smatch/src/smatch_param_to_mtag_data.c
new file mode 100644
index 0000000000..ec647317e7
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_param_to_mtag_data.c
@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Take a look at request_threaded_irq().  It takes thread_fn and dev_id.  Then
+ * it does:
+ *
+ *	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
+ *	action->thread_fn = thread_fn;
+ *	action->dev_id = dev_id;
+ *
+ * It doesn't ever pass action back to the higher levels, but instead registers
+ * it with the lower levels.
+ *
+ * The kzalloc() allocation creates a new mtag.  We don't know at this point
+ * what "thread_fn" and "dev_id" are because they come from many different
+ * sources.
+ *
+ * So what we do is we pass the information back to the callers that thread_fn
+ * and dev_id are stored as a specific mtag data.  Then when the callers *do*
+ * know what values are passed they create an mtag_alias.  An mtag_alias is a
+ * many to one relationship.  Then they store that in mtag_data using the
+ * mtag_alias.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+struct tag_assign_info {
+	mtag_t tag;
+	int offset;
+};
+ALLOCATOR(tag_assign_info, "tag name offset");
+
+static struct smatch_state *alloc_tag_data_state(mtag_t tag, char *name, int offset)
+{
+	struct smatch_state *state;
+	struct tag_assign_info *data;
+
+	data = __alloc_tag_assign_info(0);
+	data->tag = tag;
+	data->offset = offset;
+
+	state = __alloc_smatch_state(0);
+	state->name = alloc_sname(name);
+	state->data = data;
+	return state;
+}
+
+struct smatch_state *merge_tag_info(struct smatch_state *s1, struct smatch_state *s2)
+{
+	/* Basically ignore undefined states */
+	if (s1 == &undefined)
+		return s2;
+	if (s2 == &undefined)
+		return s1;
+
+	return &merged;
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct expression *left;
+	struct symbol *right_sym;
+	char *name;
+	mtag_t tag;
+	int offset;
+	int param;
+
+	if (expr->op != '=')
+		return;
+	left = strip_expr(expr->left);
+	right_sym = expr_to_sym(expr->right);
+	if (!right_sym)
+		return;
+
+	param = get_param_num_from_sym(right_sym);
+	if (param < 0)
+		return;
+	// FIXME:  modify param_has_filter_data() to take a name/sym
+	if (!expr_to_mtag_offset(left, &tag, &offset))
+		return;
+	name = expr_to_str(left);
+	if (!name)
+		return;
+	set_state_expr(my_id, expr->right, alloc_tag_data_state(tag, name, offset));
+	free_string(name);
+}
+
+#if 0
+static void save_mtag_to_map(struct expression *expr, mtag_t tag, int offset, int param, char *key, char *value)
+{
+	struct expression *arg, *gen_expr;
+	mtag_t arg_tag;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+
+	gen_expr = gen_expression_from_key(arg, key);
+	if (!gen_expr)
+		return;
+
+	if (!get_mtag(gen_expr, &arg_tag))
+		arg_tag = 0;
+
+	if (local_debug)
+		sm_msg("finding mtag for '%s' %lld", expr_to_str(gen_expr), arg_tag);
+}
+#endif
+
+static void propogate_assignment(struct expression *expr, mtag_t tag, int offset, int param, char *key)
+{
+	struct expression *arg;
+	int orig_param;
+	char buf[32];
+	char *name;
+	struct symbol *sym;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	orig_param = get_param_num_from_sym(sym);
+	if (orig_param < 0)
+		goto free;
+
+	snprintf(buf, sizeof(buf), "$->[%d]", offset);
+	set_state(my_id, name, sym, alloc_tag_data_state(tag, buf, offset));
+free:
+	free_string(name);
+}
+
+static void assign_to_alias(struct expression *expr, int param, mtag_t tag, int offset, char *key)
+{
+	struct expression *arg, *gen_expr;
+	struct range_list *rl;
+	mtag_t arg_tag;
+	mtag_t alias;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+
+	gen_expr = gen_expression_from_key(arg, key);
+	if (!gen_expr)
+		return;
+
+	get_absolute_rl(gen_expr, &rl);
+
+	if (!create_mtag_alias(tag, expr, &alias))
+		return;
+
+//	insert_mtag_data(alias, offset, rl);
+
+	if (get_mtag(gen_expr, &arg_tag))
+		sql_insert_mtag_map(arg_tag, -offset, alias);
+}
+
+static void call_does_mtag_assign(struct expression *expr, int param, char *key, char *value)
+{
+	char *p;
+	mtag_t tag;
+	int offset;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	tag = strtoul(value, NULL, 10);
+	p = strchr(value, '+');
+	if (!p)
+		return;
+	offset = atoi(p + 1);
+
+//	save_mtag_to_map(expr, tag, offset, param, key, value);
+	propogate_assignment(expr, tag, offset, param, key);
+	assign_to_alias(expr, param, tag, offset, key);
+}
+
+static void print_stored_to_mtag(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct sm_state *sm;
+	struct tag_assign_info *data;
+	char buf[256];
+	const char *param_name;
+	int param;
+
+	FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
+		if (!sm->state->data)
+			continue;
+
+		param = get_param_num_from_sym(sm->sym);
+		if (param < 0)
+			continue;
+		param_name = get_param_name(sm);
+		if (!param_name)
+			continue;
+
+		data = sm->state->data;
+		snprintf(buf, sizeof(buf), "%lld+%d", data->tag, data->offset);
+		sql_insert_return_states(return_id, return_ranges, MTAG_ASSIGN, param, param_name, buf);
+	} END_FOR_EACH_SM(sm);
+}
+
+void register_param_to_mtag_data(int id)
+{
+	my_id = id;
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+	select_return_states_hook(MTAG_ASSIGN, &call_does_mtag_assign);
+	add_merge_hook(my_id, &merge_tag_info);
+	add_split_return_callback(&print_stored_to_mtag);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_param_used.c b/usr/src/tools/smatch/src/smatch_param_used.c
new file mode 100644
index 0000000000..80d390d359
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_param_used.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2015 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static struct stree *used_stree;
+static struct stree_stack *saved_stack;
+
+STATE(used);
+
+static void get_state_hook(int owner, const char *name, struct symbol *sym)
+{
+	int arg;
+
+	if (!option_info)
+		return;
+	if (__in_fake_assign)
+		return;
+
+	arg = get_param_num_from_sym(sym);
+	if (arg >= 0)
+		set_state_stree(&used_stree, my_id, name, sym, &used);
+}
+
+static void set_param_used(struct expression *call, struct expression *arg, char *key, char *unused)
+{
+	struct symbol *sym;
+	char *name;
+	int arg_nr;
+
+	name = get_variable_from_key(arg, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	arg_nr = get_param_num_from_sym(sym);
+	if (arg_nr >= 0)
+		set_state(my_id, name, sym, &used);
+free:
+	free_string(name);
+}
+
+static void process_states(void)
+{
+	struct sm_state *tmp;
+	int arg;
+	const char *name;
+
+	FOR_EACH_SM(used_stree, tmp) {
+		arg = get_param_num_from_sym(tmp->sym);
+		if (arg < 0)
+			continue;
+		name = get_param_name(tmp);
+		if (!name)
+			continue;
+
+		sql_insert_return_implies(PARAM_USED, arg, name, "");
+	} END_FOR_EACH_SM(tmp);
+
+	free_stree(&used_stree);
+}
+
+static void match_function_def(struct symbol *sym)
+{
+	free_stree(&used_stree);
+}
+
+static void match_save_states(struct expression *expr)
+{
+	push_stree(&saved_stack, used_stree);
+	used_stree = NULL;
+}
+
+static void match_restore_states(struct expression *expr)
+{
+	free_stree(&used_stree);
+	used_stree = pop_stree(&saved_stack);
+}
+
+void register_param_used(int id)
+{
+	my_id = id;
+
+	add_hook(&match_function_def, FUNC_DEF_HOOK);
+
+	add_get_state_hook(&get_state_hook);
+
+	add_hook(&match_save_states, INLINE_FN_START);
+	add_hook(&match_restore_states, INLINE_FN_END);
+
+	select_return_implies_hook(PARAM_USED, &set_param_used);
+	all_return_states_hook(&process_states);
+}
diff --git a/usr/src/tools/smatch/src/smatch_parameter_names.c b/usr/src/tools/smatch/src/smatch_parameter_names.c
new file mode 100644
index 0000000000..5ad09c9afa
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_parameter_names.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static void match_def(struct symbol *sym)
+{
+	struct symbol *param;
+	int i;
+
+	if (__inline_fn)
+		return;
+
+	i = -1;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, param) {
+		i++;
+		if (!param->ident)
+			continue;
+		sql_insert_parameter_name(i, param->ident->name);
+	} END_FOR_EACH_PTR(param);
+}
+
+void register_parameter_names(int id)
+{
+	if (!option_info)
+		return;
+
+	add_hook(&match_def, FUNC_DEF_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_parse_call_math.c b/usr/src/tools/smatch/src/smatch_parse_call_math.c
new file mode 100644
index 0000000000..a84622d941
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_parse_call_math.c
@@ -0,0 +1,652 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+struct {
+	const char *func;
+	int param;
+} alloc_functions[] = {
+	{"kmalloc", 0},
+	{"kzalloc", 0},
+	{"__kmalloc", 0},
+	{"vmalloc", 0},
+	{"__vmalloc", 0},
+	{"__vmalloc_node", 0},
+};
+
+static struct range_list_stack *rl_stack;
+static struct string_list *op_list;
+
+static void push_op(char c)
+{
+	char *p;
+
+	p = malloc(1);
+	p[0] = c;
+	add_ptr_list(&op_list, p);
+}
+
+static char pop_op(void)
+{
+	char *p;
+	char c;
+
+	if (!op_list) {
+		sm_perror("%s: no op_list", __func__);
+		return '\0';
+	}
+
+	p = last_ptr_list((struct ptr_list *)op_list);
+
+	delete_ptr_list_last((struct ptr_list **)&op_list);
+	c = p[0];
+	free(p);
+
+	return c;
+}
+
+static int op_precedence(char c)
+{
+	switch (c) {
+	case '+':
+	case '-':
+		return 1;
+	case '*':
+	case '/':
+		return 2;
+	default:
+		return 0;
+	}
+}
+
+static int top_op_precedence(void)
+{
+	char *p;
+
+	if (!op_list)
+		return 0;
+
+	p = last_ptr_list((struct ptr_list *)op_list);
+	return op_precedence(p[0]);
+}
+
+static void rl_pop_until(char c)
+{
+	char op;
+	struct range_list *left, *right;
+	struct range_list *res;
+
+	while (top_op_precedence() && op_precedence(c) <= top_op_precedence()) {
+		op = pop_op();
+		right = pop_rl(&rl_stack);
+		left = pop_rl(&rl_stack);
+		res = rl_binop(left, op, right);
+		if (!res)
+			res = alloc_whole_rl(&llong_ctype);
+		push_rl(&rl_stack, res);
+	}
+}
+
+static void rl_discard_stacks(void)
+{
+	while (op_list)
+		pop_op();
+	while (rl_stack)
+		pop_rl(&rl_stack);
+}
+
+static int read_rl_from_var(struct expression *call, char *p, char **end, struct range_list **rl)
+{
+	struct expression *arg;
+	struct smatch_state *state;
+	long param;
+	char *name;
+	struct symbol *sym;
+	char buf[256];
+	int star;
+
+	p++;
+	param = strtol(p, &p, 10);
+
+	arg = get_argument_from_call_expr(call->args, param);
+	if (!arg)
+		return 0;
+
+	if (*p != '-' && *p != '.') {
+		get_absolute_rl(arg, rl);
+		*end = p;
+		return 1;
+	}
+
+	*end = strchr(p, ' ');
+
+	if (arg->type == EXPR_PREOP && arg->op == '&') {
+		arg = strip_expr(arg->unop);
+		star = 0;
+		p++;
+	} else {
+		star = 1;
+		p += 2;
+	}
+
+	name = expr_to_var_sym(arg, &sym);
+	if (!name)
+		return 0;
+	snprintf(buf, sizeof(buf), "%s%s", name, star ? "->" : ".");
+	free_string(name);
+
+	if (*end - p + strlen(buf) >= sizeof(buf))
+		return 0;
+	strncat(buf, p, *end - p);
+
+	state = get_state(SMATCH_EXTRA, buf, sym);
+	if (!state)
+		return 0;
+	*rl = estate_rl(state);
+	return 1;
+}
+
+static int read_var_num(struct expression *call, char *p, char **end, struct range_list **rl)
+{
+	sval_t sval;
+
+	while (*p == ' ')
+		p++;
+
+	if (*p == '$')
+		return read_rl_from_var(call, p, end, rl);
+
+	sval.type = &llong_ctype;
+	sval.value = strtoll(p, end, 10);
+	if (*end == p)
+		return 0;
+	*rl = alloc_rl(sval, sval);
+	return 1;
+}
+
+static char *read_op(char *p)
+{
+	while (*p == ' ')
+		p++;
+
+	switch (*p) {
+	case '+':
+	case '-':
+	case '*':
+	case '/':
+		return p;
+	default:
+		return NULL;
+	}
+}
+
+int parse_call_math_rl(struct expression *call, char *math, struct range_list **rl)
+{
+	struct range_list *tmp;
+	char *c;
+
+	/* try to implement shunting yard algorithm. */
+
+	c = (char *)math;
+	while (1) {
+		if (option_debug)
+			sm_msg("parsing %s", c);
+
+		/* read a number and push it onto the number stack */
+		if (!read_var_num(call, c, &c, &tmp))
+			goto fail;
+		push_rl(&rl_stack, tmp);
+
+		if (option_debug)
+			sm_msg("val = %s remaining = %s", show_rl(tmp), c);
+
+		if (!*c)
+			break;
+		if (*c == ']' && *(c + 1) == '\0')
+			break;
+
+		c = read_op(c);
+		if (!c)
+			goto fail;
+
+		if (option_debug)
+			sm_msg("op = %c remaining = %s", *c, c);
+
+		rl_pop_until(*c);
+		push_op(*c);
+		c++;
+	}
+
+	rl_pop_until(0);
+	*rl = pop_rl(&rl_stack);
+	return 1;
+fail:
+	rl_discard_stacks();
+	return 0;
+}
+
+int parse_call_math(struct expression *call, char *math, sval_t *sval)
+{
+	struct range_list *rl;
+
+	if (!parse_call_math_rl(call, math, &rl))
+		return 0;
+	if (!rl_to_sval(rl, sval))
+		return 0;
+	return 1;
+}
+
+static struct smatch_state *alloc_state_sname(char *sname)
+{
+	struct smatch_state *state;
+
+	state = __alloc_smatch_state(0);
+	state->name = sname;
+	state->data = INT_PTR(1);
+	return state;
+}
+
+static int get_arg_number(struct expression *expr)
+{
+	struct symbol *sym;
+	struct symbol *arg;
+	int i;
+
+	expr = strip_expr(expr);
+	if (expr->type != EXPR_SYMBOL)
+		return -1;
+	sym = expr->symbol;
+
+	i = 0;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
+		if (arg == sym)
+			return i;
+		i++;
+	} END_FOR_EACH_PTR(arg);
+
+	return -1;
+}
+
+static int format_name_sym_helper(char *buf, int remaining, char *name, struct symbol *sym)
+{
+	int ret = 0;
+	int arg;
+	char *param_name;
+	int name_len;
+
+	if (!name || !sym || !sym->ident)
+		goto free;
+	arg = get_param_num_from_sym(sym);
+	if (arg < 0)
+		goto free;
+	if (param_was_set_var_sym(name, sym))
+		goto free;
+
+	param_name = sym->ident->name;
+	name_len = strlen(param_name);
+
+	if (name[name_len] == '\0')
+		ret = snprintf(buf, remaining, "$%d", arg);
+	else if (name[name_len] == '-')
+		ret = snprintf(buf, remaining, "$%d%s", arg, name + name_len);
+	else
+		goto free;
+
+	remaining -= ret;
+	if (remaining <= 0)
+		ret = 0;
+
+free:
+	free_string(name);
+
+	return ret;
+
+}
+
+static int format_variable_helper(char *buf, int remaining, struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (param_was_set_var_sym(name, sym))
+		return 0;
+	return format_name_sym_helper(buf, remaining, name, sym);
+}
+
+static int format_call_to_param_mapping(char *buf, int remaining, struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+
+	name = map_call_to_param_name_sym(expr, &sym);
+	if (param_was_set_var_sym(name, sym))
+		return 0;
+	return format_name_sym_helper(buf, remaining, name, sym);
+}
+
+static int format_expr_helper(char *buf, int remaining, struct expression *expr)
+{
+	sval_t sval;
+	int ret;
+	char *cur;
+
+	if (!expr)
+		return 0;
+
+	cur = buf;
+
+	if (expr->type == EXPR_BINOP) {
+		ret = format_expr_helper(cur, remaining, expr->left);
+		if (ret == 0)
+			return 0;
+		remaining -= ret;
+		if (remaining <= 0)
+			return 0;
+		cur += ret;
+
+		ret = snprintf(cur, remaining, " %s ", show_special(expr->op));
+		remaining -= ret;
+		if (remaining <= 0)
+			return 0;
+		cur += ret;
+
+		ret = format_expr_helper(cur, remaining, expr->right);
+		if (ret == 0)
+			return 0;
+		remaining -= ret;
+		if (remaining <= 0)
+			return 0;
+		cur += ret;
+		return cur - buf;
+	}
+
+	if (get_implied_value(expr, &sval)) {
+		ret = snprintf(cur, remaining, "%s", sval_to_str(sval));
+		remaining -= ret;
+		if (remaining <= 0)
+			return 0;
+		return ret;
+	}
+
+	if (expr->type == EXPR_CALL)
+		return format_call_to_param_mapping(cur, remaining, expr);
+
+	return format_variable_helper(cur, remaining, expr);
+}
+
+static char *format_expr(struct expression *expr)
+{
+	char buf[256] = "";
+	int ret;
+
+	ret = format_expr_helper(buf, sizeof(buf), expr);
+	if (ret == 0)
+		return NULL;
+
+	return alloc_sname(buf);
+}
+
+char *get_value_in_terms_of_parameter_math(struct expression *expr)
+{
+	struct expression *tmp;
+	char buf[256] = "";
+	sval_t dummy;
+	int ret;
+
+	tmp = get_assigned_expr(expr);
+	if (tmp)
+		expr = tmp;
+	if (param_was_set(expr))
+		return NULL;
+
+	if (get_implied_value(expr, &dummy))
+		return NULL;
+
+	ret = format_expr_helper(buf, sizeof(buf), expr);
+	if (ret == 0)
+		return NULL;
+
+	return alloc_sname(buf);
+}
+
+char *get_value_in_terms_of_parameter_math_var_sym(const char *name, struct symbol *sym)
+{
+	struct expression *tmp, *expr;
+	char buf[256] = "";
+	int ret;
+	int cnt = 0;
+
+	expr = get_assigned_expr_name_sym(name, sym);
+	if (!expr)
+		return NULL;
+	while ((tmp = get_assigned_expr(expr))) {
+		expr = strip_expr(tmp);
+		if (++cnt > 3)
+			break;
+	}
+
+	ret = format_expr_helper(buf, sizeof(buf), expr);
+	if (ret == 0)
+		return NULL;
+
+	return alloc_sname(buf);
+
+}
+
+static void match_alloc(const char *fn, struct expression *expr, void *_size_arg)
+{
+	int size_arg = PTR_INT(_size_arg);
+	struct expression *right;
+	struct expression *size_expr;
+	char *sname;
+
+	right = strip_expr(expr->right);
+	size_expr = get_argument_from_call_expr(right->args, size_arg);
+
+	sname = format_expr(size_expr);
+	if (!sname)
+		return;
+	set_state_expr(my_id, expr->left, alloc_state_sname(sname));
+}
+
+static char *swap_format(struct expression *call, char *format)
+{
+	char buf[256];
+	sval_t sval;
+	long param;
+	struct expression *arg;
+	char *p;
+	char *out;
+	int ret;
+
+	if (format[0] == '$' && format[2] == '\0') {
+		param = strtol(format + 1, NULL, 10);
+		arg = get_argument_from_call_expr(call->args, param);
+		if (!arg)
+			return NULL;
+		return format_expr(arg);
+	}
+
+	buf[0] = '\0';
+	p = format;
+	out = buf;
+	while (*p) {
+		if (*p == '$') {
+			p++;
+			param = strtol(p, &p, 10);
+			arg = get_argument_from_call_expr(call->args, param);
+			if (!arg)
+				return NULL;
+			param = get_arg_number(arg);
+			if (param >= 0) {
+				ret = snprintf(out, buf + sizeof(buf) - out, "$%ld", param);
+				out += ret;
+				if (out >= buf + sizeof(buf))
+					return NULL;
+			} else if (get_implied_value(arg, &sval)) {
+				ret = snprintf(out, buf + sizeof(buf) - out, "%s", sval_to_str(sval));
+				out += ret;
+				if (out >= buf + sizeof(buf))
+					return NULL;
+			} else {
+				return NULL;
+			}
+		}
+		*out = *p;
+		p++;
+		out++;
+	}
+	if (buf[0] == '\0')
+		return NULL;
+	*out = '\0';
+	return alloc_sname(buf);
+}
+
+static char *buf_size_recipe;
+static int db_buf_size_callback(void *unused, int argc, char **argv, char **azColName)
+{
+	if (argc != 1)
+		return 0;
+
+	if (!buf_size_recipe)
+		buf_size_recipe = alloc_sname(argv[0]);
+	else if (strcmp(buf_size_recipe, argv[0]) != 0)
+		buf_size_recipe = alloc_sname("invalid");
+	return 0;
+}
+
+static char *get_allocation_recipe_from_call(struct expression *expr)
+{
+	struct symbol *sym;
+	static char sql_filter[1024];
+	int i;
+
+	if (is_fake_call(expr))
+		return NULL;
+	expr = strip_expr(expr);
+	if (expr->fn->type != EXPR_SYMBOL)
+		return NULL;
+	sym = expr->fn->symbol;
+	if (!sym)
+		return NULL;
+
+	for (i = 0; i < ARRAY_SIZE(alloc_functions); i++) {
+		if (strcmp(sym->ident->name, alloc_functions[i].func) == 0) {
+			char buf[32];
+
+			snprintf(buf, sizeof(buf), "$%d", alloc_functions[i].param);
+			buf_size_recipe = alloc_sname(buf);
+			return swap_format(expr, buf_size_recipe);
+		}
+	}
+
+	if (sym->ctype.modifiers & MOD_STATIC) {
+		snprintf(sql_filter, 1024, "file = '%s' and function = '%s';",
+			 get_filename(), sym->ident->name);
+	} else {
+		snprintf(sql_filter, 1024, "function = '%s' and static = 0;",
+				sym->ident->name);
+	}
+
+	buf_size_recipe = NULL;
+	run_sql(db_buf_size_callback, NULL,
+		"select value from return_states where type=%d and %s",
+		BUF_SIZE, sql_filter);
+	if (!buf_size_recipe || strcmp(buf_size_recipe, "invalid") == 0)
+		return NULL;
+	return swap_format(expr, buf_size_recipe);
+}
+
+static void match_call_assignment(struct expression *expr)
+{
+	char *sname;
+
+	sname = get_allocation_recipe_from_call(expr->right);
+	if (!sname)
+		return;
+	set_state_expr(my_id, expr->left, alloc_state_sname(sname));
+}
+
+static void match_returns_call(int return_id, char *return_ranges, struct expression *call)
+{
+	char *sname;
+
+	sname = get_allocation_recipe_from_call(call);
+	if (option_debug)
+		sm_msg("sname = %s", sname);
+	if (!sname)
+		return;
+
+	sql_insert_return_states(return_id, return_ranges, BUF_SIZE, -1, "",
+			sname);
+}
+
+static void print_returned_allocations(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct expression *tmp;
+	struct smatch_state *state;
+	struct symbol *sym;
+	char *name;
+	int cnt = 0;
+
+	expr = strip_expr(expr);
+	while ((tmp = get_assigned_expr(expr))) {
+		if (cnt++ > 5)  /* assignments to self cause infinite loops */
+			break;
+		expr = strip_expr(tmp);
+	}
+	if (!expr)
+		return;
+
+	if (expr->type == EXPR_CALL) {
+		match_returns_call(return_id, return_ranges, expr);
+		return;
+	}
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+
+	state = get_state(my_id, name, sym);
+	if (!state || !state->data)
+		goto free;
+
+	sql_insert_return_states(return_id, return_ranges, BUF_SIZE, -1, "",
+			state->name);
+free:
+	free_string(name);
+}
+
+void register_parse_call_math(int id)
+{
+	int i;
+
+	my_id = id;
+
+	for (i = 0; i < ARRAY_SIZE(alloc_functions); i++)
+		add_function_assign_hook(alloc_functions[i].func, &match_alloc,
+				         INT_PTR(alloc_functions[i].param));
+	add_hook(&match_call_assignment, CALL_ASSIGNMENT_HOOK);
+	add_split_return_callback(print_returned_allocations);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_passes_array_size.c b/usr/src/tools/smatch/src/smatch_passes_array_size.c
new file mode 100644
index 0000000000..cf69c8cdc5
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_passes_array_size.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+
+static int find_param_eq(struct expression *expr, int size)
+{
+	struct expression *arg;
+	sval_t val;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+		if (!get_implied_value(arg, &val))
+			continue;
+		if (val.value == size)
+			return i;
+	} END_FOR_EACH_PTR(arg);
+
+	return -1;
+}
+
+static void match_call(struct expression *expr)
+{
+	struct expression *arg;
+	struct symbol *type;
+	int size, bytes;
+	int i, nr;
+	char buf[16];
+
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+		type = get_type(arg);
+		if (!type || (type->type != SYM_PTR && type->type != SYM_ARRAY))
+			continue;
+		size = get_array_size(arg);
+		if (size > 0) {
+			nr = find_param_eq(expr, size);
+			if (nr >= 0) {
+				snprintf(buf, sizeof(buf), "%d", nr);
+				sql_insert_caller_info(expr, ARRAYSIZE_ARG, i, buf, "");
+				continue;
+			}
+		}
+		bytes = get_array_size_bytes(arg);
+		if (bytes > 0) {
+			nr = find_param_eq(expr, bytes);
+			if (nr >= 0) {
+				snprintf(buf, sizeof(buf), "%d", nr);
+				sql_insert_caller_info(expr, SIZEOF_ARG, i, buf, "");
+				continue;
+			}
+		}
+	} END_FOR_EACH_PTR(arg);
+}
+
+void register_passes_array_size(int id)
+{
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_project.c b/usr/src/tools/smatch/src/smatch_project.c
new file mode 100644
index 0000000000..416445e441
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_project.c
@@ -0,0 +1,218 @@
+/*
+ * Copyright (C) 2010 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This file is only for very generic stuff, that is reusable
+ * between projects.  If you need something special create a
+ * check_your_project.c.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_function_hashtable.h"
+
+static DEFINE_HASHTABLE_INSERT(insert_func, char, int);
+static DEFINE_HASHTABLE_SEARCH(search_func, char, int);
+static struct hashtable *skipped_funcs;
+static struct hashtable *silenced_funcs;
+static struct hashtable *no_inline_funcs;
+
+int is_skipped_function(void)
+{
+	char *func;
+
+	func = get_function();
+	if (!func)
+		return 0;
+	if (search_func(skipped_funcs, func))
+		return 1;
+	return 0;
+}
+
+/*
+ * A silenced function will still be processed and potentially appear in info
+ * output, but not regular checks.
+ */
+int is_silenced_function(void)
+{
+	char *func;
+
+	if (is_skipped_function())
+		return 1;
+
+	func = get_function();
+	if (!func)
+		return 0;
+	if (search_func(silenced_funcs, func))
+		return 1;
+	return 0;
+}
+
+int is_no_inline_function(const char *function)
+{
+	if (search_func(no_inline_funcs, (char *)function))
+		return 1;
+	return 0;
+}
+
+static void register_no_return_funcs(void)
+{
+	struct token *token;
+	const char *func;
+	char name[256];
+
+	snprintf(name, 256, "%s.no_return_funcs", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = show_ident(token->ident);
+		add_function_hook(func, &__match_nullify_path_hook, NULL);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void register_ignored_macros(void)
+{
+	struct token *token;
+	char *macro;
+	char name[256];
+
+	if (option_project == PROJ_NONE)
+		strcpy(name, "ignored_macros");
+	else
+		snprintf(name, 256, "%s.ignored_macros", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		macro = alloc_string(show_ident(token->ident));
+		add_ptr_list(&__ignored_macros, macro);
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void register_skipped_functions(void)
+{
+	struct token *token;
+	char *func;
+	char name[256];
+
+	skipped_funcs = create_function_hashtable(500);
+
+	if (option_project == PROJ_NONE)
+		return;
+
+	snprintf(name, 256, "%s.skipped_functions", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = alloc_string(show_ident(token->ident));
+		insert_func(skipped_funcs, func, INT_PTR(1));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void register_silenced_functions(void)
+{
+	struct token *token;
+	char *func;
+	char name[256];
+
+	silenced_funcs = create_function_hashtable(500);
+
+	if (option_project == PROJ_NONE)
+		return;
+
+	snprintf(name, 256, "%s.silenced_functions", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = alloc_string(show_ident(token->ident));
+		insert_func(silenced_funcs, func, INT_PTR(1));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void register_no_inline_functions(void)
+{
+	struct token *token;
+	char *func;
+	char name[256];
+
+	no_inline_funcs = create_function_hashtable(500);
+
+	if (option_project == PROJ_NONE)
+		return;
+
+	snprintf(name, 256, "%s.no_inline_functions", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		func = alloc_string(show_ident(token->ident));
+		insert_func(no_inline_funcs, func, INT_PTR(1));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+void register_project(int id)
+{
+	register_no_return_funcs();
+	register_ignored_macros();
+	register_skipped_functions();
+	register_silenced_functions();
+	register_no_inline_functions();
+}
diff --git a/usr/src/tools/smatch/src/smatch_ranges.c b/usr/src/tools/smatch/src/smatch_ranges.c
new file mode 100644
index 0000000000..fbc93fec7e
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_ranges.c
@@ -0,0 +1,1844 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_extra.h"
+#include "smatch_slist.h"
+
+ALLOCATOR(data_info, "smatch extra data");
+ALLOCATOR(data_range, "data range");
+__DO_ALLOCATOR(struct data_range, sizeof(struct data_range), __alignof__(struct data_range),
+			 "permanent ranges", perm_data_range);
+__DECLARE_ALLOCATOR(struct ptr_list, rl_ptrlist);
+
+char *show_rl(struct range_list *list)
+{
+	struct data_range *tmp;
+	char full[512];
+	int i = 0;
+
+	full[0] = '\0';
+	full[sizeof(full) - 1] = '\0';
+	FOR_EACH_PTR(list, tmp) {
+		if (i++)
+			strncat(full, ",", 254 - strlen(full));
+		if (sval_cmp(tmp->min, tmp->max) == 0) {
+			strncat(full, sval_to_str(tmp->min), 254 - strlen(full));
+			continue;
+		}
+		strncat(full, sval_to_str(tmp->min), 254 - strlen(full));
+		strncat(full, "-", 254 - strlen(full));
+		strncat(full, sval_to_str(tmp->max), 254 - strlen(full));
+	} END_FOR_EACH_PTR(tmp);
+	if (strlen(full) == sizeof(full) - 1)
+		full[sizeof(full) - 2] = '+';
+	return alloc_sname(full);
+}
+
+void free_all_rl(void)
+{
+	clear_rl_ptrlist_alloc();
+}
+
+static int sval_too_big(struct symbol *type, sval_t sval)
+{
+	if (type_bits(type) >= 32 &&
+	    type_bits(sval.type) <= type_bits(type))
+		return 0;
+	if (sval.uvalue <= ((1ULL << type_bits(type)) - 1))
+		return 0;
+	if (type_signed(sval.type)) {
+		if (type_unsigned(type)) {
+			unsigned long long neg = ~sval.uvalue;
+			if (neg <= sval_type_max(type).uvalue)
+				return 0;
+		}
+		if (sval.value < sval_type_min(type).value)
+			return 1;
+		if (sval.value > sval_type_max(type).value)
+			return 1;
+		return 0;
+	}
+	if (sval.uvalue > sval_type_max(type).uvalue)
+		return 1;
+	return 0;
+}
+
+static void add_range_t(struct symbol *type, struct range_list **rl, sval_t min, sval_t max)
+{
+	/* If we're just adding a number, cast it and add it */
+	if (sval_cmp(min, max) == 0) {
+		add_range(rl, sval_cast(type, min), sval_cast(type, max));
+		return;
+	}
+
+	/* If the range is within the type range then add it */
+	if (sval_fits(type, min) && sval_fits(type, max)) {
+		add_range(rl, sval_cast(type, min), sval_cast(type, max));
+		return;
+	}
+
+	/*
+	 * If the range we are adding has more bits than the range type then
+	 * add the whole range type.  Eg:
+	 * 0x8000000000000000 - 0xf000000000000000 -> cast to int
+	 * This isn't totally the right thing to do.  We could be more granular.
+	 */
+	if (sval_too_big(type, min) || sval_too_big(type, max)) {
+		add_range(rl, sval_type_min(type), sval_type_max(type));
+		return;
+	}
+
+	/* Cast negative values to high positive values */
+	if (sval_is_negative(min) && type_unsigned(type)) {
+		if (sval_is_positive(max)) {
+			if (sval_too_high(type, max)) {
+				add_range(rl, sval_type_min(type), sval_type_max(type));
+				return;
+			}
+			add_range(rl, sval_type_val(type, 0), sval_cast(type, max));
+			max = sval_type_max(type);
+		} else {
+			max = sval_cast(type, max);
+		}
+		min = sval_cast(type, min);
+		add_range(rl, min, max);
+	}
+
+	/* Cast high positive numbers to negative */
+	if (sval_unsigned(max) && sval_is_negative(sval_cast(type, max))) {
+		if (!sval_is_negative(sval_cast(type, min))) {
+			add_range(rl, sval_cast(type, min), sval_type_max(type));
+			min = sval_type_min(type);
+		} else {
+			min = sval_cast(type, min);
+		}
+		max = sval_cast(type, max);
+		add_range(rl, min, max);
+	}
+
+	add_range(rl, sval_cast(type, min), sval_cast(type, max));
+	return;
+}
+
+static int str_to_comparison_arg_helper(const char *str,
+		struct expression *call, int *comparison,
+		struct expression **arg, char **endp)
+{
+	int param;
+	char *c = (char *)str;
+
+	if (*c != '[')
+		return 0;
+	c++;
+
+	if (*c == '<') {
+		c++;
+		if (*c == '=') {
+			*comparison = SPECIAL_LTE;
+			c++;
+		} else {
+			*comparison = '<';
+		}
+	} else if (*c == '=') {
+		c++;
+		c++;
+		*comparison = SPECIAL_EQUAL;
+	} else if (*c == '>') {
+		c++;
+		if (*c == '=') {
+			*comparison = SPECIAL_GTE;
+			c++;
+		} else {
+			*comparison = '>';
+		}
+	} else if (*c == '!') {
+		c++;
+		c++;
+		*comparison = SPECIAL_NOTEQUAL;
+	} else {
+		return 0;
+	}
+
+	if (*c != '$')
+		return 0;
+	c++;
+
+	param = strtoll(c, &c, 10);
+	if (*c == ']')
+		c++; /* skip the ']' character */
+	if (endp)
+		*endp = (char *)c;
+
+	if (!call)
+		return 0;
+	*arg = get_argument_from_call_expr(call->args, param);
+	if (!*arg)
+		return 0;
+	if (*c == '-' && *(c + 1) == '>') {
+		char buf[256];
+		int n;
+
+		n = snprintf(buf, sizeof(buf), "$%s", c);
+		if (n >= sizeof(buf))
+			return 0;
+		if (buf[n - 1] == ']')
+			buf[n - 1] = '\0';
+		*arg = gen_expression_from_key(*arg, buf);
+		while (*c && *c != ']')
+			c++;
+	}
+	return 1;
+}
+
+int str_to_comparison_arg(const char *str, struct expression *call, int *comparison, struct expression **arg)
+{
+	while (1) {
+		if (!*str)
+			return 0;
+		if (*str == '[')
+			break;
+		str++;
+	}
+	return str_to_comparison_arg_helper(str, call, comparison, arg, NULL);
+}
+
+static int get_val_from_key(int use_max, struct symbol *type, char *c, struct expression *call, char **endp, sval_t *sval)
+{
+	struct expression *arg;
+	int comparison;
+	sval_t ret, tmp;
+
+	if (use_max)
+		ret = sval_type_max(type);
+	else
+		ret = sval_type_min(type);
+
+	if (!str_to_comparison_arg_helper(c, call, &comparison, &arg, endp)) {
+		*sval = ret;
+		return 0;
+	}
+
+	if (use_max && get_implied_max(arg, &tmp)) {
+		ret = tmp;
+		if (comparison == '<') {
+			tmp.value = 1;
+			ret = sval_binop(ret, '-', tmp);
+		}
+	}
+	if (!use_max && get_implied_min(arg, &tmp)) {
+		ret = tmp;
+		if (comparison == '>') {
+			tmp.value = 1;
+			ret = sval_binop(ret, '+', tmp);
+		}
+	}
+
+	*sval = ret;
+	return 1;
+}
+
+static sval_t add_one(sval_t sval)
+{
+	sval.value++;
+	return sval;
+}
+
+static sval_t sub_one(sval_t sval)
+{
+	sval.value--;
+	return sval;
+}
+
+void filter_by_comparison(struct range_list **rl, int comparison, struct range_list *right)
+{
+	struct range_list *left_orig = *rl;
+	struct range_list *right_orig = right;
+	struct range_list *ret_rl = *rl;
+	struct symbol *cast_type;
+	sval_t min, max;
+
+	cast_type = rl_type(left_orig);
+	if (sval_type_max(rl_type(left_orig)).uvalue < sval_type_max(rl_type(right_orig)).uvalue)
+		cast_type = rl_type(right_orig);
+	if (sval_type_max(cast_type).uvalue < INT_MAX)
+		cast_type = &int_ctype;
+
+	min = sval_type_min(cast_type);
+	max = sval_type_max(cast_type);
+	left_orig = cast_rl(cast_type, left_orig);
+	right_orig = cast_rl(cast_type, right_orig);
+
+	switch (comparison) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+		ret_rl = remove_range(left_orig, rl_max(right_orig), max);
+		break;
+	case SPECIAL_LTE:
+	case SPECIAL_UNSIGNED_LTE:
+		if (!sval_is_max(rl_max(right_orig)))
+			ret_rl = remove_range(left_orig, add_one(rl_max(right_orig)), max);
+		break;
+	case SPECIAL_EQUAL:
+		ret_rl = rl_intersection(left_orig, right_orig);
+		break;
+	case SPECIAL_GTE:
+	case SPECIAL_UNSIGNED_GTE:
+		if (!sval_is_min(rl_min(right_orig)))
+			ret_rl = remove_range(left_orig, min, sub_one(rl_min(right_orig)));
+		break;
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+		ret_rl = remove_range(left_orig, min, rl_min(right_orig));
+		break;
+	case SPECIAL_NOTEQUAL:
+		if (sval_cmp(rl_min(right_orig), rl_max(right_orig)) == 0)
+			ret_rl = remove_range(left_orig, rl_min(right_orig), rl_min(right_orig));
+		break;
+	default:
+		sm_perror("unhandled comparison %s", show_special(comparison));
+		return;
+	}
+
+	*rl = cast_rl(rl_type(*rl), ret_rl);
+}
+
+static struct range_list *filter_by_comparison_call(char *c, struct expression *call, char **endp, struct range_list *start_rl)
+{
+	struct symbol *type;
+	struct expression *arg;
+	struct range_list *casted_start, *right_orig;
+	int comparison;
+
+	if (!str_to_comparison_arg_helper(c, call, &comparison, &arg, endp))
+		return start_rl;
+
+	if (!get_implied_rl(arg, &right_orig))
+		return start_rl;
+
+	type = &int_ctype;
+	if (type_positive_bits(rl_type(start_rl)) > type_positive_bits(type))
+		type = rl_type(start_rl);
+	if (type_positive_bits(rl_type(right_orig)) > type_positive_bits(type))
+		type = rl_type(right_orig);
+
+	casted_start = cast_rl(type, start_rl);
+	right_orig = cast_rl(type, right_orig);
+
+	filter_by_comparison(&casted_start, comparison, right_orig);
+	return cast_rl(rl_type(start_rl), casted_start);
+}
+
+static sval_t parse_val(int use_max, struct expression *call, struct symbol *type, char *c, char **endp)
+{
+	char *start = c;
+	sval_t ret;
+
+	if (!strncmp(start, "max", 3)) {
+		ret = sval_type_max(type);
+		c += 3;
+	} else if (!strncmp(start, "u64max", 6)) {
+		ret = sval_type_val(type, ULLONG_MAX);
+		c += 6;
+	} else if (!strncmp(start, "s64max", 6)) {
+		ret = sval_type_val(type, LLONG_MAX);
+		c += 6;
+	} else if (!strncmp(start, "u32max", 6)) {
+		ret = sval_type_val(type, UINT_MAX);
+		c += 6;
+	} else if (!strncmp(start, "s32max", 6)) {
+		ret = sval_type_val(type, INT_MAX);
+		c += 6;
+	} else if (!strncmp(start, "u16max", 6)) {
+		ret = sval_type_val(type, USHRT_MAX);
+		c += 6;
+	} else if (!strncmp(start, "s16max", 6)) {
+		ret = sval_type_val(type, SHRT_MAX);
+		c += 6;
+	} else if (!strncmp(start, "min", 3)) {
+		ret = sval_type_min(type);
+		c += 3;
+	} else if (!strncmp(start, "s64min", 6)) {
+		ret = sval_type_val(type, LLONG_MIN);
+		c += 6;
+	} else if (!strncmp(start, "s32min", 6)) {
+		ret = sval_type_val(type, INT_MIN);
+		c += 6;
+	} else if (!strncmp(start, "s16min", 6)) {
+		ret = sval_type_val(type, SHRT_MIN);
+		c += 6;
+	} else if (!strncmp(start, "long_min", 8)) {
+		ret = sval_type_val(type, LONG_MIN);
+		c += 8;
+	} else if (!strncmp(start, "long_max", 8)) {
+		ret = sval_type_val(type, LONG_MAX);
+		c += 8;
+	} else if (!strncmp(start, "ulong_max", 9)) {
+		ret = sval_type_val(type, ULONG_MAX);
+		c += 9;
+	} else if (!strncmp(start, "ptr_max", 7)) {
+		ret = sval_type_val(type, valid_ptr_max);
+		c += 7;
+	} else if (start[0] == '[') {
+		/* this parses [==p0] comparisons */
+		get_val_from_key(1, type, start, call, &c, &ret);
+	} else if (type_positive_bits(type) == 64) {
+		ret = sval_type_val(type, strtoull(start, &c, 0));
+	} else {
+		ret = sval_type_val(type, strtoll(start, &c, 0));
+	}
+	*endp = c;
+	return ret;
+}
+
+static char *jump_to_call_math(char *value)
+{
+	char *c = value;
+
+	while (*c && *c != '[')
+		c++;
+
+	if (!*c)
+		return NULL;
+	c++;
+	if (*c == '<' || *c == '=' || *c == '>' || *c == '!')
+		return NULL;
+
+	return c;
+}
+
+static void str_to_rl_helper(struct expression *call, struct symbol *type, char *str, char **endp, struct range_list **rl)
+{
+	struct range_list *rl_tmp = NULL;
+	sval_t min, max;
+	char *c;
+
+	min = sval_type_min(type);
+	max = sval_type_max(type);
+	c = str;
+	while (*c != '\0' && *c != '[') {
+		if (*c == '+') {
+			if (sval_cmp(min, sval_type_min(type)) != 0)
+				min = max;
+			max = sval_type_max(type);
+			add_range_t(type, &rl_tmp, min, max);
+			break;
+		}
+		if (*c == '(')
+			c++;
+		min = parse_val(0, call, type, c, &c);
+		if (!sval_fits(type, min))
+			min = sval_type_min(type);
+		max = min;
+		if (*c == ')')
+			c++;
+		if (*c == '\0' || *c == '[') {
+			add_range_t(type, &rl_tmp, min, min);
+			break;
+		}
+		if (*c == ',') {
+			add_range_t(type, &rl_tmp, min, min);
+			c++;
+			continue;
+		}
+		if (*c == '+') {
+			min = sval_type_max(type);
+			c++;
+		}
+		if (*c != '-') {
+			sm_msg("debug XXX: trouble parsing %s c = %s", str, c);
+			break;
+		}
+		c++;
+		if (*c == '(')
+			c++;
+		max = parse_val(1, call, type, c, &c);
+		if (!sval_fits(type, max))
+			max = sval_type_max(type);
+		if (*c == '+') {
+			max = sval_type_max(type);
+			c++;
+		}
+		add_range_t(type, &rl_tmp, min, max);
+		if (*c == ')')
+			c++;
+		if (*c == ',')
+			c++;
+	}
+
+	*rl = rl_tmp;
+	*endp = c;
+}
+
+static void str_to_dinfo(struct expression *call, struct symbol *type, char *value, struct data_info *dinfo)
+{
+	struct range_list *math_rl;
+	char *call_math;
+	char *c;
+	struct range_list *rl = NULL;
+
+	if (!type)
+		type = &llong_ctype;
+
+	if (strcmp(value, "empty") == 0)
+		return;
+
+	if (strncmp(value, "[==$", 4) == 0) {
+		struct expression *arg;
+		int comparison;
+
+		if (!str_to_comparison_arg(value, call, &comparison, &arg))
+			return;
+		if (!get_implied_rl(arg, &rl))
+			return;
+		goto cast;
+	}
+
+	str_to_rl_helper(call, type, value, &c, &rl);
+	if (*c == '\0')
+		goto cast;
+
+	call_math = jump_to_call_math(value);
+	if (call_math && parse_call_math_rl(call, call_math, &math_rl)) {
+		rl = rl_intersection(rl, math_rl);
+		goto cast;
+	}
+
+	/*
+	 * For now if we already tried to handle the call math and couldn't
+	 * figure it out then bail.
+	 */
+	if (jump_to_call_math(c) == c + 1)
+		goto cast;
+
+	rl = filter_by_comparison_call(c, call, &c, rl);
+
+cast:
+	rl = cast_rl(type, rl);
+	dinfo->value_ranges = rl;
+}
+
+void str_to_rl(struct symbol *type, char *value, struct range_list **rl)
+{
+	struct data_info dinfo = {};
+
+	str_to_dinfo(NULL, type, value, &dinfo);
+	*rl = dinfo.value_ranges;
+}
+
+void call_results_to_rl(struct expression *expr, struct symbol *type, char *value, struct range_list **rl)
+{
+	struct data_info dinfo = {};
+
+	str_to_dinfo(strip_expr(expr), type, value, &dinfo);
+	*rl = dinfo.value_ranges;
+}
+
+int is_whole_rl(struct range_list *rl)
+{
+	struct data_range *drange;
+
+	if (ptr_list_empty(rl))
+		return 0;
+	drange = first_ptr_list((struct ptr_list *)rl);
+	if (sval_is_min(drange->min) && sval_is_max(drange->max))
+		return 1;
+	return 0;
+}
+
+int is_whole_rl_non_zero(struct range_list *rl)
+{
+	struct data_range *drange;
+
+	if (ptr_list_empty(rl))
+		return 0;
+	drange = first_ptr_list((struct ptr_list *)rl);
+	if (sval_unsigned(drange->min) &&
+	    drange->min.value == 1 &&
+	    sval_is_max(drange->max))
+		return 1;
+	if (!sval_is_min(drange->min) || drange->max.value != -1)
+		return 0;
+	drange = last_ptr_list((struct ptr_list *)rl);
+	if (drange->min.value != 1 || !sval_is_max(drange->max))
+		return 0;
+	return 1;
+}
+
+sval_t rl_min(struct range_list *rl)
+{
+	struct data_range *drange;
+	sval_t ret;
+
+	ret.type = &llong_ctype;
+	ret.value = LLONG_MIN;
+	if (ptr_list_empty(rl))
+		return ret;
+	drange = first_ptr_list((struct ptr_list *)rl);
+	return drange->min;
+}
+
+sval_t rl_max(struct range_list *rl)
+{
+	struct data_range *drange;
+	sval_t ret;
+
+	ret.type = &llong_ctype;
+	ret.value = LLONG_MAX;
+	if (ptr_list_empty(rl))
+		return ret;
+	drange = last_ptr_list((struct ptr_list *)rl);
+	return drange->max;
+}
+
+int rl_to_sval(struct range_list *rl, sval_t *sval)
+{
+	sval_t min, max;
+
+	if (!rl)
+		return 0;
+
+	min = rl_min(rl);
+	max = rl_max(rl);
+	if (sval_cmp(min, max) != 0)
+		return 0;
+	*sval = min;
+	return 1;
+}
+
+struct symbol *rl_type(struct range_list *rl)
+{
+	if (!rl)
+		return NULL;
+	return rl_min(rl).type;
+}
+
+static struct data_range *alloc_range_helper_sval(sval_t min, sval_t max, int perm)
+{
+	struct data_range *ret;
+
+	if (perm)
+		ret = __alloc_perm_data_range(0);
+	else
+		ret = __alloc_data_range(0);
+	ret->min = min;
+	ret->max = max;
+	return ret;
+}
+
+struct data_range *alloc_range(sval_t min, sval_t max)
+{
+	return alloc_range_helper_sval(min, max, 0);
+}
+
+struct data_range *alloc_range_perm(sval_t min, sval_t max)
+{
+	return alloc_range_helper_sval(min, max, 1);
+}
+
+struct range_list *alloc_rl(sval_t min, sval_t max)
+{
+	struct range_list *rl = NULL;
+
+	if (sval_cmp(min, max) > 0)
+		return alloc_whole_rl(min.type);
+
+	add_range(&rl, min, max);
+	return rl;
+}
+
+struct range_list *alloc_whole_rl(struct symbol *type)
+{
+	if (!type || type_positive_bits(type) < 0)
+		type = &llong_ctype;
+	if (type->type == SYM_ARRAY)
+		type = &ptr_ctype;
+
+	return alloc_rl(sval_type_min(type), sval_type_max(type));
+}
+
+extern int rl_ptrlist_hack;
+void add_range(struct range_list **list, sval_t min, sval_t max)
+{
+	struct data_range *tmp;
+	struct data_range *new = NULL;
+	int check_next = 0;
+
+	/*
+	 * There is at least on valid reason why the types might be confusing
+	 * and that's when you have a void pointer and on some paths you treat
+	 * it as a u8 pointer and on other paths you treat it as a u16 pointer.
+	 * This case is hard to deal with.
+	 *
+	 * There are other cases where we probably should be more specific about
+	 * the types than we are.  For example, we end up merging a lot of ulong
+	 * with pointers and I have not figured out why we do that.
+	 *
+	 * But this hack works for both cases, I think.  We cast it to pointers
+	 * or we use the bigger size.
+	 *
+	 */
+	if (*list && rl_type(*list) != min.type) {
+		if (rl_type(*list)->type == SYM_PTR) {
+			min = sval_cast(rl_type(*list), min);
+			max = sval_cast(rl_type(*list), max);
+		} else if (min.type->type == SYM_PTR) {
+			*list = cast_rl(min.type, *list);
+		} else if (type_bits(rl_type(*list)) >= type_bits(min.type)) {
+			min = sval_cast(rl_type(*list), min);
+			max = sval_cast(rl_type(*list), max);
+		} else {
+			*list = cast_rl(min.type, *list);
+		}
+	}
+
+	if (sval_cmp(min, max) > 0) {
+		min = sval_type_min(min.type);
+		max = sval_type_max(min.type);
+	}
+
+	/*
+	 * FIXME:  This has a problem merging a range_list like: min-0,3-max
+	 * with a range like 1-2.  You end up with min-2,3-max instead of
+	 * just min-max.
+	 */
+	FOR_EACH_PTR(*list, tmp) {
+		if (check_next) {
+			/* Sometimes we overlap with more than one range
+			   so we have to delete or modify the next range. */
+			if (!sval_is_max(max) && max.value + 1 == tmp->min.value) {
+				/* join 2 ranges here */
+				new->max = tmp->max;
+				DELETE_CURRENT_PTR(tmp);
+				return;
+			}
+
+			/* Doesn't overlap with the next one. */
+			if (sval_cmp(max, tmp->min) < 0)
+				return;
+
+			if (sval_cmp(max, tmp->max) <= 0) {
+				/* Partially overlaps the next one. */
+				new->max = tmp->max;
+				DELETE_CURRENT_PTR(tmp);
+				return;
+			} else {
+				/* Completely overlaps the next one. */
+				DELETE_CURRENT_PTR(tmp);
+				/* there could be more ranges to delete */
+				continue;
+			}
+		}
+		if (!sval_is_max(max) && max.value + 1 == tmp->min.value) {
+			/* join 2 ranges into a big range */
+			new = alloc_range(min, tmp->max);
+			REPLACE_CURRENT_PTR(tmp, new);
+			return;
+		}
+		if (sval_cmp(max, tmp->min) < 0) { /* new range entirely below */
+			new = alloc_range(min, max);
+			INSERT_CURRENT(new, tmp);
+			return;
+		}
+		if (sval_cmp(min, tmp->min) < 0) { /* new range partially below */
+			if (sval_cmp(max, tmp->max) < 0)
+				max = tmp->max;
+			else
+				check_next = 1;
+			new = alloc_range(min, max);
+			REPLACE_CURRENT_PTR(tmp, new);
+			if (!check_next)
+				return;
+			continue;
+		}
+		if (sval_cmp(max, tmp->max) <= 0) /* new range already included */
+			return;
+		if (sval_cmp(min, tmp->max) <= 0) { /* new range partially above */
+			min = tmp->min;
+			new = alloc_range(min, max);
+			REPLACE_CURRENT_PTR(tmp, new);
+			check_next = 1;
+			continue;
+		}
+		if (!sval_is_min(min) && min.value - 1 == tmp->max.value) {
+			/* join 2 ranges into a big range */
+			new = alloc_range(tmp->min, max);
+			REPLACE_CURRENT_PTR(tmp, new);
+			check_next = 1;
+			continue;
+		}
+		/* the new range is entirely above the existing ranges */
+	} END_FOR_EACH_PTR(tmp);
+	if (check_next)
+		return;
+	new = alloc_range(min, max);
+
+	rl_ptrlist_hack = 1;
+	add_ptr_list(list, new);
+	rl_ptrlist_hack = 0;
+}
+
+struct range_list *clone_rl(struct range_list *list)
+{
+	struct data_range *tmp;
+	struct range_list *ret = NULL;
+
+	FOR_EACH_PTR(list, tmp) {
+		add_ptr_list(&ret, tmp);
+	} END_FOR_EACH_PTR(tmp);
+	return ret;
+}
+
+struct range_list *clone_rl_permanent(struct range_list *list)
+{
+	struct data_range *tmp;
+	struct data_range *new;
+	struct range_list *ret = NULL;
+
+	FOR_EACH_PTR(list, tmp) {
+		new = alloc_range_perm(tmp->min, tmp->max);
+		add_ptr_list(&ret, new);
+	} END_FOR_EACH_PTR(tmp);
+	return ret;
+}
+
+struct range_list *rl_union(struct range_list *one, struct range_list *two)
+{
+	struct data_range *tmp;
+	struct range_list *ret = NULL;
+
+	FOR_EACH_PTR(one, tmp) {
+		add_range(&ret, tmp->min, tmp->max);
+	} END_FOR_EACH_PTR(tmp);
+	FOR_EACH_PTR(two, tmp) {
+		add_range(&ret, tmp->min, tmp->max);
+	} END_FOR_EACH_PTR(tmp);
+	return ret;
+}
+
+struct range_list *remove_range(struct range_list *list, sval_t min, sval_t max)
+{
+	struct data_range *tmp;
+	struct range_list *ret = NULL;
+
+	if (!list)
+		return NULL;
+
+	min = sval_cast(rl_type(list), min);
+	max = sval_cast(rl_type(list), max);
+	if (sval_cmp(min, max) > 0) {
+		sval_t tmp = min;
+		min = max;
+		max = tmp;
+	}
+
+	FOR_EACH_PTR(list, tmp) {
+		if (sval_cmp(tmp->max, min) < 0) {
+			add_range(&ret, tmp->min, tmp->max);
+			continue;
+		}
+		if (sval_cmp(tmp->min, max) > 0) {
+			add_range(&ret, tmp->min, tmp->max);
+			continue;
+		}
+		if (sval_cmp(tmp->min, min) >= 0 && sval_cmp(tmp->max, max) <= 0)
+			continue;
+		if (sval_cmp(tmp->min, min) >= 0) {
+			max.value++;
+			add_range(&ret, max, tmp->max);
+		} else if (sval_cmp(tmp->max, max) <= 0) {
+			min.value--;
+			add_range(&ret, tmp->min, min);
+		} else {
+			min.value--;
+			max.value++;
+			add_range(&ret, tmp->min, min);
+			add_range(&ret, max, tmp->max);
+		}
+	} END_FOR_EACH_PTR(tmp);
+	return ret;
+}
+
+int ranges_equiv(struct data_range *one, struct data_range *two)
+{
+	if (!one && !two)
+		return 1;
+	if (!one || !two)
+		return 0;
+	if (sval_cmp(one->min, two->min) != 0)
+		return 0;
+	if (sval_cmp(one->max, two->max) != 0)
+		return 0;
+	return 1;
+}
+
+int rl_equiv(struct range_list *one, struct range_list *two)
+{
+	struct data_range *one_range;
+	struct data_range *two_range;
+
+	if (one == two)
+		return 1;
+
+	PREPARE_PTR_LIST(one, one_range);
+	PREPARE_PTR_LIST(two, two_range);
+	for (;;) {
+		if (!one_range && !two_range)
+			return 1;
+		if (!ranges_equiv(one_range, two_range))
+			return 0;
+		NEXT_PTR_LIST(one_range);
+		NEXT_PTR_LIST(two_range);
+	}
+	FINISH_PTR_LIST(two_range);
+	FINISH_PTR_LIST(one_range);
+
+	return 1;
+}
+
+int true_comparison_range(struct data_range *left, int comparison, struct data_range *right)
+{
+	switch (comparison) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+		if (sval_cmp(left->min, right->max) < 0)
+			return 1;
+		return 0;
+	case SPECIAL_UNSIGNED_LTE:
+	case SPECIAL_LTE:
+		if (sval_cmp(left->min, right->max) <= 0)
+			return 1;
+		return 0;
+	case SPECIAL_EQUAL:
+		if (sval_cmp(left->max, right->min) < 0)
+			return 0;
+		if (sval_cmp(left->min, right->max) > 0)
+			return 0;
+		return 1;
+	case SPECIAL_UNSIGNED_GTE:
+	case SPECIAL_GTE:
+		if (sval_cmp(left->max, right->min) >= 0)
+			return 1;
+		return 0;
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+		if (sval_cmp(left->max, right->min) > 0)
+			return 1;
+		return 0;
+	case SPECIAL_NOTEQUAL:
+		if (sval_cmp(left->min, left->max) != 0)
+			return 1;
+		if (sval_cmp(right->min, right->max) != 0)
+			return 1;
+		if (sval_cmp(left->min, right->min) != 0)
+			return 1;
+		return 0;
+	default:
+		sm_perror("unhandled comparison %d", comparison);
+		return 0;
+	}
+	return 0;
+}
+
+int true_comparison_range_LR(int comparison, struct data_range *var, struct data_range *val, int left)
+{
+	if (left)
+		return true_comparison_range(var, comparison, val);
+	else
+		return true_comparison_range(val, comparison, var);
+}
+
+static int false_comparison_range_sval(struct data_range *left, int comparison, struct data_range *right)
+{
+	switch (comparison) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+		if (sval_cmp(left->max, right->min) >= 0)
+			return 1;
+		return 0;
+	case SPECIAL_UNSIGNED_LTE:
+	case SPECIAL_LTE:
+		if (sval_cmp(left->max, right->min) > 0)
+			return 1;
+		return 0;
+	case SPECIAL_EQUAL:
+		if (sval_cmp(left->min, left->max) != 0)
+			return 1;
+		if (sval_cmp(right->min, right->max) != 0)
+			return 1;
+		if (sval_cmp(left->min, right->min) != 0)
+			return 1;
+		return 0;
+	case SPECIAL_UNSIGNED_GTE:
+	case SPECIAL_GTE:
+		if (sval_cmp(left->min, right->max) < 0)
+			return 1;
+		return 0;
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+		if (sval_cmp(left->min, right->max) <= 0)
+			return 1;
+		return 0;
+	case SPECIAL_NOTEQUAL:
+		if (sval_cmp(left->max, right->min) < 0)
+			return 0;
+		if (sval_cmp(left->min, right->max) > 0)
+			return 0;
+		return 1;
+	default:
+		sm_perror("unhandled comparison %d", comparison);
+		return 0;
+	}
+	return 0;
+}
+
+int false_comparison_range_LR(int comparison, struct data_range *var, struct data_range *val, int left)
+{
+	if (left)
+		return false_comparison_range_sval(var, comparison, val);
+	else
+		return false_comparison_range_sval(val, comparison, var);
+}
+
+int possibly_true(struct expression *left, int comparison, struct expression *right)
+{
+	struct range_list *rl_left, *rl_right;
+	struct data_range *tmp_left, *tmp_right;
+	struct symbol *type;
+
+	if (!get_implied_rl(left, &rl_left))
+		return 1;
+	if (!get_implied_rl(right, &rl_right))
+		return 1;
+
+	type = rl_type(rl_left);
+	if (type_positive_bits(type) < type_positive_bits(rl_type(rl_right)))
+		type = rl_type(rl_right);
+	if (type_positive_bits(type) < 31)
+		type = &int_ctype;
+
+	rl_left = cast_rl(type, rl_left);
+	rl_right = cast_rl(type, rl_right);
+
+	FOR_EACH_PTR(rl_left, tmp_left) {
+		FOR_EACH_PTR(rl_right, tmp_right) {
+			if (true_comparison_range(tmp_left, comparison, tmp_right))
+				return 1;
+		} END_FOR_EACH_PTR(tmp_right);
+	} END_FOR_EACH_PTR(tmp_left);
+	return 0;
+}
+
+int possibly_false(struct expression *left, int comparison, struct expression *right)
+{
+	struct range_list *rl_left, *rl_right;
+	struct data_range *tmp_left, *tmp_right;
+	struct symbol *type;
+
+	if (!get_implied_rl(left, &rl_left))
+		return 1;
+	if (!get_implied_rl(right, &rl_right))
+		return 1;
+
+	type = rl_type(rl_left);
+	if (type_positive_bits(type) < type_positive_bits(rl_type(rl_right)))
+		type = rl_type(rl_right);
+	if (type_positive_bits(type) < 31)
+		type = &int_ctype;
+
+	rl_left = cast_rl(type, rl_left);
+	rl_right = cast_rl(type, rl_right);
+
+	FOR_EACH_PTR(rl_left, tmp_left) {
+		FOR_EACH_PTR(rl_right, tmp_right) {
+			if (false_comparison_range_sval(tmp_left, comparison, tmp_right))
+				return 1;
+		} END_FOR_EACH_PTR(tmp_right);
+	} END_FOR_EACH_PTR(tmp_left);
+	return 0;
+}
+
+int possibly_true_rl(struct range_list *left_ranges, int comparison, struct range_list *right_ranges)
+{
+	struct data_range *left_tmp, *right_tmp;
+	struct symbol *type;
+
+	if (!left_ranges || !right_ranges)
+		return 1;
+
+	type = rl_type(left_ranges);
+	if (type_positive_bits(type) < type_positive_bits(rl_type(right_ranges)))
+		type = rl_type(right_ranges);
+	if (type_positive_bits(type) < 31)
+		type = &int_ctype;
+
+	left_ranges = cast_rl(type, left_ranges);
+	right_ranges = cast_rl(type, right_ranges);
+
+	FOR_EACH_PTR(left_ranges, left_tmp) {
+		FOR_EACH_PTR(right_ranges, right_tmp) {
+			if (true_comparison_range(left_tmp, comparison, right_tmp))
+				return 1;
+		} END_FOR_EACH_PTR(right_tmp);
+	} END_FOR_EACH_PTR(left_tmp);
+	return 0;
+}
+
+int possibly_false_rl(struct range_list *left_ranges, int comparison, struct range_list *right_ranges)
+{
+	struct data_range *left_tmp, *right_tmp;
+	struct symbol *type;
+
+	if (!left_ranges || !right_ranges)
+		return 1;
+
+	type = rl_type(left_ranges);
+	if (type_positive_bits(type) < type_positive_bits(rl_type(right_ranges)))
+		type = rl_type(right_ranges);
+	if (type_positive_bits(type) < 31)
+		type = &int_ctype;
+
+	left_ranges = cast_rl(type, left_ranges);
+	right_ranges = cast_rl(type, right_ranges);
+
+	FOR_EACH_PTR(left_ranges, left_tmp) {
+		FOR_EACH_PTR(right_ranges, right_tmp) {
+			if (false_comparison_range_sval(left_tmp, comparison, right_tmp))
+				return 1;
+		} END_FOR_EACH_PTR(right_tmp);
+	} END_FOR_EACH_PTR(left_tmp);
+	return 0;
+}
+
+/* FIXME: the _rl here stands for right left so really it should be _lr */
+int possibly_true_rl_LR(int comparison, struct range_list *a, struct range_list *b, int left)
+{
+	if (left)
+		return possibly_true_rl(a, comparison, b);
+	else
+		return possibly_true_rl(b, comparison, a);
+}
+
+int possibly_false_rl_LR(int comparison, struct range_list *a, struct range_list *b, int left)
+{
+	if (left)
+		return possibly_false_rl(a, comparison, b);
+	else
+		return possibly_false_rl(b, comparison, a);
+}
+
+int rl_has_sval(struct range_list *rl, sval_t sval)
+{
+	struct data_range *tmp;
+
+	FOR_EACH_PTR(rl, tmp) {
+		if (sval_cmp(tmp->min, sval) <= 0 &&
+		    sval_cmp(tmp->max, sval) >= 0)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+void tack_on(struct range_list **list, struct data_range *drange)
+{
+	add_ptr_list(list, drange);
+}
+
+void push_rl(struct range_list_stack **rl_stack, struct range_list *rl)
+{
+	add_ptr_list(rl_stack, rl);
+}
+
+struct range_list *pop_rl(struct range_list_stack **rl_stack)
+{
+	struct range_list *rl;
+
+	rl = last_ptr_list((struct ptr_list *)*rl_stack);
+	delete_ptr_list_last((struct ptr_list **)rl_stack);
+	return rl;
+}
+
+struct range_list *top_rl(struct range_list_stack *rl_stack)
+{
+	struct range_list *rl;
+
+	rl = last_ptr_list((struct ptr_list *)rl_stack);
+	return rl;
+}
+
+void filter_top_rl(struct range_list_stack **rl_stack, struct range_list *filter)
+{
+	struct range_list *rl;
+
+	rl = pop_rl(rl_stack);
+	rl = rl_filter(rl, filter);
+	push_rl(rl_stack, rl);
+}
+
+struct range_list *rl_truncate_cast(struct symbol *type, struct range_list *rl)
+{
+	struct data_range *tmp;
+	struct range_list *ret = NULL;
+	sval_t min, max;
+
+	if (!rl)
+		return NULL;
+
+	if (!type || type == rl_type(rl))
+		return rl;
+
+	FOR_EACH_PTR(rl, tmp) {
+		min = tmp->min;
+		max = tmp->max;
+		if (type_bits(type) < type_bits(rl_type(rl))) {
+			min.uvalue = tmp->min.uvalue & ((1ULL << type_bits(type)) - 1);
+			max.uvalue = tmp->max.uvalue & ((1ULL << type_bits(type)) - 1);
+		}
+		if (sval_cmp(min, max) > 0) {
+			min = sval_cast(type, min);
+			max = sval_cast(type, max);
+		}
+		add_range_t(type, &ret, min, max);
+	} END_FOR_EACH_PTR(tmp);
+
+	return ret;
+}
+
+static int rl_is_sane(struct range_list *rl)
+{
+	struct data_range *tmp;
+	struct symbol *type;
+
+	type = rl_type(rl);
+	FOR_EACH_PTR(rl, tmp) {
+		if (!sval_fits(type, tmp->min))
+			return 0;
+		if (!sval_fits(type, tmp->max))
+			return 0;
+		if (sval_cmp(tmp->min, tmp->max) > 0)
+			return 0;
+	} END_FOR_EACH_PTR(tmp);
+
+	return 1;
+}
+
+static int rl_type_consistent(struct range_list *rl)
+{
+	struct data_range *tmp;
+	struct symbol *type;
+
+	type = rl_type(rl);
+	FOR_EACH_PTR(rl, tmp) {
+		if (type != tmp->min.type || type != tmp->max.type)
+			return 0;
+	} END_FOR_EACH_PTR(tmp);
+	return 1;
+}
+
+static struct range_list *cast_to_bool(struct range_list *rl)
+{
+	struct data_range *tmp;
+	struct range_list *ret = NULL;
+	int has_one = 0;
+	int has_zero = 0;
+	sval_t min = { .type = &bool_ctype };
+	sval_t max = { .type = &bool_ctype };
+
+	FOR_EACH_PTR(rl, tmp) {
+		if (tmp->min.value || tmp->max.value)
+			has_one = 1;
+		if (sval_is_negative(tmp->min) &&
+		    sval_is_negative(tmp->max))
+			continue;
+		if (tmp->min.value == 0 ||
+		    tmp->max.value == 0)
+			has_zero = 1;
+		if (sval_is_negative(tmp->min) &&
+		    tmp->max.value > 0)
+			has_zero = 1;
+	} END_FOR_EACH_PTR(tmp);
+
+	if (!has_zero)
+		min.value = 1;
+	if (has_one)
+		max.value = 1;
+
+	add_range(&ret, min, max);
+	return ret;
+}
+
+struct range_list *cast_rl(struct symbol *type, struct range_list *rl)
+{
+	struct data_range *tmp;
+	struct range_list *ret = NULL;
+
+	if (!rl)
+		return NULL;
+
+	if (!type)
+		return rl;
+	if (!rl_is_sane(rl))
+		return alloc_whole_rl(type);
+	if (type == rl_type(rl) && rl_type_consistent(rl))
+		return rl;
+
+	if (type == &bool_ctype)
+		return cast_to_bool(rl);
+
+	FOR_EACH_PTR(rl, tmp) {
+		add_range_t(type, &ret, tmp->min, tmp->max);
+	} END_FOR_EACH_PTR(tmp);
+
+	if (!ret)
+		return alloc_whole_rl(type);
+
+	return ret;
+}
+
+struct range_list *rl_invert(struct range_list *orig)
+{
+	struct range_list *ret = NULL;
+	struct data_range *tmp;
+	sval_t gap_min, abs_max, sval;
+
+	if (!orig)
+		return NULL;
+	if (type_bits(rl_type(orig)) < 0)  /* void type mostly */
+		return NULL;
+
+	gap_min = sval_type_min(rl_min(orig).type);
+	abs_max = sval_type_max(rl_max(orig).type);
+
+	FOR_EACH_PTR(orig, tmp) {
+		if (sval_cmp(tmp->min, gap_min) > 0) {
+			sval = sval_type_val(tmp->min.type, tmp->min.value - 1);
+			add_range(&ret, gap_min, sval);
+		}
+		if (sval_cmp(tmp->max, abs_max) == 0)
+			return ret;
+		gap_min = sval_type_val(tmp->max.type, tmp->max.value + 1);
+	} END_FOR_EACH_PTR(tmp);
+
+	if (sval_cmp(gap_min, abs_max) <= 0)
+		add_range(&ret, gap_min, abs_max);
+
+	return ret;
+}
+
+struct range_list *rl_filter(struct range_list *rl, struct range_list *filter)
+{
+	struct data_range *tmp;
+
+	FOR_EACH_PTR(filter, tmp) {
+		rl = remove_range(rl, tmp->min, tmp->max);
+	} END_FOR_EACH_PTR(tmp);
+
+	return rl;
+}
+
+struct range_list *rl_intersection(struct range_list *one, struct range_list *two)
+{
+	struct range_list *one_orig;
+	struct range_list *two_orig;
+	struct range_list *ret;
+	struct symbol *ret_type;
+	struct symbol *small_type;
+	struct symbol *large_type;
+
+	if (!two)
+		return NULL;
+	if (!one)
+		return NULL;
+
+	one_orig = one;
+	two_orig = two;
+
+	ret_type = rl_type(one);
+	small_type = rl_type(one);
+	large_type = rl_type(two);
+
+	if (type_bits(rl_type(two)) < type_bits(small_type)) {
+		small_type = rl_type(two);
+		large_type = rl_type(one);
+	}
+
+	one = cast_rl(large_type, one);
+	two = cast_rl(large_type, two);
+
+	ret = one;
+	one = rl_invert(one);
+	two = rl_invert(two);
+
+	ret = rl_filter(ret, one);
+	ret = rl_filter(ret, two);
+
+	one = cast_rl(small_type, one_orig);
+	two = cast_rl(small_type, two_orig);
+
+	one = rl_invert(one);
+	two = rl_invert(two);
+
+	ret = cast_rl(small_type, ret);
+	ret = rl_filter(ret, one);
+	ret = rl_filter(ret, two);
+
+	return cast_rl(ret_type, ret);
+}
+
+static struct range_list *handle_mod_rl(struct range_list *left, struct range_list *right)
+{
+	sval_t zero;
+	sval_t max;
+
+	max = rl_max(right);
+	if (sval_is_max(max))
+		return left;
+	if (max.value == 0)
+		return NULL;
+	max.value--;
+	if (sval_is_negative(max))
+		return NULL;
+	if (sval_cmp(rl_max(left), max) < 0)
+		return left;
+	zero = max;
+	zero.value = 0;
+	return alloc_rl(zero, max);
+}
+
+static struct range_list *get_neg_rl(struct range_list *rl)
+{
+	struct data_range *tmp;
+	struct data_range *new;
+	struct range_list *ret = NULL;
+
+	if (!rl)
+		return NULL;
+	if (sval_is_positive(rl_min(rl)))
+		return NULL;
+
+	FOR_EACH_PTR(rl, tmp) {
+		if (sval_is_positive(tmp->min))
+			break;
+		if (sval_is_positive(tmp->max)) {
+			new = alloc_range(tmp->min, tmp->max);
+			new->max.value = -1;
+			add_range(&ret, new->min, new->max);
+			break;
+		}
+		add_range(&ret, tmp->min, tmp->max);
+	} END_FOR_EACH_PTR(tmp);
+
+	return ret;
+}
+
+static struct range_list *get_pos_rl(struct range_list *rl)
+{
+	struct data_range *tmp;
+	struct data_range *new;
+	struct range_list *ret = NULL;
+
+	if (!rl)
+		return NULL;
+	if (sval_is_negative(rl_max(rl)))
+		return NULL;
+
+	FOR_EACH_PTR(rl, tmp) {
+		if (sval_is_negative(tmp->max))
+			continue;
+		if (sval_is_positive(tmp->min)) {
+			add_range(&ret, tmp->min, tmp->max);
+			continue;
+		}
+		new = alloc_range(tmp->min, tmp->max);
+		new->min.value = 0;
+		add_range(&ret, new->min, new->max);
+	} END_FOR_EACH_PTR(tmp);
+
+	return ret;
+}
+
+static struct range_list *divide_rl_helper(struct range_list *left, struct range_list *right)
+{
+	sval_t right_min, right_max;
+	sval_t min, max;
+
+	if (!left || !right)
+		return NULL;
+
+	/* let's assume we never divide by zero */
+	right_min = rl_min(right);
+	right_max = rl_max(right);
+	if (right_min.value == 0 && right_max.value == 0)
+		return NULL;
+	if (right_min.value == 0)
+		right_min.value = 1;
+	if (right_max.value == 0)
+		right_max.value = -1;
+
+	max = sval_binop(rl_max(left), '/', right_min);
+	min = sval_binop(rl_min(left), '/', right_max);
+
+	return alloc_rl(min, max);
+}
+
+static struct range_list *handle_divide_rl(struct range_list *left, struct range_list *right)
+{
+	struct range_list *left_neg, *left_pos, *right_neg, *right_pos;
+	struct range_list *neg_neg, *neg_pos, *pos_neg, *pos_pos;
+	struct range_list *ret;
+
+	if (is_whole_rl(right))
+		return NULL;
+
+	left_neg = get_neg_rl(left);
+	left_pos = get_pos_rl(left);
+	right_neg = get_neg_rl(right);
+	right_pos = get_pos_rl(right);
+
+	neg_neg = divide_rl_helper(left_neg, right_neg);
+	neg_pos = divide_rl_helper(left_neg, right_pos);
+	pos_neg = divide_rl_helper(left_pos, right_neg);
+	pos_pos = divide_rl_helper(left_pos, right_pos);
+
+	ret = rl_union(neg_neg, neg_pos);
+	ret = rl_union(ret, pos_neg);
+	return rl_union(ret, pos_pos);
+}
+
+static struct range_list *handle_add_mult_rl(struct range_list *left, int op, struct range_list *right)
+{
+	sval_t min, max;
+
+	if (sval_binop_overflows(rl_min(left), op, rl_min(right)))
+		return NULL;
+	min = sval_binop(rl_min(left), op, rl_min(right));
+
+	if (sval_binop_overflows(rl_max(left), op, rl_max(right)))
+		return NULL;
+	max = sval_binop(rl_max(left), op, rl_max(right));
+
+	return alloc_rl(min, max);
+}
+
+static struct range_list *handle_sub_rl(struct range_list *left_orig, struct range_list *right_orig)
+{
+	struct range_list *left_rl, *right_rl;
+	struct symbol *type;
+	sval_t min, max;
+	sval_t min_ll, max_ll, res_ll;
+	sval_t tmp;
+
+	/* TODO:  These things should totally be using dranges where possible */
+
+	if (!left_orig || !right_orig)
+		return NULL;
+
+	type = &int_ctype;
+	if (type_positive_bits(rl_type(left_orig)) > type_positive_bits(type))
+		type = rl_type(left_orig);
+	if (type_positive_bits(rl_type(right_orig)) > type_positive_bits(type))
+		type = rl_type(right_orig);
+
+	left_rl = cast_rl(type, left_orig);
+	right_rl = cast_rl(type, right_orig);
+
+	max = rl_max(left_rl);
+	min = sval_type_min(type);
+
+	min_ll = rl_min(left_rl);
+	min_ll.type = &llong_ctype;
+	max_ll = rl_max(right_rl);
+	max_ll.type = &llong_ctype;
+	res_ll = min_ll;
+	res_ll.value = min_ll.value - max_ll.value;
+
+	if (!sval_binop_overflows(rl_min(left_rl), '-', rl_max(right_rl))) {
+		tmp = sval_binop(rl_min(left_rl), '-', rl_max(right_rl));
+		if (sval_cmp(tmp, min) > 0)
+			min = tmp;
+	} else if (type_positive_bits(type) < 63 &&
+		   !sval_binop_overflows(min_ll, '-', max_ll) &&
+		   (min.value != 0 && sval_cmp(res_ll, min) >= 0)) {
+		struct range_list *left_casted, *right_casted, *result;
+
+		left_casted = cast_rl(&llong_ctype, left_orig);
+		right_casted = cast_rl(&llong_ctype, right_orig);
+		result = handle_sub_rl(left_casted, right_casted);
+		return cast_rl(type, result);
+	}
+
+	if (!sval_is_max(rl_max(left_rl))) {
+		tmp = sval_binop(rl_max(left_rl), '-', rl_min(right_rl));
+		if (sval_cmp(tmp, max) < 0)
+			max = tmp;
+	}
+
+	if (sval_is_min(min) && sval_is_max(max))
+		return NULL;
+
+	return alloc_rl(min, max);
+}
+
+static unsigned long long rl_bits_always_set(struct range_list *rl)
+{
+	return sval_fls_mask(rl_min(rl));
+}
+
+static unsigned long long rl_bits_maybe_set(struct range_list *rl)
+{
+	return sval_fls_mask(rl_max(rl));
+}
+
+static struct range_list *handle_OR_rl(struct range_list *left, struct range_list *right)
+{
+	unsigned long long left_min, left_max, right_min, right_max;
+	sval_t min, max;
+	sval_t sval;
+
+	if ((rl_to_sval(left, &sval) || rl_to_sval(right, &sval)) &&
+	    !sval_binop_overflows(rl_max(left), '+', rl_max(right)))
+		return rl_binop(left, '+', right);
+
+	left_min = rl_bits_always_set(left);
+	left_max = rl_bits_maybe_set(left);
+	right_min = rl_bits_always_set(right);
+	right_max = rl_bits_maybe_set(right);
+
+	min.type = max.type = &ullong_ctype;
+	min.uvalue = left_min | right_min;
+	max.uvalue = left_max | right_max;
+
+	return cast_rl(rl_type(left), alloc_rl(min, max));
+}
+
+static struct range_list *handle_XOR_rl(struct range_list *left, struct range_list *right)
+{
+	unsigned long long left_set, left_maybe;
+	unsigned long long right_set, right_maybe;
+	sval_t zero, max;
+
+	left_set = rl_bits_always_set(left);
+	left_maybe = rl_bits_maybe_set(left);
+
+	right_set = rl_bits_always_set(right);
+	right_maybe = rl_bits_maybe_set(right);
+
+	zero = max = rl_min(left);
+	zero.uvalue = 0;
+	max.uvalue = fls_mask((left_maybe | right_maybe) ^ (left_set & right_set));
+
+	return cast_rl(rl_type(left), alloc_rl(zero, max));
+}
+
+static struct range_list *handle_AND_rl(struct range_list *left, struct range_list *right)
+{
+	unsigned long long left_set, left_maybe;
+	unsigned long long right_set, right_maybe;
+	sval_t zero, max;
+
+	return NULL;
+
+	left_set = rl_bits_always_set(left);
+	left_maybe = rl_bits_maybe_set(left);
+
+	right_set = rl_bits_always_set(right);
+	right_maybe = rl_bits_maybe_set(right);
+
+	zero = max = rl_min(left);
+	zero.uvalue = 0;
+	max.uvalue = fls_mask((left_maybe | right_maybe) ^ (left_set & right_set));
+
+	return cast_rl(rl_type(left), alloc_rl(zero, max));
+}
+
+struct range_list *rl_binop(struct range_list *left, int op, struct range_list *right)
+{
+	struct symbol *cast_type;
+	sval_t left_sval, right_sval;
+	struct range_list *ret = NULL;
+
+	cast_type = rl_type(left);
+	if (sval_type_max(rl_type(left)).uvalue < sval_type_max(rl_type(right)).uvalue)
+		cast_type = rl_type(right);
+	if (sval_type_max(cast_type).uvalue < INT_MAX)
+		cast_type = &int_ctype;
+
+	left = cast_rl(cast_type, left);
+	right = cast_rl(cast_type, right);
+
+	if (!left && !right)
+		return NULL;
+
+	if (rl_to_sval(left, &left_sval) && rl_to_sval(right, &right_sval)) {
+		sval_t val = sval_binop(left_sval, op, right_sval);
+		return alloc_rl(val, val);
+	}
+
+	switch (op) {
+	case '%':
+		ret = handle_mod_rl(left, right);
+		break;
+	case '/':
+		ret = handle_divide_rl(left, right);
+		break;
+	case '*':
+	case '+':
+		ret = handle_add_mult_rl(left, op, right);
+		break;
+	case '|':
+		ret = handle_OR_rl(left, right);
+		break;
+	case '^':
+		ret = handle_XOR_rl(left, right);
+		break;
+	case '&':
+		ret = handle_AND_rl(left, right);
+		break;
+	case '-':
+		ret = handle_sub_rl(left, right);
+		break;
+	/* FIXME:  Do the rest as well */
+	case SPECIAL_RIGHTSHIFT:
+	case SPECIAL_LEFTSHIFT:
+		break;
+	}
+
+	return ret;
+}
+
+void free_data_info_allocs(void)
+{
+	struct allocator_struct *desc = &data_info_allocator;
+	struct allocation_blob *blob = desc->blobs;
+
+	free_all_rl();
+	clear_math_cache();
+
+	desc->blobs = NULL;
+	desc->allocations = 0;
+	desc->total_bytes = 0;
+	desc->useful_bytes = 0;
+	desc->freelist = NULL;
+	while (blob) {
+		struct allocation_blob *next = blob->next;
+		blob_free(blob, desc->chunking);
+		blob = next;
+	}
+	clear_data_range_alloc();
+}
+
+void split_comparison_rl(struct range_list *left_orig, int op, struct range_list *right_orig,
+		struct range_list **left_true_rl, struct range_list **left_false_rl,
+		struct range_list **right_true_rl, struct range_list **right_false_rl)
+{
+	struct range_list *left_true, *left_false;
+	struct range_list *right_true, *right_false;
+	sval_t min, max;
+
+	min = sval_type_min(rl_type(left_orig));
+	max = sval_type_max(rl_type(left_orig));
+
+	left_true = clone_rl(left_orig);
+	left_false = clone_rl(left_orig);
+	right_true = clone_rl(right_orig);
+	right_false = clone_rl(right_orig);
+
+	switch (op) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+		left_true = remove_range(left_orig, rl_max(right_orig), max);
+		if (!sval_is_min(rl_min(right_orig))) {
+			left_false = remove_range(left_orig, min, sub_one(rl_min(right_orig)));
+		}
+
+		right_true = remove_range(right_orig, min, rl_min(left_orig));
+		if (!sval_is_max(rl_max(left_orig)))
+			right_false = remove_range(right_orig, add_one(rl_max(left_orig)), max);
+		break;
+	case SPECIAL_UNSIGNED_LTE:
+	case SPECIAL_LTE:
+		if (!sval_is_max(rl_max(right_orig)))
+			left_true = remove_range(left_orig, add_one(rl_max(right_orig)), max);
+		left_false = remove_range(left_orig, min, rl_min(right_orig));
+
+		if (!sval_is_min(rl_min(left_orig)))
+			right_true = remove_range(right_orig, min, sub_one(rl_min(left_orig)));
+		right_false = remove_range(right_orig, rl_max(left_orig), max);
+
+		if (sval_cmp(rl_min(left_orig), rl_min(right_orig)) == 0)
+			left_false = remove_range(left_false, rl_min(left_orig), rl_min(left_orig));
+		if (sval_cmp(rl_max(left_orig), rl_max(right_orig)) == 0)
+			right_false = remove_range(right_false, rl_max(left_orig), rl_max(left_orig));
+		break;
+	case SPECIAL_EQUAL:
+		left_true = rl_intersection(left_orig, right_orig);
+		right_true = clone_rl(left_true);
+
+		if (sval_cmp(rl_min(right_orig), rl_max(right_orig)) == 0)
+			left_false = remove_range(left_orig, rl_min(right_orig), rl_min(right_orig));
+		if (sval_cmp(rl_min(left_orig), rl_max(left_orig)) == 0)
+			right_false = remove_range(right_orig, rl_min(left_orig), rl_min(left_orig));
+		break;
+	case SPECIAL_UNSIGNED_GTE:
+	case SPECIAL_GTE:
+		if (!sval_is_min(rl_min(right_orig)))
+			left_true = remove_range(left_orig, min, sub_one(rl_min(right_orig)));
+		left_false = remove_range(left_orig, rl_max(right_orig), max);
+
+		if (!sval_is_max(rl_max(left_orig)))
+			right_true = remove_range(right_orig, add_one(rl_max(left_orig)), max);
+		right_false = remove_range(right_orig, min, rl_min(left_orig));
+
+		if (sval_cmp(rl_min(left_orig), rl_min(right_orig)) == 0)
+			right_false = remove_range(right_false, rl_min(left_orig), rl_min(left_orig));
+		if (sval_cmp(rl_max(left_orig), rl_max(right_orig)) == 0)
+			left_false = remove_range(left_false, rl_max(left_orig), rl_max(left_orig));
+		break;
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+		left_true = remove_range(left_orig, min, rl_min(right_orig));
+		if (!sval_is_max(rl_max(right_orig)))
+			left_false = remove_range(left_orig, add_one(rl_max(right_orig)), max);
+
+		right_true = remove_range(right_orig, rl_max(left_orig), max);
+		if (!sval_is_min(rl_min(left_orig)))
+			right_false = remove_range(right_orig, min, sub_one(rl_min(left_orig)));
+		break;
+	case SPECIAL_NOTEQUAL:
+		left_false = rl_intersection(left_orig, right_orig);
+		right_false = clone_rl(left_false);
+
+		if (sval_cmp(rl_min(right_orig), rl_max(right_orig)) == 0)
+			left_true = remove_range(left_orig, rl_min(right_orig), rl_min(right_orig));
+		if (sval_cmp(rl_min(left_orig), rl_max(left_orig)) == 0)
+			right_true = remove_range(right_orig, rl_min(left_orig), rl_min(left_orig));
+		break;
+	default:
+		sm_perror(" unhandled comparison %d", op);
+		return;
+	}
+
+	if (left_true_rl) {
+		*left_true_rl = left_true;
+		*left_false_rl = left_false;
+	}
+	if (right_true_rl) {
+		*right_true_rl = right_true;
+		*right_false_rl = right_false;
+	}
+}
diff --git a/usr/src/tools/smatch/src/smatch_real_absolute.c b/usr/src/tools/smatch/src/smatch_real_absolute.c
new file mode 100644
index 0000000000..96cf6b4aa7
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_real_absolute.c
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2015 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Say we have a line like:
+ * foo = bar / 8;
+ * Assume we don't know anything about bar.  Well, now we know that foo is less
+ * than UINT_MAX / 8.  Which might be useful, but it probably is misleading
+ * useless knowledge.  Up to now we have ignored those but now we have said to
+ * store them.
+ *
+ * It also works if you have something like "foo = (int)(char)unknown_var;".
+ *
+ * I feel like this data doesn't have to be perfect, it just has to be better
+ * than nothing and that will help eliminate some false positives.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static void pre_merge_hook(struct sm_state *sm)
+{
+	struct smatch_state *abs;
+	struct smatch_state *extra;
+	struct range_list *rl;
+
+	extra = get_state(SMATCH_EXTRA, sm->name, sm->sym);
+	if (!extra || !estate_rl(extra))
+		return;
+	abs = get_state(my_id, sm->name, sm->sym);
+	if (!abs || !estate_rl(abs)) {
+		set_state(my_id, sm->name, sm->sym, clone_estate(extra));
+		return;
+	}
+	rl = rl_intersection(estate_rl(abs), estate_rl(extra));
+	set_state(my_id, sm->name, sm->sym, alloc_estate_rl(clone_rl(rl)));
+}
+
+static struct smatch_state *empty_state(struct sm_state *sm)
+{
+	return alloc_estate_empty();
+}
+
+static void reset(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(my_id, sm->name, sm->sym, alloc_estate_whole(estate_type(sm->state)));
+}
+
+static int in_iterator_pre_statement(void)
+{
+	struct statement *stmt;
+
+	/*
+	 * we can't use __cur_stmt because that isn't set for
+	 * iterator_pre_statement.  Kind of a mess.
+	 *
+	 */
+
+	stmt = last_ptr_list((struct ptr_list *)big_statement_stack);
+
+	if (!stmt || !stmt->parent)
+		return 0;
+	if (stmt->parent->type != STMT_ITERATOR)
+		return 0;
+	if (stmt->parent->iterator_pre_statement != stmt)
+		return 0;
+	return 1;
+}
+
+static void match_assign(struct expression *expr)
+{
+	struct range_list *rl;
+	struct symbol *type;
+	sval_t sval;
+
+	if (expr->op != '=')
+		return;
+	if (is_fake_call(expr->right))
+		return;
+	if (in_iterator_pre_statement())
+		return;
+
+	get_real_absolute_rl(expr->right, &rl);
+
+	type = get_type(expr->left);
+	if (!type)
+		return;
+
+	rl = cast_rl(type, rl);
+	if (is_whole_rl(rl) && !get_state_expr(my_id, expr->left))
+		return;
+	/* These are handled by smatch_extra.c */
+	if (rl_to_sval(rl, &sval) && !get_state_expr(my_id, expr->left))
+		return;
+
+	set_state_expr(my_id, expr->left, alloc_estate_rl(clone_rl(rl)));
+}
+
+struct smatch_state *get_real_absolute_state(struct expression *expr)
+{
+	return get_state_expr(my_id, expr);
+}
+
+struct smatch_state *get_real_absolute_state_var_sym(const char *name, struct symbol *sym)
+{
+	return get_state(my_id, name, sym);
+}
+
+void register_real_absolute(int id)
+{
+	my_id = id;
+
+	add_pre_merge_hook(my_id, &pre_merge_hook);
+	add_unmatched_state_hook(my_id, &empty_state);
+	add_merge_hook(my_id, &merge_estates);
+	add_modification_hook(my_id, &reset);
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_recurse.c b/usr/src/tools/smatch/src/smatch_recurse.c
new file mode 100644
index 0000000000..01ec7168ab
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_recurse.c
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+#define RECURSE_LIMIT 10
+
+static int recurse(struct expression *expr,
+		   int (func)(struct expression *expr, void *p),
+		   void *param, int nr)
+{
+	int ret;
+
+	if (!expr)
+		return 0;
+
+	ret = func(expr, param);
+	if (ret)
+		return ret;
+
+	if (nr > RECURSE_LIMIT)
+		return -1;
+	nr++;
+
+	switch (expr->type) {
+	case EXPR_PREOP:
+		ret = recurse(expr->unop, func, param, nr);
+		break;
+	case EXPR_POSTOP:
+		ret = recurse(expr->unop, func, param, nr);
+		break;
+	case EXPR_STATEMENT:
+		return -1;
+		break;
+	case EXPR_LOGICAL:
+	case EXPR_COMPARE:
+	case EXPR_BINOP:
+	case EXPR_COMMA:
+		ret = recurse(expr->left, func, param, nr);
+		if (ret)
+			return ret;
+		ret = recurse(expr->right, func, param, nr);
+		break;
+	case EXPR_ASSIGNMENT:
+		ret = recurse(expr->right, func, param, nr);
+		if (ret)
+			return ret;
+		ret = recurse(expr->left, func, param, nr);
+		break;
+	case EXPR_DEREF:
+		ret = recurse(expr->deref, func, param, nr);
+		break;
+	case EXPR_SLICE:
+		ret = recurse(expr->base, func, param, nr);
+		break;
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+		ret = recurse(expr->cast_expression, func, param, nr);
+		break;
+	case EXPR_SIZEOF:
+	case EXPR_OFFSETOF:
+	case EXPR_ALIGNOF:
+		break;
+	case EXPR_CONDITIONAL:
+	case EXPR_SELECT:
+		ret = recurse(expr->conditional, func, param, nr);
+		if (ret)
+			return ret;
+		ret = recurse(expr->cond_true, func, param, nr);
+		if (ret)
+			return ret;
+		ret = recurse(expr->cond_false, func, param, nr);
+		break;
+	case EXPR_CALL:
+		return -1;
+		break;
+	case EXPR_INITIALIZER:
+		return -1;
+		break;
+	case EXPR_IDENTIFIER:
+		ret = recurse(expr->ident_expression, func, param, nr);
+		break;
+	case EXPR_INDEX:
+		ret = recurse(expr->idx_expression, func, param, nr);
+		break;
+	case EXPR_POS:
+		ret = recurse(expr->init_expr, func, param, nr);
+		break;
+	case EXPR_SYMBOL:
+	case EXPR_STRING:
+	case EXPR_VALUE:
+		break;
+	default:
+		return -1;
+		break;
+	};
+	return ret;
+}
+
+static int has_symbol_helper(struct expression *expr, void *_sym)
+{
+	struct symbol *sym = _sym;
+
+	if (!expr || expr->type != EXPR_SYMBOL)
+		return 0;
+	if (expr->symbol == sym)
+		return 1;
+	return 0;
+}
+
+int has_symbol(struct expression *expr, struct symbol *sym)
+{
+	return recurse(expr, has_symbol_helper, sym, 0);
+}
+
+struct expr_name_sym {
+	struct expression *expr;
+	char *name;
+	struct symbol *sym;
+};
+
+static int has_var_helper(struct expression *expr, void *_var)
+{
+	struct expr_name_sym *xns = _var;
+	char *name;
+	struct symbol *sym;
+	int matched = 0;
+
+	if (!expr)
+		return 0;
+	if (expr->type != xns->expr->type)
+		return 0;
+	// I hope this is defined for everything?  It should work, right?
+	if (expr->op != xns->expr->op)
+		return 0;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	if (sym == xns->sym && strcmp(name, xns->name) == 0)
+		matched = 1;
+free:
+	free_string(name);
+	return matched;
+}
+
+int has_variable(struct expression *expr, struct expression *var)
+{
+	struct expr_name_sym xns;
+	int ret = -1;
+
+	xns.expr = var;
+	xns.name = expr_to_var_sym(var, &xns.sym);
+	if (!xns.name || !xns.sym)
+		goto free;
+	ret = recurse(expr, has_var_helper, &xns, 0);
+free:
+	free_string(xns.name);
+	return ret;
+}
+
+static int has_inc_dec_helper(struct expression *expr, void *unused)
+{
+	if (!expr)
+		return 0;
+	if (expr->type != EXPR_PREOP && expr->type != EXPR_POSTOP)
+		return 0;
+	if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
+		return 1;
+	return 0;
+}
+
+int has_inc_dec(struct expression *expr)
+{
+	return recurse(expr, has_inc_dec_helper, NULL, 0);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_return_to_param.c b/usr/src/tools/smatch/src/smatch_return_to_param.c
new file mode 100644
index 0000000000..220d24f1f9
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_return_to_param.c
@@ -0,0 +1,291 @@
+/*
+ * Copyright (C) 2017 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This is for smatch_extra.c to use.  It sort of like check_assigned_expr.c but
+ * more limited.  Say a function returns "64min-s64max[$0->data]" and the caller
+ * does "struct whatever *p = get_data(dev);" then we want to record that p is
+ * now the same as "dev->data".  Then if we update "p->foo" it means we can
+ * update "dev->data->foo" as well.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+extern int check_assigned_expr_id;
+static int my_id;
+static int link_id;
+
+static struct smatch_state *alloc_my_state(const char *name, struct symbol *sym)
+{
+	struct smatch_state *state;
+
+	state = __alloc_smatch_state(0);
+	state->name = alloc_sname(name);
+	state->data = sym;
+	return state;
+}
+
+static void undef(struct sm_state *sm, struct expression *mod_expr)
+{
+	if (__in_fake_parameter_assign)
+		return;
+	set_state(my_id, sm->name, sm->sym, &undefined);
+}
+
+char *map_call_to_other_name_sym(const char *name, struct symbol *sym, struct symbol **new_sym)
+{
+	struct smatch_state *state;
+	int skip;
+	char buf[256];
+
+	/* skip 'foo->'.  This was checked in the caller. */
+	skip = strlen(sym->ident->name) + 2;
+
+	state = get_state(my_id, sym->ident->name, sym);
+	if (!state || !state->data)
+		return NULL;
+
+	snprintf(buf, sizeof(buf), "%s->%s", state->name, name + skip);
+	*new_sym = state->data;
+	return alloc_string(buf);
+}
+
+static char *map_my_state_long_to_short(struct sm_state *sm, const char *name, struct symbol *sym, struct symbol **new_sym, bool stack)
+{
+	int len;
+	char buf[256];
+
+	if (sm->state->data != sym)
+		return NULL;
+	len = strlen(sm->state->name);
+	if (strncmp(name, sm->state->name, len) != 0)
+		return NULL;
+
+	if (name[len] == '.')
+		return NULL;
+	if (!stack && name[len] != '-')
+		return NULL;
+	snprintf(buf, sizeof(buf), "%s%s", sm->name, name + len);
+	*new_sym = sm->sym;
+	return alloc_string(buf);
+}
+
+static char *map_assignment_long_to_short(struct sm_state *sm, const char *name, struct symbol *sym, struct symbol **new_sym, bool stack)
+{
+	struct expression *orig_expr;
+	struct symbol *orig_sym;
+	int len;
+	char buf[256];
+
+	orig_expr = sm->state->data;
+	if (!orig_expr)
+		return NULL;
+
+	/*
+	 * Say we have an assignment like:
+	 *     foo->bar->my_ptr = my_ptr;
+	 * We still expect the function to carry on using "my_ptr" as the
+	 * shorter name.  That's not a long to short mapping.
+	 *
+	 */
+	if (orig_expr->type == EXPR_SYMBOL)
+		return NULL;
+
+	orig_sym = expr_to_sym(orig_expr);
+	if (!orig_sym)
+		return NULL;
+	if (sym != orig_sym)
+		return NULL;
+
+	len = strlen(sm->state->name);
+	if (strncmp(name, sm->state->name, len) != 0)
+		return NULL;
+
+	if (name[len] == '.')
+		return NULL;
+	if (!stack && name[len] != '-')
+		return NULL;
+	snprintf(buf, sizeof(buf), "%s%s", sm->name, name + len);
+	*new_sym = sm->sym;
+	return alloc_string(buf);
+}
+
+/*
+ * Normally, we expect people to consistently refer to variables by the shortest
+ * name.  So they use "b->a" instead of "foo->bar.a" when both point to the
+ * same memory location.  However, when we're dealing across function boundaries
+ * then sometimes we pass frob(foo) which sets foo->bar.a.  In that case, we
+ * translate it to the shorter name.  Smatch extra updates the shorter name,
+ * which in turn updates the longer name.
+ *
+ */
+static char *map_long_to_short_name_sym_helper(const char *name, struct symbol *sym, struct symbol **new_sym, bool stack)
+{
+	char *ret;
+	struct sm_state *sm;
+
+	*new_sym = NULL;
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (sm->owner == my_id) {
+			ret = map_my_state_long_to_short(sm, name, sym, new_sym, stack);
+			if (ret)
+				return ret;
+			continue;
+		}
+		if (sm->owner == check_assigned_expr_id) {
+			ret = map_assignment_long_to_short(sm, name, sym, new_sym, stack);
+			if (ret)
+				return ret;
+			continue;
+		}
+	} END_FOR_EACH_SM(sm);
+
+	return NULL;
+}
+
+char *map_long_to_short_name_sym(const char *name, struct symbol *sym, struct symbol **new_sym)
+{
+	return map_long_to_short_name_sym_helper(name, sym, new_sym, 1);
+}
+
+char *map_long_to_short_name_sym_nostack(const char *name, struct symbol *sym, struct symbol **new_sym)
+{
+	return map_long_to_short_name_sym_helper(name, sym, new_sym, 0);
+}
+
+char *map_call_to_param_name_sym(struct expression *expr, struct symbol **sym)
+{
+	char *name;
+	struct symbol *start_sym;
+	struct smatch_state *state;
+
+	*sym = NULL;
+
+	name = expr_to_str_sym(expr, &start_sym);
+	if (!name)
+		return NULL;
+	if (expr->type == EXPR_CALL)
+		start_sym = expr_to_sym(expr->fn);
+
+	state = get_state(my_id, name, start_sym);
+	free_string(name);
+	if (!state || !state->data)
+		return NULL;
+
+	*sym = state->data;
+	return alloc_string(state->name);
+}
+
+static void store_mapping_helper(char *left_name, struct symbol *left_sym, struct expression *call, const char *return_string)
+{
+	const char *p = return_string;
+	char *close;
+	int param;
+	struct expression *arg, *new;
+	char *right_name;
+	struct symbol *right_sym;
+	char buf[256];
+
+	while (*p && *p != '[')
+		p++;
+	if (!*p)
+		return;
+	p++;
+	if (*p != '$')
+		return;
+
+	snprintf(buf, sizeof(buf), "%s", p);
+	close = strchr(buf, ']');
+	if (!close)
+		return;
+	*close = '\0';
+
+	param = atoi(buf + 1);
+	arg = get_argument_from_call_expr(call->args, param);
+	if (!arg)
+		return;
+
+	new = gen_expression_from_key(arg, buf);
+	if (!new)
+		return;
+
+	right_name = expr_to_var_sym(new, &right_sym);
+	if (!right_name || !right_sym)
+		goto free;
+
+	set_state(my_id, left_name, left_sym, alloc_my_state(right_name, right_sym));
+	store_link(link_id, right_name, right_sym, left_name, left_sym);
+
+free:
+	free_string(right_name);
+}
+
+void __add_return_to_param_mapping(struct expression *expr, const char *return_string)
+{
+	struct expression *call;
+	char *left_name = NULL;
+	struct symbol *left_sym;
+
+	if (expr->type == EXPR_ASSIGNMENT) {
+		left_name = expr_to_var_sym(expr->left, &left_sym);
+		if (!left_name || !left_sym)
+			goto free;
+
+		call = strip_expr(expr->right);
+		if (call->type != EXPR_CALL)
+			goto free;
+
+		store_mapping_helper(left_name, left_sym, call, return_string);
+		goto free;
+	}
+
+	if (expr->type == EXPR_CALL &&
+	    expr_get_parent_stmt(expr) &&
+	    expr_get_parent_stmt(expr)->type == STMT_RETURN) {
+		call = strip_expr(expr);
+		left_sym = expr_to_sym(call->fn);
+		if (!left_sym)
+			return;
+		left_name = expr_to_str(call);
+		if (!left_name)
+			return;
+
+		store_mapping_helper(left_name, left_sym, call, return_string);
+		goto free;
+
+	}
+
+free:
+	free_string(left_name);
+}
+
+void register_return_to_param(int id)
+{
+	my_id = id;
+	add_modification_hook(my_id, &undef);
+}
+
+void register_return_to_param_links(int id)
+{
+	link_id = id;
+	set_up_link_functions(my_id, link_id);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_returns.c b/usr/src/tools/smatch/src/smatch_returns.c
new file mode 100644
index 0000000000..5c7157cf1f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_returns.c
@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2011 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+int RETURN_ID;
+
+struct return_states_callback {
+	void (*callback)(void);
+};
+ALLOCATOR(return_states_callback, "return states callbacks");
+DECLARE_PTR_LIST(callback_list, struct return_states_callback);
+static struct callback_list *callback_list;
+
+DECLARE_PTR_LIST(stree_stack_stack, struct stree_stack);
+static void push_stree_stack(struct stree_stack_stack **stack_stack, struct stree_stack *stack)
+{
+	add_ptr_list(stack_stack, stack);
+}
+
+static struct stree_stack *pop_stree_stack(struct stree_stack_stack **stack_stack)
+{
+	struct stree_stack *stack;
+
+	stack = last_ptr_list((struct ptr_list *)*stack_stack);
+	delete_ptr_list_last((struct ptr_list **)stack_stack);
+	return stack;
+}
+
+static struct stree_stack *return_stree_stack;
+static struct stree_stack_stack *saved_stack_stack;
+static struct stree *all_return_states;
+static struct stree_stack *saved_stack;
+
+void all_return_states_hook(void (*callback)(void))
+{
+	struct return_states_callback *rs_cb = __alloc_return_states_callback(0);
+
+	rs_cb->callback = callback;
+	add_ptr_list(&callback_list, rs_cb);
+}
+
+static void call_hooks(void)
+{
+	struct return_states_callback *rs_cb;
+
+	__set_fake_cur_stree_fast(all_return_states);
+	FOR_EACH_PTR(callback_list, rs_cb) {
+		rs_cb->callback();
+	} END_FOR_EACH_PTR(rs_cb);
+	__pop_fake_cur_stree_fast();
+}
+
+static void match_return(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct stree *stree;
+
+	stree = clone_stree(__get_cur_stree());
+	merge_stree_no_pools(&all_return_states, stree);
+	push_stree(&return_stree_stack, stree);
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	/*
+	 * FIXME: either this isn't needed or we need to copy a stree into the
+	 * return_stree_stack as well.
+	 */
+	merge_stree(&all_return_states, __get_cur_stree());
+	call_hooks();
+}
+
+static void match_save_states(struct expression *expr)
+{
+	push_stree(&saved_stack, all_return_states);
+	all_return_states = NULL;
+
+	push_stree_stack(&saved_stack_stack, return_stree_stack);
+	return_stree_stack = NULL;
+}
+
+static void match_restore_states(struct expression *expr)
+{
+	/* This free_stree() isn't needed is it?? */
+	free_stree(&all_return_states);
+
+	all_return_states = pop_stree(&saved_stack);
+	return_stree_stack = pop_stree_stack(&saved_stack_stack);
+}
+
+struct stree *get_all_return_states(void)
+{
+	return all_return_states;
+}
+
+struct stree_stack *get_all_return_strees(void)
+{
+	return return_stree_stack;
+}
+
+static void free_resources(struct symbol *sym)
+{
+	struct stree *tmp;
+
+	free_stree(&all_return_states);
+
+	FOR_EACH_PTR(return_stree_stack, tmp) {
+		free_stree(&tmp);
+	} END_FOR_EACH_PTR(tmp);
+	free_stree_stack(&return_stree_stack);
+}
+
+void register_returns_early(int id)
+{
+	RETURN_ID = id;
+
+	add_split_return_callback(match_return);
+}
+
+void register_returns(int id)
+{
+	add_hook(&match_end_func, END_FUNC_HOOK);
+	add_hook(&match_save_states, INLINE_FN_START);
+	add_hook(&match_restore_states, INLINE_FN_END);
+	add_hook(&free_resources, AFTER_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_scope.c b/usr/src/tools/smatch/src/smatch_scope.c
new file mode 100644
index 0000000000..271e23722d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scope.c
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2016 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+static struct statement_list *stmt_list;
+
+static int end_of_function(struct statement *stmt)
+{
+	struct symbol *fn = get_base_type(cur_func_sym);
+
+	/* err on the conservative side of things */
+	if (!fn)
+		return 1;
+	if (stmt == fn->stmt || stmt == fn->inline_stmt)
+		return 1;
+	return 0;
+}
+
+/*
+ * We're wasting a lot of time worrying about out of scope variables.
+ * When we come to the end of a scope then just delete them all the out of
+ * scope states.
+ */
+static void match_end_of_block(struct statement *stmt)
+{
+	struct statement *tmp;
+	struct symbol *sym;
+
+	if (end_of_function(stmt))
+		return;
+
+	FOR_EACH_PTR(stmt->stmts, tmp) {
+		if (tmp->type != STMT_DECLARATION)
+			return;
+
+		FOR_EACH_PTR(tmp->declaration, sym) {
+			if (!sym->ident)
+				continue;
+			__delete_all_states_sym(sym);
+		} END_FOR_EACH_PTR(sym);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static int is_outer_stmt(struct statement *stmt)
+{
+	struct symbol *fn;
+
+	if (!cur_func_sym)
+		return 0;
+	fn = get_base_type(cur_func_sym);
+	if (!fn)
+		return 0;
+	/*
+	 * There are times when ->parent is not set but it's set for
+	 * the outer statement so ignoring NULLs works as a work-around.
+	 */
+	if (!stmt->parent)
+		return 0;
+	if (stmt->parent == fn->stmt ||
+	    stmt->parent == fn->inline_stmt)
+		return 1;
+	return 0;
+}
+
+static void match_stmt(struct statement *stmt)
+{
+	struct statement *tmp;
+
+	if (__inline_fn)
+		return;
+
+	if (stmt->type == STMT_COMPOUND)
+		add_ptr_list(&stmt_list, stmt);
+
+	if (!is_outer_stmt(stmt))
+		return;
+
+	FOR_EACH_PTR(stmt_list, tmp) {
+		match_end_of_block(tmp);
+	} END_FOR_EACH_PTR(tmp);
+	free_ptr_list(&stmt_list);
+}
+
+static void match_end_func(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	free_ptr_list(&stmt_list);
+}
+
+void register_scope(int id)
+{
+	add_hook(&match_stmt, STMT_HOOK_AFTER);
+	add_hook(&match_end_func, AFTER_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/add_gfp_to_allocations.sh b/usr/src/tools/smatch/src/smatch_scripts/add_gfp_to_allocations.sh
new file mode 100755
index 0000000000..090150838d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/add_gfp_to_allocations.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+if ! test -e kernel.allocation_funcs || ! test -e kernel.gfp_flags ; then
+    echo "We need the kernel.allocation_funcs and the kernel.gfp_flags files"
+    echo "The scripts to generate them are in smatch_data/"
+    exit 1
+fi
+
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/kernel.allocation_funcs_gfp.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+
+echo "// Automatically generated by add_gfp_to_allocations.sh" > kernel.allocation_funcs_gfp
+for i in $(grep -v "//" kernel.allocation_funcs) ; do
+    if ! grep -w $i kernel.gfp_flags ; then
+	echo $i X
+    fi
+done >> $tmp
+
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> kernel.allocation_funcs_gfp
+rm $tmp
+
+echo "Done.  Created kernel.allocation_funcs_gfp"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/build_generic_data.sh b/usr/src/tools/smatch/src/smatch_scripts/build_generic_data.sh
new file mode 100755
index 0000000000..27ad013bf5
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/build_generic_data.sh
@@ -0,0 +1,67 @@
+#!/bin/bash
+
+# This is a generic script to parse --info output.  For the kernel, don't use
+# this script, use build_kernel_data.sh instead.
+
+NR_CPU=$(cat /proc/cpuinfo | grep ^processor | wc -l)
+SCRIPT_DIR=$(dirname $0)
+DATA_DIR=smatch_data
+PROJECT=smatch_generic
+TARGET=""
+
+function usage {
+    echo
+    echo "Usage:  $0"
+    echo "Updates the smatch_data/ directory and builds the smatch database"
+    echo " -p <project> (default = $PROJECT)"
+    echo
+    exit 1
+}
+
+while true ; do
+    if [[ "$1" == "--target" ]] ; then
+        shift
+        TARGET="$1"
+        shift
+    elif [ "$1" == "-p" ] || [ "$1" == "--project" ] ; then
+        shift
+        PROJECT="$1"
+        shift
+    elif [ "$1" == "--help" ] || [ "$1" = "-h" ] ; then
+        usage
+    else
+        break
+    fi
+done
+
+if [ -e $SCRIPT_DIR/../smatch ] ; then
+    BIN_DIR=$SCRIPT_DIR/../
+else
+    echo "This script should be located in the smatch_scripts/ subdirectory of the smatch source."
+    exit 1
+fi
+
+# If someone is building the database for the first time then make sure all the
+# required packages are installed
+if [ ! -e smatch_db.sqlite ] ; then
+    [ -e smatch_warns.txt ] || touch smatch_warns.txt
+    if ! $SCRIPT_DIR/../smatch_data/db/create_db.sh -p=$PROJECT smatch_warns.txt ; then
+        echo "Hm... Not working.  Make sure you have all the sqlite3 packages"
+        echo "And the sqlite3 libraries for Perl and Python"
+        exit 1
+    fi
+fi
+
+make -j${NR_CPU} CHECK="$BIN_DIR/smatch --call-tree --info --param-mapper --spammy --file-output" $TARGET
+
+find -name \*.c.smatch -exec cat \{\} \; -exec rm \{\} \; > smatch_warns.txt
+
+for i in $SCRIPT_DIR/gen_* ; do
+        $i smatch_warns.txt -p=${PROJECT}
+done
+
+mkdir -p $DATA_DIR
+mv $PROJECT.* $DATA_DIR
+
+$SCRIPT_DIR/../smatch_data/db/create_db.sh -p=$PROJECT smatch_warns.txt
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/build_kernel_data.sh b/usr/src/tools/smatch/src/smatch_scripts/build_kernel_data.sh
new file mode 100755
index 0000000000..cacf065e0a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/build_kernel_data.sh
@@ -0,0 +1,47 @@
+#!/bin/bash
+
+PROJECT=kernel
+
+function usage {
+    echo
+    echo "Usage:  $0"
+    echo "Updates the smatch_data/ directory and builds the smatch database"
+    echo
+    exit 1
+}
+
+if [ "$1" = "-h" ] || [ "$1" = "--help" ] ; then
+	usage;
+fi
+
+SCRIPT_DIR=$(dirname $0)
+if [ -e $SCRIPT_DIR/../smatch -a -d kernel -a -d fs ] ; then
+    CMD=$SCRIPT_DIR/../smatch
+    DATA_DIR=$SCRIPT_DIR/../smatch_data
+else
+    echo "This script should be located in the smatch_scripts/ subdirectory of the smatch source."
+    echo "It should be run from the root of a kernel source tree."
+    exit 1
+fi
+
+# If someone is building the database for the first time then make sure all the
+# required packages are installed
+if [ ! -e smatch_db.sqlite ] ; then
+    [ -e smatch_warns.txt ] || touch smatch_warns.txt
+    if ! $DATA_DIR/db/create_db.sh -p=kernel smatch_warns.txt ; then
+        echo "Hm... Not working.  Make sure you have all the sqlite3 packages"
+        echo "And the sqlite3 libraries for Perl and Python"
+        exit 1
+    fi
+fi
+
+$SCRIPT_DIR/test_kernel.sh --call-tree --info --param-mapper --spammy --data=$DATA_DIR
+
+for i in $SCRIPT_DIR/gen_* ; do
+	$i smatch_warns.txt -p=kernel
+done
+
+mv ${PROJECT}.* $DATA_DIR
+
+$DATA_DIR/db/create_db.sh -p=kernel smatch_warns.txt
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/call_tree.pl b/usr/src/tools/smatch/src/smatch_scripts/call_tree.pl
new file mode 100755
index 0000000000..745a5376b5
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/call_tree.pl
@@ -0,0 +1,146 @@
+#!/usr/bin/perl
+
+# This script is supposed to help use the param_mapper output.
+# Give it a function and parameter and it lists the functions
+# and parameters which are basically equivalent.
+
+use strict;
+
+sub usage()
+{
+    print("call_tree.pl <smatch output file>\n");
+    print("call_tree.pl finds paths between two functions\n"); 
+    exit(1);
+}
+
+my %param_map;
+
+my $UNKNOWN  = 1;
+my $NOTFOUND = 2;
+my $FOUND    = 3;
+
+my $path;
+
+sub print_path()
+{
+    my $i = 0;
+
+    foreach my $func (@{$path}) {
+	if ($i++) {
+	    print(", ");
+	}
+	print("$func");
+    }
+    print("\n");
+    print("\n");
+}
+
+sub recurse($$)
+{
+    my $link = shift;
+    my $target = shift;
+    my $found = 0;
+
+    if ($link =~ /$target/) {
+	print_path();
+	return 1;
+    }
+    if (%{$param_map{$link}}->{found} == $NOTFOUND) {
+	return 0;
+    }
+
+    %{$param_map{$link}}->{found} = $NOTFOUND;
+
+    foreach my $l (@{%{$param_map{$link}}->{links}}){
+	push(@{$path}, $l);
+	$found = recurse($l, $target);
+	if (!$found) {
+	    pop(@{$path});
+	} else {
+	    last;
+	}
+    }
+
+    return $found;
+}
+
+sub search($$)
+{
+    my $start_func = shift;
+    my $end_func = shift;
+
+    foreach my $link (@{%{$param_map{$start_func}}->{links}}){
+	%{$param_map{$start_func}}->{found} = $NOTFOUND;
+	foreach my $l (@{%{$param_map{$start_func}}->{links}}){
+	    %{$param_map{$l}}->{found} = $NOTFOUND;
+	}
+	$path = [$start_func, $link];
+	%{$param_map{$link}}->{found} = $UNKNOWN;
+	recurse($link, $end_func);
+    }
+}
+
+sub add_link($$)
+{
+    my $one = shift;
+    my $two = shift;
+
+    if (!defined($param_map{$one})) {
+	$param_map{$one} = {found => $UNKNOWN, links => []};
+    }
+    push @{$param_map{$one}->{links}}, $two;
+}
+
+sub load_all($)
+{
+    my $file = shift;
+
+    open(FILE, "<$file");
+    while (<FILE>) {
+	if (/.*?:\d+ (.*?)\(\) info: func_call (.*)/) {
+	    add_link("$1", "$2");
+	}
+    }
+}
+
+sub set_all_unknown()
+{
+    my $i = 0;
+
+    foreach my $func (keys %param_map){
+	%{$param_map{$func}}->{found} = $UNKNOWN;
+    }
+}
+
+my $file = shift();
+if (!$file) {
+    usage();
+}
+
+if (! -e $file) {
+    printf("Error:  $file does not exist.\n");
+    exit(1);
+}
+
+print("Loading functions...\n");
+load_all($file);
+
+while (1) {
+    my $start_func;
+    my $end_func;
+
+    print("Enter the start function:  ");
+    $start_func = <STDIN>;
+    $start_func =~ s/^\s+|\s+$//g;
+    print("Enter the target function:  ");
+    $end_func = <STDIN>;
+    $end_func =~ s/^\s+|\s+$//g;
+
+
+    print("$start_func to $end_func\n");
+    if ($start_func =~ /./ && $end_func =~ /./) {
+	search($start_func, $end_func);
+    }
+
+    set_all_unknown();
+}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/filter_kernel_deref_check.sh b/usr/src/tools/smatch/src/smatch_scripts/filter_kernel_deref_check.sh
new file mode 100755
index 0000000000..c70d7994ea
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/filter_kernel_deref_check.sh
@@ -0,0 +1,101 @@
+#!/bin/bash
+
+file=$1
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages>"
+    exit 1
+fi
+
+IFS="
+"
+
+for line in $(grep 'dereferenced before' $file) ; do
+
+    code_file=$(echo "$line" | cut -d ':' -f1)
+    lineno=$(echo "$line" | cut -d ' ' -f1 | cut -d ':' -f2)
+    function=$(echo "$line" | cut -d ' ' -f2)
+    variable=$(echo "$line" | cut -d "'" -f3)
+    source_line=$(tail -n +$lineno $code_file | head -n 1 | sed -e 's/^\W*//')
+
+    if echo "$source_line" | grep -q rcu_assign_pointer ; then
+	continue
+    fi
+    if echo "$source_line" | grep -q '^\W*tda_' ; then
+	continue
+    fi
+    if echo "$source_line" | grep -q tda_fail ; then
+	continue
+    fi
+    if echo "$source_line" | grep -q '^\W*ATH5K_' ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw CMDINFO ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw dump_desc_dbg ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw CAMERA_IS_OPERATIONAL ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw USBVISION_IS_OPERATIONAL ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw DEV_INIT_TEST_WITH_RETURN ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw TW_PRINTK ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw RESET_ONE_SEC_TX_CNT ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw SOCK_DEBUG; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw P80211SKB_RXMETA ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw ACM_READY ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw v4l2_subdev_notify ; then
+	continue
+    fi
+    if echo "$source_line" | egrep -qw 'tuner_(err|info)' ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw DBG_SKB ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw for_each_mddev ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw v4l2_subdev_call ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw VALID_CALLBACK ; then
+	continue
+    fi
+    if [ "$variable" == "bp->dev" ] && echo "$source_line" | grep -qw DP ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw BNX2X_ERR ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw FCOE_NETDEV_DBG ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw __rq_for_each_bio ; then
+	continue
+    fi
+    if echo "$source_line" | grep -qw IPS_DMA_DIR ; then
+	continue
+    fi
+    if [ "$variable" == "dev" ] && echo "$source_line" | grep -qw dprintk ; then
+	continue
+    fi
+
+    echo "$code_file:$lineno $function '$variable': $source_line"
+done
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/find_expanded_holes.pl b/usr/src/tools/smatch/src/smatch_scripts/find_expanded_holes.pl
new file mode 100755
index 0000000000..3f38c6817d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/find_expanded_holes.pl
@@ -0,0 +1,18 @@
+#!/usr/bin/perl
+
+use strict;
+
+my $cur_struct = "";
+my $printed = 0;
+
+while (<>) {
+    if ($_ =~ /^struct (\w+) {/) {
+	$cur_struct = $1;
+	$printed = 0;
+	next;
+    }
+    if ($_ =~ /.* hole,.*/ && !$printed) {
+	print "$cur_struct\n";
+	$printed = 1;
+    }
+}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/find_null_params.sh b/usr/src/tools/smatch/src/smatch_scripts/find_null_params.sh
new file mode 100755
index 0000000000..9e39146d2d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/find_null_params.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+file=$1
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages>"
+    exit 1
+fi
+
+grep " unchecked " $file | cut -d ' ' -f 5- | sort -u > unchecked
+grep " undefined " $file | cut -d ' ' -f 5- | sort -u > null_calls.txt
+cat null_calls.txt unchecked | sort | uniq -d > null_params.txt
+IFS="
+"
+for i in $(cat null_params.txt) ; do
+	grep "$i" $file | grep -w undefined 
+done
+
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/follow_params.pl b/usr/src/tools/smatch/src/smatch_scripts/follow_params.pl
new file mode 100755
index 0000000000..b2b8e77320
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/follow_params.pl
@@ -0,0 +1,106 @@
+#!/usr/bin/perl
+
+use strict;
+
+sub usage()
+{
+    print "$0 <smatch output file> <function> <parameter>\n";
+    print "Give this program a function and parameter and it follows to find\n";
+    print "how the parameter gets passed down to lower levels.\n'";
+    exit(1);
+}
+
+my %param_map;
+
+my $UNUSED   = 0;
+my $USED     = 1;
+
+sub print_link($)
+{
+    my $link = shift;
+
+    $link =~ s/%/ /;
+    print "$link\n";
+}
+
+sub recurse($)
+{
+    my $link = shift;
+
+    if ($param_map{$link}{used} == $USED) {
+	return;
+    }
+    ${param_map}{$link}->{used} = $USED;
+
+    print_link($link);
+
+    foreach my $l (@{$param_map{$link}{links}}){
+	recurse($l);
+    }
+
+}
+
+sub follow($$)
+{
+    my $f = shift;
+    my $p = shift;
+
+    recurse("$f%$p");
+}
+
+sub add_link($$)
+{
+    my $one = shift;
+    my $two = shift;
+
+    if (!defined($param_map{$one})) {
+	$param_map{$one} = {used => $UNUSED, links => []};
+    }
+    push @{$param_map{$one}{links}}, $two;
+}
+
+sub load_all($)
+{
+    my $file = shift;
+
+    open(FILE, "<$file");
+    while (<FILE>) {
+	if (/.*?:\d+ (.*?)\(\) info: param_mapper (\d+) => (.*?) (\d+)/) {
+	    add_link("$1%$2", "$3%$4");
+	}
+    }
+}
+
+sub set_all_unused()
+{
+    foreach my $func (keys %param_map){
+	($param_map{$func}{used} = $UNUSED);
+    }
+
+}
+
+my $file = shift();
+my $func = shift();
+my $param = shift();
+
+if (!defined($file) or !defined($func) or !defined($param)) {
+    usage();
+}
+
+if (! -e $file) {
+    printf("Error:  $file does not exist.\n");
+    exit(1);
+}
+
+load_all($file);
+
+while (1) {
+    follow($func, $param);
+
+    $func = shift();
+    $param = shift();
+    if (!defined($func) || !defined($param)) {
+	last;
+    }
+    set_all_unused();
+}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_allocation_list.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_allocation_list.sh
new file mode 100755
index 0000000000..20175624bd
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_allocation_list.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/kernel.allocation_funcs.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of functions that return a new allocation." \
+    > kernel.allocation_funcs
+echo '// generated by `gen_allocation_list.sh`' >> kernel.allocation_funcs
+grep "allocation func$" $file | cut -s -d ' ' -f 2 | cut -d '(' -f 1 | \
+    sort -u > $tmp
+echo "kmalloc" >> $tmp
+echo "kzalloc" >> $tmp
+echo "kcalloc" >> $tmp
+echo "__alloc_skb" >> $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u \
+    >> kernel.allocation_funcs
+rm $tmp
+echo "Done.  List saved as 'kernel.allocation_funcs'"
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_bit_shifters.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_bit_shifters.sh
new file mode 100755
index 0000000000..98fa30ca20
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_bit_shifters.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/${project}.bit_shifters.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of macros used as shifters." \
+    > ${project}.bit_shifters
+echo '// generated by `gen_bit_shifters.sh`' >> ${project}.bit_shifters
+grep "info: bit shifter" $file | cut -s -d "'" -f 2- | sed -e "s/'//g" | sort -u > $tmp
+
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> ${project}.bit_shifters
+rm $tmp
+echo "Done.  List saved as '${project}.bit_shifters'"
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_dma_funcs.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_dma_funcs.sh
new file mode 100755
index 0000000000..6307061b48
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_dma_funcs.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+outfile="kernel.dma_funcs"
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/${outfile}.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+tmp2=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of DMA function and buffer parameters." > $outfile
+echo '// generated by `gen_dma_funcs.sh`' >> $outfile
+${bin_dir}/trace_params.pl $file usb_control_msg 6 >> $tmp
+${bin_dir}/trace_params.pl $file usb_fill_bulk_urb 3 >> $tmp
+cat $tmp | sort -u > $tmp2
+mv $tmp2 $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> $outfile
+rm $tmp
+echo "Done.  List saved as '$outfile'"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_err_ptr_list.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_err_ptr_list.sh
new file mode 100755
index 0000000000..79c40c570b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_err_ptr_list.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/kernel.returns_err_ptr.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of functions that return a new allocation." \
+    > kernel.returns_err_ptr
+echo '// generated by `gen_err_ptr_list.sh`' >> kernel.returns_err_ptr
+grep "returns_err_ptr$" $file | cut -s -d ' ' -f 2 | cut -d '(' -f 1 | \
+    sort -u > $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u \
+    >> kernel.returns_err_ptr
+rm $tmp
+echo "Done.  List saved as 'kernel.returns_err_ptr'"
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_expects_err_ptr.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_expects_err_ptr.sh
new file mode 100755
index 0000000000..83dbe8fffd
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_expects_err_ptr.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+outfile="kernel.expects_err_ptr"
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/${outfile}.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of functions which expect an ERR_PTR." > $outfile
+echo '// generated by `gen_expects_err_ptr.sh`' >> $outfile
+grep -w "expects ERR_PTR" $file | cut -d ' ' -f 2,6 | \
+    sed -e 's/([1234567890]*)//' | sort -u > $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> $outfile
+rm $tmp
+echo "Done.  List saved as '$outfile'"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_frees_list.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_frees_list.sh
new file mode 100755
index 0000000000..5813d29fad
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_frees_list.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/kernel.frees_argument.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of functions and the argument they free." > kernel.frees_argument
+echo '// generated by `gen_frees_list.sh`' >> kernel.frees_argument
+grep -w free_arg $file | cut -d ' ' -f 5- >> $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> kernel.frees_argument
+rm $tmp
+echo "Done.  List saved as 'kernel.frees_argument'"
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_gfp_flags.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_gfp_flags.sh
new file mode 100755
index 0000000000..2c7ea98b5b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_gfp_flags.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+outfile="kernel.gfp_flags"
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/${outfile}.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+tmp2=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of GFP flag parameters." > $outfile
+echo '// generated by `gen_gfp_flags.sh`' >> $outfile
+${bin_dir}/trace_params.pl $file kmalloc 1 >> $tmp
+${bin_dir}/trace_params.pl $file kzalloc 1 >> $tmp
+${bin_dir}/trace_params.pl $file kcalloc 2 >> $tmp
+cat $tmp | sort -u > $tmp2
+mv $tmp2 $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> $outfile
+rm $tmp
+echo "Done.  List saved as '$outfile'"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_implicit_dependencies.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_implicit_dependencies.sh
new file mode 100755
index 0000000000..bb62174375
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_implicit_dependencies.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/kernel.implicit_dependencies.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+
+# echo "// list of syscalls and the fields they write/read to." > kernel.implicit_dependencies
+# echo '// generated by `gen_implicit_dependencies.sh`' >> kernel.implicit_dependencies
+grep -w read_list $file >> $tmp
+grep -w write_list $file >> $tmp
+# cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> kernel.implicit_dependencies
+cat $tmp >> kernel.implicit_dependencies
+rm $tmp
+echo "Done.  List saved as 'kernel.implicit_dependencies"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_no_return_funcs.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_no_return_funcs.sh
new file mode 100755
index 0000000000..713456c04a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_no_return_funcs.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+outfile="${project}.no_return_funcs"
+bin_dir=$(dirname $0)
+add_file=$(echo ${bin_dir}/../smatch_data/${outfile}.add)
+remove=$(echo ${bin_dir}/../smatch_data/${outfile}.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+tmp2=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of functions which don't return." > $outfile
+echo '// generated by `gen_no_return_funcs.sh`' >> $outfile
+cat $(echo ${bin_dir}/../smatch_data/no_return_funcs) >> $outfile
+cat $add_file >> $outfile 2> /dev/null
+
+grep no_return_funcs $file | cut -d ' ' -f 2 | cut -d '(' -f 1 > $tmp
+
+cat $tmp | sort -u > $tmp2
+mv $tmp2 $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> $outfile
+rm $tmp
+echo "Done.  List saved as '$outfile'"
+echo "Copy it to smatch_data/<project>.no_return_funcs"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_puts_list.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_puts_list.sh
new file mode 100755
index 0000000000..5a877aeb84
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_puts_list.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/kernel.puts_argument.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of functions and the argument they decrement the ref of." > kernel.puts_argument
+echo '// generated by `gen_puts_list.sh`' >> kernel.puts_argument
+grep -w puts_arg $file | cut -d ' ' -f 5- >> $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> kernel.puts_argument
+rm $tmp
+echo "Done.  List saved as 'kernel.puts_argument'"
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_returns_held.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_returns_held.sh
new file mode 100755
index 0000000000..f8e7fe383c
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_returns_held.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/kernel.returns_held.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of functions that return a held device." \
+    > kernel.returns_held_funcs
+echo '// generated by `gen_returns_held.sh`' >> kernel.returns_held_funcs
+grep "returned dev is held" $file | cut -s -d ' ' -f 2 | cut -d '(' -f 1 | \
+    sort -u > $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u \
+    >> kernel.returns_held_funcs
+rm $tmp
+echo "Done.  List saved as 'kernel.returns_held_funcs'"
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_rosenberg_funcs.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_rosenberg_funcs.sh
new file mode 100755
index 0000000000..338da9d5dd
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_rosenberg_funcs.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+outfile="kernel.rosenberg_funcs"
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/${outfile}.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+tmp2=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of copy_to_user function and buffer parameters." > $outfile
+echo '// generated by `gen_rosenberg_funcs.sh`' >> $outfile
+${bin_dir}/trace_params.pl $file copy_to_user 1 >> $tmp
+${bin_dir}/trace_params.pl $file nla_put 3 >> $tmp
+cat $tmp | sort -u > $tmp2
+mv $tmp2 $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> $outfile
+rm $tmp
+echo "Done.  List saved as '$outfile'"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_sizeof_param.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_sizeof_param.sh
new file mode 100755
index 0000000000..8f4e5f7493
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_sizeof_param.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+outfile="${project}.sizeof_param"
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/${outfile}.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+tmp2=$(mktemp /tmp/smatch.XXXX)
+
+
+echo "// list of function parameters that are the size of a buffer." > $outfile
+echo '// generated by `gen_sizeof_param.sh`' >> $outfile
+
+grep sizeof_param $file | grep '[0-9] [0-9]$' | cut -d ' ' -f 5- | \
+    sort -u | sed -e "s/'//g" > $tmp
+grep sizeof_param $file | grep '[0-9] -1$' | cut -d ' ' -f 5- | \
+    sort -u | sed -e "s/'//g" >> $tmp
+grep -f $remove $tmp >> $tmp2 2> /dev/null
+cat $tmp $tmp2 2> /dev/null | sort | uniq -u >> $outfile
+rm $tmp
+rm $tmp2
+
+echo "Done.  List saved as '$outfile'"
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_trinity.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_trinity.sh
new file mode 100755
index 0000000000..c8e84f04c6
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_trinity.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+cat << EOF > trinity_smatch.h
+
+#pragma once
+
+/* Syscalls from arch/x86/syscalls/syscall_64.tbl */
+
+#include "sanitise.h"
+#include "syscall.h"
+#include "syscalls/syscalls.h"
+
+EOF
+
+cat smatch_trinity_* >> trinity_smatch.c
+
+
+for i in $(grep syscallentry smatch_trinity_*  | cut -d ' ' -f 3) ; do
+    echo "extern struct syscallentry $i;" >> trinity_smatch.h
+done
+
+echo "" >> trinity_smatch.h
+echo "struct syscalltable syscalls_smatch[] = {" >> trinity_smatch.h
+
+for i in $(grep syscallentry smatch_trinity_*  | cut -d ' ' -f 3) ; do
+    echo "{ .entry = &$i },"  >> trinity_smatch.h
+done
+
+echo "};" >> trinity_smatch.h
diff --git a/usr/src/tools/smatch/src/smatch_scripts/gen_unwind_functions.sh b/usr/src/tools/smatch/src/smatch_scripts/gen_unwind_functions.sh
new file mode 100755
index 0000000000..ae85049020
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/gen_unwind_functions.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+
+file=$1
+project=$(echo "$2" | cut -d = -f 2)
+
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 <file with smatch messages> -p=<project>"
+    exit 1
+fi
+
+if [[ "$project" != "kernel" ]] ; then
+    exit 0
+fi
+
+outfile="kernel.unwind_functions"
+bin_dir=$(dirname $0)
+remove=$(echo ${bin_dir}/../smatch_data/${outfile}.remove)
+tmp=$(mktemp /tmp/smatch.XXXX)
+tmp2=$(mktemp /tmp/smatch.XXXX)
+
+echo "// list of unwind functions." > $outfile
+echo '// generated by `gen_unwind_functions.sh`' >> $outfile
+grep "is unwind function" $file | cut -d ' ' -f 2 | cut -d '(' -f 1 >> $tmp
+cat $tmp | sort -u > $tmp2
+mv $tmp2 $tmp
+cat $tmp $remove $remove 2> /dev/null | sort | uniq -u >> $outfile
+rm $tmp
+echo "Done.  List saved as '$outfile'"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/generisize.pl b/usr/src/tools/smatch/src/smatch_scripts/generisize.pl
new file mode 100755
index 0000000000..8132ed296b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/generisize.pl
@@ -0,0 +1,64 @@
+#!/usr/bin/perl
+
+use strict;
+
+sub help()
+{
+    print "usage: $0 [-r]\n";
+    print "Counts the number of errors of each type.\n";
+    print "-r means down to the nearest 10.\n";
+    exit 1;
+}
+
+my $round;
+my $arg = shift;
+if ($arg =~ /-h/) {
+    help();
+} elsif ($arg =~ /-r/) {
+    $round = 1;
+}
+
+my %msgs;
+
+sub add_msg($)
+{
+    my $msg = shift;
+
+    if (defined $msgs{$msg}) {
+	$msgs{$msg}++;
+    } else {
+	$msgs{$msg} = 1;
+    }
+}
+
+while (<>) {
+    s/^.*?:\d+(|:\d+:) .*? //;
+    s/[us](16|32|64)(min|max)//g;
+    s/0x\w+//g;
+    s/[01234567890]//g;
+    if ($_ =~ /can't/) {
+        s/(.*can't.*').*?('.*)/$1 $2/;
+        s/(.*?)'.*?'(.*can't.*)/$1 $2/;
+    } elsif ($_ =~ /don't/) {
+    	s/(.*don't.*').*?('.*)/$1 $2/;
+    } else {
+    	s/'.*?'/''/g;
+    }
+    s/,//g;
+    s/\(\w+ returns null\)/(... returns null)/;
+    s/dma on the stack \(.*?\)/dma on the stack (...)/;
+    s/possible ERR_PTR '' to .*/possible ERR_PTR '' to .../;
+    s/inconsistent returns ([^ ]+?) locked \(\)/inconsistent returns ... locked ()/;
+    s/(.*) [^ ]* (too large for) [^ ]+ (.*)/$1 $2 $3/;
+
+    add_msg($_);
+}
+
+foreach my $key (sort { $msgs{$b} <=> $msgs{$a} } keys %msgs) {
+    my $count = $msgs{$key};
+
+    if ($round) {
+	$count = $msgs{$key} - $msgs{$key} % 10;
+    }
+    print "$count $key";
+}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/README b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/README
new file mode 100644
index 0000000000..5963c80002
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/README
@@ -0,0 +1,6 @@
+Python module for parsing kernel.implicit_dependencies
+
+`python main.py -h` for usage.
+run `python main.py -v -p` to generate verbose and pretty print.
+
+To generate kernel.implicit_dependencies, run `smatch_scripts/build_kernel_data.sh`
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/constants.py b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/constants.py
new file mode 100644
index 0000000000..127d677330
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/constants.py
@@ -0,0 +1,28 @@
+from collections import defaultdict
+
+# location of kernel.implicit_dependencies
+IMPL_DEP_FILE_STR = "../../smatch_data/kernel.implicit_dependencies"
+OUTPUT_FILE_STR = "implicit_dependencies"
+
+# struct fields to ignore, because they are too common
+GLOBAL_BLACKLIST = [
+    ('fd', 'file'),
+]
+
+# here we can manually add struct fields that smatch missed
+hardcode_syscall_write_fields = {}
+
+# here we can manually add struct fields that smatch missed
+hardcode_syscall_read_fields = {
+    "msync": [("vm_area_struct", "vm_flags"), ("vm_area_struct", "vm_file")]
+}
+
+SYSCALL_PREFIXES = [
+    "SYSC_",
+    "C_SYSC_",
+    "sys_",
+]
+
+class ListType(object):
+    READ = "read_list"
+    WRITE = "write_list"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/main.py b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/main.py
new file mode 100644
index 0000000000..0df3baf5e4
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/main.py
@@ -0,0 +1,39 @@
+import argparse
+import sys
+
+from constants import (
+    IMPL_DEP_FILE_STR,
+    OUTPUT_FILE_STR,
+)
+from parser import Parser
+
+def main():
+    arg_parser = argparse.ArgumentParser(
+        description="Control module for tracking implicit dependencies"
+    )
+    arg_parser.add_argument(
+        "-f", "--file", default=IMPL_DEP_FILE_STR,
+        help="path to kernel.implicit_dependencies",
+    )
+    arg_parser.add_argument(
+        "-o", "--output", default=OUTPUT_FILE_STR,
+        help="where to output info",
+    )
+    arg_parser.add_argument(
+        "-v", "--verbose", action="store_true",
+        help="if verbose, we list what fields are responsible for the dependency"
+    )
+    arg_parser.add_argument(
+        "-p", "--pretty", action="store_true",
+        help="print implicit dependencies in pretty format"
+    )
+    args = arg_parser.parse_args()
+
+    p = Parser(args.file, output_file_str=args.output, verbose=args.verbose, pretty=args.pretty)
+    p.parse()
+    p.write()
+    p.close()
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/parser.py b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/parser.py
new file mode 100644
index 0000000000..5cc5a8efb1
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/parser.py
@@ -0,0 +1,152 @@
+from collections import defaultdict
+import copy
+import json
+import sys
+import pprint
+
+from constants import (
+    GLOBAL_BLACKLIST,
+    IMPL_DEP_FILE_STR,
+    OUTPUT_FILE_STR,
+    SYSCALL_PREFIXES,
+    ListType,
+    hardcode_syscall_read_fields,
+    hardcode_syscall_write_fields,
+)
+
+class Parser(object):
+    def __init__(
+        self,
+        impl_dep_file_str=IMPL_DEP_FILE_STR,
+        output_file_str=OUTPUT_FILE_STR,
+        verbose=False,
+        pretty=False
+    ):
+        try:
+            self.impl_dep_file = file(impl_dep_file_str, 'r')
+            self.output_file = file(output_file_str + '.json', 'w+')
+            if verbose:
+                self.output_file_verbose = file(output_file_str + '_verbose.json', 'w+')
+            if pretty:
+                self.pretty_output_file = file(output_file_str + '.pretty', 'w+')
+                self.pretty_output_file_verbose = file(output_file_str + '_verbose.pretty', 'w+')
+        except IOError:
+            sys.stderr.write("ERROR: Cannot open files %s %s.\n" % (impl_dep_file_str, output_file_str))
+            sys.exit(1)
+        self.verbose = verbose
+        self.pretty = pretty
+        self.syscall_read_fields = defaultdict(set)
+        self.syscall_write_fields = defaultdict(set)
+        self.implicit_dependencies = defaultdict(set)
+        self.verbose_impl_dep = defaultdict(list)
+        self.deref_counter = defaultdict(int)  # count which struct->members are most common
+
+        for syscall,fields in hardcode_syscall_read_fields.iteritems():
+            self.syscall_read_fields[syscall].update(set(fields))
+
+        for syscall,fields in hardcode_syscall_write_fields.iteritems():
+            self.syscall_write_fields[syscall].update(set(fields))
+
+    def _sanitize_syscall(self, syscall):
+        for prefix in SYSCALL_PREFIXES:
+            if syscall.startswith(prefix):
+                return syscall[len(prefix):]
+        return syscall
+
+    def _deref_to_tuple(self, deref):
+        """ (struct a)->b ==> (a,b) """
+        struct, member = deref.split('->')
+        struct = struct[1:-1]  # strip parens
+        struct = struct.split(' ')[1]  # drop struct keyword
+        return (struct, member)
+
+    def _split_field(self, field):
+        field = field.strip()
+        field = field[1: -1]  # strip square brackets
+        derefs = [struct.strip() for struct in field.strip().split(',') if struct]
+        return map(
+            lambda deref: self._deref_to_tuple(deref),
+            derefs
+        )
+
+    def _sanitize_line(self, line):
+        syscall_and_listtype, field = line.split(':')
+        syscall, list_type = syscall_and_listtype.split(' ')
+        syscall = self._sanitize_syscall(syscall)
+        derefs = self._split_field(field)
+        return syscall, list_type, derefs
+
+    def _add_fields(self, syscall, list_type, derefs):
+        if list_type == ListType.READ:
+            d = self.syscall_read_fields
+        elif list_type == ListType.WRITE:
+            d = self.syscall_write_fields
+        for deref in derefs:
+            if deref in GLOBAL_BLACKLIST:  # ignore spammy structs
+                continue
+            d[syscall].add(deref)
+
+    def _construct_implicit_deps(self):
+        """ just do a naive O(n^2) loop to see intersections between write_list and read_list """
+        for this_call,read_fields in self.syscall_read_fields.iteritems():
+            for that_call,write_fields in self.syscall_write_fields.iteritems():
+                if that_call == this_call:  # calls are obviously dependent on themselves. ignore.
+                    continue
+                intersection = read_fields & write_fields
+                if intersection:
+                    self.implicit_dependencies[this_call].add(that_call)
+                if intersection and self.verbose:
+                    self.verbose_impl_dep[this_call].append({
+                        'call': that_call,
+                        'reason': intersection,
+                    })
+                    for deref in intersection:
+                        self.deref_counter[deref] += 1
+
+    def parse(self):
+        for line in self.impl_dep_file:
+            syscall, list_type, derefs = self._sanitize_line(line)
+            self._add_fields(syscall, list_type, derefs)
+        # pprint.pprint(dict(self.syscall_write_fields))
+        # pprint.pprint(dict(self.syscall_read_fields))
+        self._construct_implicit_deps()
+        # pprint.pprint(dict(self.implicit_dependencies))
+        # pprint.pprint(dict(self.verbose_impl_dep))
+
+    def _listify_verbose_reason(self, reason):
+        r = copy.deepcopy(reason)
+        r['reason'] = list(r['reason'])
+        r['reason'] = map(
+            lambda (struct,field): struct + '->' + field,
+            r['reason']
+        )
+        return r
+
+    def _get_json_dependencies(self):
+        implicit_dependencies = {}
+        verbose_impl_dep = {}
+        for call, dep_set in self.implicit_dependencies.iteritems():
+            implicit_dependencies[call] = list(dep_set)
+        for call, call_reasons in self.verbose_impl_dep.iteritems():
+            verbose_impl_dep[call] = map(
+                lambda reason: self._listify_verbose_reason(reason),
+                call_reasons,
+            )
+        return implicit_dependencies, verbose_impl_dep
+
+    def write(self):
+        implicit_dependencies, verbose_impl_dep = self._get_json_dependencies()
+        json.dump(implicit_dependencies, self.output_file)
+        if self.verbose:
+            json.dump(verbose_impl_dep, self.output_file_verbose)
+        if self.pretty:
+            pprint.pprint(dict(self.implicit_dependencies), self.pretty_output_file)
+            pprint.pprint(dict(self.verbose_impl_dep), self.pretty_output_file_verbose)
+        for deref, count in sorted(self.deref_counter.iteritems(), key=lambda (k,v): (v,k)):
+            print "%s: %d" % (deref, count)
+
+    def close(self):
+        self.output_file.close()
+        self.impl_dep_file.close()
+        if self.verbose:
+            self.output_file_verbose.close()
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies
new file mode 100644
index 0000000000..44e3cc6c17
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies
@@ -0,0 +1,12227 @@
+{'accept4': set(['accept4',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fcntl64',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'old_readdir',
+                 'perf_event_open',
+                 'pread64',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setsockopt',
+                 'shutdown',
+                 'signalfd4',
+                 'splice',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'acct': set(['accept4',
+              'acct',
+              'dup',
+              'dup3',
+              'epoll_create1',
+              'epoll_ctl',
+              'eventfd2',
+              'flock',
+              'memfd_create',
+              'mmap_pgoff',
+              'mq_open',
+              'open',
+              'open_by_handle_at',
+              'openat',
+              'perf_event_open',
+              'pipe2',
+              'remap_file_pages',
+              'setns',
+              'shmat',
+              'shmctl',
+              'shmdt',
+              'socket',
+              'socketpair',
+              'swapoff',
+              'swapon',
+              'uselib']),
+ 'alarm': set(['adjtimex',
+               'alarm',
+               'clock_adjtime',
+               'getitimer',
+               'getrusage',
+               'ppoll',
+               'select',
+               'setitimer',
+               'settimeofday',
+               'wait4',
+               'waitid']),
+ 'bind': set(['accept4',
+              'bind',
+              'bpf',
+              'connect',
+              'copy_file_range',
+              'epoll_ctl',
+              'epoll_wait',
+              'fallocate',
+              'fchdir',
+              'fchmod',
+              'fchown',
+              'fcntl',
+              'fcntl64',
+              'fdatasync',
+              'fgetxattr',
+              'flistxattr',
+              'flock',
+              'fremovexattr',
+              'fsetxattr',
+              'fstatfs',
+              'fstatfs64',
+              'fsync',
+              'ftruncate',
+              'futimesat',
+              'getdents',
+              'getdents64',
+              'getpeername',
+              'getsockname',
+              'getsockopt',
+              'inotify_add_watch',
+              'inotify_rm_watch',
+              'ioctl',
+              'listen',
+              'llseek',
+              'lseek',
+              'mq_getsetattr',
+              'mq_notify',
+              'mq_timedreceive',
+              'mq_timedsend',
+              'old_readdir',
+              'perf_event_open',
+              'pread64',
+              'preadv',
+              'preadv2',
+              'preadv64',
+              'preadv64v2',
+              'pwrite64',
+              'pwritev',
+              'pwritev2',
+              'pwritev64',
+              'pwritev64v2',
+              'read',
+              'readahead',
+              'readv',
+              'recvfrom',
+              'sendfile',
+              'sendfile64',
+              'sendto',
+              'setsockopt',
+              'shutdown',
+              'signalfd4',
+              'splice',
+              'sync_file_range',
+              'syncfs',
+              'tee',
+              'utime',
+              'utimensat',
+              'vmsplice',
+              'write',
+              'writev']),
+ 'bpf': set(['accept4',
+             'acct',
+             'bind',
+             'bpf',
+             'capget',
+             'clone',
+             'connect',
+             'copy_file_range',
+             'dup',
+             'dup3',
+             'epoll_create1',
+             'epoll_ctl',
+             'epoll_wait',
+             'eventfd2',
+             'fallocate',
+             'fchdir',
+             'fchmod',
+             'fchown',
+             'fcntl',
+             'fcntl64',
+             'fdatasync',
+             'fgetxattr',
+             'flistxattr',
+             'flock',
+             'fork',
+             'fremovexattr',
+             'fsetxattr',
+             'fstatfs',
+             'fstatfs64',
+             'fsync',
+             'ftruncate',
+             'futimesat',
+             'get_robust_list',
+             'getdents',
+             'getdents64',
+             'getitimer',
+             'getpeername',
+             'getpgid',
+             'getppid',
+             'getpriority',
+             'getrusage',
+             'getsid',
+             'getsockname',
+             'getsockopt',
+             'inotify_add_watch',
+             'inotify_rm_watch',
+             'ioctl',
+             'ioperm',
+             'ioprio_get',
+             'ioprio_set',
+             'keyctl',
+             'kill',
+             'listen',
+             'llseek',
+             'lseek',
+             'memfd_create',
+             'migrate_pages',
+             'mmap_pgoff',
+             'move_pages',
+             'mq_getsetattr',
+             'mq_notify',
+             'mq_open',
+             'mq_timedreceive',
+             'mq_timedsend',
+             'msgrcv',
+             'old_readdir',
+             'open',
+             'open_by_handle_at',
+             'openat',
+             'perf_event_open',
+             'pipe2',
+             'prctl',
+             'pread64',
+             'preadv',
+             'preadv2',
+             'preadv64',
+             'preadv64v2',
+             'prlimit64',
+             'ptrace',
+             'pwrite64',
+             'pwritev',
+             'pwritev2',
+             'pwritev64',
+             'pwritev64v2',
+             'read',
+             'readahead',
+             'readv',
+             'recvfrom',
+             'remap_file_pages',
+             'rt_sigaction',
+             'rt_sigprocmask',
+             'rt_sigtimedwait',
+             'sched_getaffinity',
+             'sched_getattr',
+             'sched_getparam',
+             'sched_getscheduler',
+             'sched_rr_get_interval',
+             'sched_setaffinity',
+             'sched_setattr',
+             'sched_setparam',
+             'sched_setscheduler',
+             'semtimedop',
+             'sendfile',
+             'sendfile64',
+             'sendto',
+             'setitimer',
+             'setns',
+             'setpgid',
+             'setpriority',
+             'setsid',
+             'setsockopt',
+             'shmat',
+             'shmctl',
+             'shmdt',
+             'shutdown',
+             'sigaction',
+             'sigaltstack',
+             'signal',
+             'signalfd4',
+             'socket',
+             'socketpair',
+             'splice',
+             'swapoff',
+             'swapon',
+             'sync_file_range',
+             'syncfs',
+             'tee',
+             'umount',
+             'uselib',
+             'utime',
+             'utimensat',
+             'vfork',
+             'vmsplice',
+             'write',
+             'writev']),
+ 'brk': set(['brk',
+             'get_mempolicy',
+             'getrusage',
+             'io_cancel',
+             'io_destroy',
+             'io_getevents',
+             'io_setup',
+             'madvise',
+             'mbind',
+             'migrate_pages',
+             'mincore',
+             'mlockall',
+             'modify_ldt',
+             'move_pages',
+             'mprotect',
+             'mremap',
+             'munlock',
+             'munlockall',
+             'pkey_mprotect',
+             'prctl',
+             'remap_file_pages',
+             'shmdt',
+             'swapoff']),
+ 'capset': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'clock_adjtime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime',
+                       'timer_settime']),
+ 'clock_nanosleep': set(['clock_adjtime',
+                         'clock_getres',
+                         'clock_gettime',
+                         'clock_nanosleep',
+                         'clock_settime',
+                         'epoll_wait',
+                         'faccessat',
+                         'fchmod',
+                         'fchmodat',
+                         'fchown',
+                         'fchownat',
+                         'fstat',
+                         'ftruncate',
+                         'futex',
+                         'futimesat',
+                         'inotify_add_watch',
+                         'io_getevents',
+                         'ioctl',
+                         'linkat',
+                         'memfd_create',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'mq_unlink',
+                         'nanosleep',
+                         'newfstat',
+                         'poll',
+                         'ppoll',
+                         'pselect6',
+                         'readlinkat',
+                         'recvmmsg',
+                         'rt_sigtimedwait',
+                         'sched_rr_get_interval',
+                         'select',
+                         'semtimedop',
+                         'sendfile',
+                         'sendfile64',
+                         'settimeofday',
+                         'stime',
+                         'swapoff',
+                         'swapon',
+                         'timer_create',
+                         'timer_delete',
+                         'timer_gettime',
+                         'timer_settime',
+                         'timerfd_gettime',
+                         'timerfd_settime',
+                         'unlink',
+                         'unlinkat',
+                         'uselib',
+                         'utime']),
+ 'clock_settime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime',
+                       'timer_settime']),
+ 'connect': set(['accept4',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fcntl64',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'old_readdir',
+                 'perf_event_open',
+                 'pread64',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setsockopt',
+                 'shutdown',
+                 'signalfd4',
+                 'splice',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'copy_file_range': set(['accept4',
+                         'bind',
+                         'bpf',
+                         'connect',
+                         'copy_file_range',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchown',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'flistxattr',
+                         'flock',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'getdents',
+                         'getdents64',
+                         'getpeername',
+                         'getsockname',
+                         'getsockopt',
+                         'inotify_add_watch',
+                         'inotify_rm_watch',
+                         'ioctl',
+                         'listen',
+                         'llseek',
+                         'lseek',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'old_readdir',
+                         'perf_event_open',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'read',
+                         'readahead',
+                         'readv',
+                         'recvfrom',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'setsockopt',
+                         'shutdown',
+                         'signalfd4',
+                         'splice',
+                         'sync_file_range',
+                         'syncfs',
+                         'tee',
+                         'utime',
+                         'utimensat',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'delete_module': set(['delete_module', 'finit_module', 'init_module']),
+ 'dmi_modalias_show': set(['dmi_modalias_show']),
+ 'dup3': set(['dup2', 'dup3', 'select', 'unshare']),
+ 'epoll_create1': set(['capget',
+                       'capset',
+                       'clone',
+                       'epoll_create1',
+                       'epoll_ctl',
+                       'epoll_wait',
+                       'faccessat',
+                       'fork',
+                       'get_robust_list',
+                       'getgroups',
+                       'getgroups16',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getresgid',
+                       'getresgid16',
+                       'getresuid',
+                       'getresuid16',
+                       'getrusage',
+                       'getsid',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setfsgid',
+                       'setfsuid',
+                       'setgid',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setregid',
+                       'setresgid',
+                       'setresuid',
+                       'setreuid',
+                       'setsid',
+                       'setuid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'unshare',
+                       'vfork']),
+ 'epoll_ctl': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'brk',
+                   'capget',
+                   'clone',
+                   'connect',
+                   'copy_file_range',
+                   'delete_module',
+                   'dup',
+                   'dup2',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'eventfd2',
+                   'exit_group',
+                   'faccessat',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'finit_module',
+                   'flistxattr',
+                   'flock',
+                   'fork',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'get_curr_temp',
+                   'get_mempolicy',
+                   'get_robust_list',
+                   'get_trip_temp',
+                   'getcwd',
+                   'getdents',
+                   'getdents64',
+                   'getgroups',
+                   'getgroups16',
+                   'getitimer',
+                   'getpeername',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'getsockname',
+                   'getsockopt',
+                   'init_module',
+                   'inotify_add_watch',
+                   'inotify_init1',
+                   'inotify_rm_watch',
+                   'io_cancel',
+                   'io_destroy',
+                   'io_getevents',
+                   'io_setup',
+                   'io_submit',
+                   'ioctl',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'kexec_load',
+                   'keyctl',
+                   'kill',
+                   'linkat',
+                   'listen',
+                   'llseek',
+                   'lookup_dcookie',
+                   'lseek',
+                   'madvise',
+                   'mbind',
+                   'memfd_create',
+                   'migrate_pages',
+                   'mincore',
+                   'mkdirat',
+                   'mknodat',
+                   'mlockall',
+                   'mmap_pgoff',
+                   'modify_ldt',
+                   'move_pages',
+                   'mprotect',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'mremap',
+                   'msgctl',
+                   'msgrcv',
+                   'msgsnd',
+                   'munlock',
+                   'munlockall',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'pkey_mprotect',
+                   'prctl',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'prlimit64',
+                   'ptrace',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'quotactl',
+                   'read',
+                   'readahead',
+                   'readlinkat',
+                   'readv',
+                   'reboot',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'renameat2',
+                   'request_key',
+                   'rmdir',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'sched_yield',
+                   'semctl',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'set_trip_temp',
+                   'setgid',
+                   'setgroups',
+                   'setgroups16',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresgid',
+                   'setresuid',
+                   'setreuid',
+                   'setsid',
+                   'setsockopt',
+                   'setuid',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'signalfd4',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'symlinkat',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'timer_create',
+                   'timer_delete',
+                   'timer_getoverrun',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_create',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'umount',
+                   'unlink',
+                   'unlinkat',
+                   'unshare',
+                   'uselib',
+                   'ustat',
+                   'utime',
+                   'utimensat',
+                   'vfork',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'epoll_wait': set(['accept4',
+                    'acct',
+                    'bind',
+                    'bpf',
+                    'capget',
+                    'clone',
+                    'connect',
+                    'copy_file_range',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'eventfd2',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fork',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'get_robust_list',
+                    'getdents',
+                    'getdents64',
+                    'getitimer',
+                    'getpeername',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'ioperm',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'keyctl',
+                    'kill',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'memfd_create',
+                    'migrate_pages',
+                    'mmap_pgoff',
+                    'move_pages',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_open',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'old_readdir',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'prctl',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'prlimit64',
+                    'ptrace',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'remap_file_pages',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'setsockopt',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'shutdown',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'signalfd4',
+                    'socket',
+                    'socketpair',
+                    'splice',
+                    'swapoff',
+                    'swapon',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'umount',
+                    'uselib',
+                    'utime',
+                    'utimensat',
+                    'vfork',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'faccessat': set(['accept4',
+                   'acct',
+                   'capget',
+                   'clone',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'fork',
+                   'get_robust_list',
+                   'getcwd',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'migrate_pages',
+                   'mmap_pgoff',
+                   'move_pages',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'quotactl',
+                   'remap_file_pages',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setresuid',
+                   'setreuid',
+                   'setsid',
+                   'setuid',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'umount',
+                   'unshare',
+                   'uselib',
+                   'vfork']),
+ 'fallocate': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'fchdir': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getcwd',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lookup_dcookie',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'quotactl',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'splice',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'unshare',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'fchmod': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getcwd',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lookup_dcookie',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'quotactl',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'splice',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'unshare',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'fchmodat': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'getcwd',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'unshare',
+                  'uselib']),
+ 'fchown': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getcwd',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lookup_dcookie',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'quotactl',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'splice',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'unshare',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'fchownat': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'getcwd',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'unshare',
+                  'uselib']),
+ 'fcntl': set(['accept4',
+               'acct',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'epoll_wait',
+               'eventfd2',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'memfd_create',
+               'mmap_pgoff',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_open',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'remap_file_pages',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setns',
+               'setsockopt',
+               'shmat',
+               'shmctl',
+               'shmdt',
+               'shutdown',
+               'signalfd4',
+               'socket',
+               'socketpair',
+               'splice',
+               'swapoff',
+               'swapon',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'uselib',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'fcntl64': set(['accept4',
+                 'acct',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'eventfd2',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fcntl64',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'old_readdir',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'pread64',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'remap_file_pages',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setns',
+                 'setsockopt',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'shutdown',
+                 'signalfd4',
+                 'socket',
+                 'socketpair',
+                 'splice',
+                 'swapoff',
+                 'swapon',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'uselib',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'fdatasync': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'fgetxattr': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'finit_module': set(['delete_module', 'finit_module', 'init_module']),
+ 'flistxattr': set(['accept4',
+                    'bind',
+                    'bpf',
+                    'connect',
+                    'copy_file_range',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'getdents',
+                    'getdents64',
+                    'getpeername',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'old_readdir',
+                    'perf_event_open',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setsockopt',
+                    'shutdown',
+                    'signalfd4',
+                    'splice',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'utime',
+                    'utimensat',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'flock': set(['accept4',
+               'acct',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'epoll_wait',
+               'eventfd2',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'memfd_create',
+               'mmap_pgoff',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_open',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'quotactl',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'remap_file_pages',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setns',
+               'setsockopt',
+               'shmat',
+               'shmctl',
+               'shmdt',
+               'shutdown',
+               'signalfd4',
+               'socket',
+               'socketpair',
+               'splice',
+               'swapoff',
+               'swapon',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'umount',
+               'uselib',
+               'ustat',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'fremovexattr': set(['accept4',
+                      'bind',
+                      'bpf',
+                      'connect',
+                      'copy_file_range',
+                      'epoll_ctl',
+                      'epoll_wait',
+                      'fallocate',
+                      'fchdir',
+                      'fchmod',
+                      'fchown',
+                      'fcntl',
+                      'fcntl64',
+                      'fdatasync',
+                      'fgetxattr',
+                      'flistxattr',
+                      'flock',
+                      'fremovexattr',
+                      'fsetxattr',
+                      'fstatfs',
+                      'fstatfs64',
+                      'fsync',
+                      'ftruncate',
+                      'futimesat',
+                      'getdents',
+                      'getdents64',
+                      'getpeername',
+                      'getsockname',
+                      'getsockopt',
+                      'inotify_add_watch',
+                      'inotify_rm_watch',
+                      'ioctl',
+                      'listen',
+                      'llseek',
+                      'lseek',
+                      'mq_getsetattr',
+                      'mq_notify',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'old_readdir',
+                      'perf_event_open',
+                      'pread64',
+                      'preadv',
+                      'preadv2',
+                      'preadv64',
+                      'preadv64v2',
+                      'pwrite64',
+                      'pwritev',
+                      'pwritev2',
+                      'pwritev64',
+                      'pwritev64v2',
+                      'read',
+                      'readahead',
+                      'readv',
+                      'recvfrom',
+                      'sendfile',
+                      'sendfile64',
+                      'sendto',
+                      'setsockopt',
+                      'shutdown',
+                      'signalfd4',
+                      'splice',
+                      'sync_file_range',
+                      'syncfs',
+                      'tee',
+                      'utime',
+                      'utimensat',
+                      'vmsplice',
+                      'write',
+                      'writev']),
+ 'fsetxattr': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'fstat': set(['fstat', 'lstat', 'newfstat', 'stat']),
+ 'fstatfs': set(['accept4',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fcntl64',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'old_readdir',
+                 'perf_event_open',
+                 'pread64',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setsockopt',
+                 'shutdown',
+                 'signalfd4',
+                 'splice',
+                 'statfs',
+                 'statfs64',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'ustat',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'fstatfs64': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'statfs',
+                   'statfs64',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'ustat',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'fsync': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'ftruncate': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'eventfd2',
+                   'faccessat',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'linkat',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readlinkat',
+                   'readv',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setns',
+                   'setsockopt',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'signalfd4',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'futex': set(['clock_nanosleep',
+               'epoll_wait',
+               'faccessat',
+               'fchmod',
+               'fchmodat',
+               'fchown',
+               'fchownat',
+               'fstat',
+               'ftruncate',
+               'futex',
+               'futimesat',
+               'inotify_add_watch',
+               'io_getevents',
+               'ioctl',
+               'linkat',
+               'memfd_create',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mq_unlink',
+               'nanosleep',
+               'newfstat',
+               'poll',
+               'ppoll',
+               'pselect6',
+               'readlinkat',
+               'recvmmsg',
+               'rt_sigtimedwait',
+               'sched_rr_get_interval',
+               'select',
+               'semtimedop',
+               'sendfile',
+               'sendfile64',
+               'settimeofday',
+               'stime',
+               'swapoff',
+               'swapon',
+               'timer_gettime',
+               'timer_settime',
+               'timerfd_gettime',
+               'timerfd_settime',
+               'unlink',
+               'unlinkat',
+               'uselib',
+               'utime']),
+ 'futimesat': set(['accept4',
+                   'adjtimex',
+                   'alarm',
+                   'bind',
+                   'bpf',
+                   'clock_adjtime',
+                   'clock_nanosleep',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'faccessat',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstat',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futex',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getitimer',
+                   'getpeername',
+                   'getrusage',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'io_getevents',
+                   'ioctl',
+                   'linkat',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'nanosleep',
+                   'newfstat',
+                   'old_readdir',
+                   'perf_event_open',
+                   'poll',
+                   'ppoll',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pselect6',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readlinkat',
+                   'readv',
+                   'recvfrom',
+                   'recvmmsg',
+                   'rt_sigtimedwait',
+                   'sched_rr_get_interval',
+                   'select',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setitimer',
+                   'setsockopt',
+                   'settimeofday',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'stime',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'wait4',
+                   'waitid',
+                   'write',
+                   'writev']),
+ 'get_mempolicy': set(['brk',
+                       'capget',
+                       'clone',
+                       'fork',
+                       'get_mempolicy',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'madvise',
+                       'mbind',
+                       'migrate_pages',
+                       'mincore',
+                       'mlockall',
+                       'move_pages',
+                       'mprotect',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'mremap',
+                       'msgrcv',
+                       'munlock',
+                       'munlockall',
+                       'perf_event_open',
+                       'pkey_mprotect',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'remap_file_pages',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'set_mempolicy',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'shmdt',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'getcwd': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'ftruncate',
+                'getcwd',
+                'linkat',
+                'lookup_dcookie',
+                'memfd_create',
+                'mkdirat',
+                'mknodat',
+                'mmap_pgoff',
+                'mq_open',
+                'mq_unlink',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'quotactl',
+                'remap_file_pages',
+                'renameat2',
+                'rmdir',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'symlinkat',
+                'umount',
+                'unlink',
+                'unlinkat',
+                'unshare',
+                'uselib']),
+ 'getdents': set(['accept4',
+                  'bind',
+                  'bpf',
+                  'capget',
+                  'clone',
+                  'connect',
+                  'copy_file_range',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fork',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'get_robust_list',
+                  'getdents',
+                  'getdents64',
+                  'getitimer',
+                  'getpeername',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'ioperm',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'old_readdir',
+                  'perf_event_open',
+                  'prctl',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'prlimit64',
+                  'ptrace',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'setsockopt',
+                  'shutdown',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'signalfd4',
+                  'splice',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'umount',
+                  'utime',
+                  'utimensat',
+                  'vfork',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'getdents64': set(['accept4',
+                    'bind',
+                    'bpf',
+                    'capget',
+                    'clone',
+                    'connect',
+                    'copy_file_range',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fork',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'get_robust_list',
+                    'getdents',
+                    'getdents64',
+                    'getitimer',
+                    'getpeername',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'ioperm',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'keyctl',
+                    'kill',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'migrate_pages',
+                    'move_pages',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'old_readdir',
+                    'perf_event_open',
+                    'prctl',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'prlimit64',
+                    'ptrace',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'setsockopt',
+                    'shutdown',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'signalfd4',
+                    'splice',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'umount',
+                    'utime',
+                    'utimensat',
+                    'vfork',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'getegid': set(['capget',
+                 'clone',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'perf_event_open',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'getegid16': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'geteuid': set(['capget',
+                 'clone',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'perf_event_open',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'geteuid16': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'getgid': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'getgid16': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'getgroups': set(['capget',
+                   'capset',
+                   'clone',
+                   'epoll_create1',
+                   'faccessat',
+                   'fork',
+                   'get_robust_list',
+                   'getgroups',
+                   'getgroups16',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getresgid',
+                   'getresgid16',
+                   'getresuid',
+                   'getresuid16',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setfsgid',
+                   'setfsuid',
+                   'setgid',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresgid',
+                   'setresuid',
+                   'setreuid',
+                   'setsid',
+                   'setuid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'unshare',
+                   'vfork']),
+ 'getgroups16': set(['capget',
+                     'capset',
+                     'clone',
+                     'epoll_create1',
+                     'faccessat',
+                     'fork',
+                     'get_robust_list',
+                     'getgroups',
+                     'getgroups16',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getpriority',
+                     'getresgid',
+                     'getresgid16',
+                     'getresuid',
+                     'getresuid16',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setfsgid',
+                     'setfsuid',
+                     'setgid',
+                     'setgroups',
+                     'setgroups16',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setpriority',
+                     'setregid',
+                     'setresgid',
+                     'setresuid',
+                     'setreuid',
+                     'setsid',
+                     'setuid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'unshare',
+                     'vfork']),
+ 'getitimer': set(['exit_group', 'setitimer', 'timer_create']),
+ 'getpeername': set(['accept4',
+                     'bind',
+                     'bpf',
+                     'connect',
+                     'copy_file_range',
+                     'epoll_ctl',
+                     'epoll_wait',
+                     'fallocate',
+                     'fchdir',
+                     'fchmod',
+                     'fchown',
+                     'fcntl',
+                     'fcntl64',
+                     'fdatasync',
+                     'fgetxattr',
+                     'flistxattr',
+                     'flock',
+                     'fremovexattr',
+                     'fsetxattr',
+                     'fstatfs',
+                     'fstatfs64',
+                     'fsync',
+                     'ftruncate',
+                     'futimesat',
+                     'getdents',
+                     'getdents64',
+                     'getpeername',
+                     'getsockname',
+                     'getsockopt',
+                     'inotify_add_watch',
+                     'inotify_rm_watch',
+                     'ioctl',
+                     'listen',
+                     'llseek',
+                     'lseek',
+                     'mq_getsetattr',
+                     'mq_notify',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'old_readdir',
+                     'perf_event_open',
+                     'pread64',
+                     'preadv',
+                     'preadv2',
+                     'preadv64',
+                     'preadv64v2',
+                     'pwrite64',
+                     'pwritev',
+                     'pwritev2',
+                     'pwritev64',
+                     'pwritev64v2',
+                     'read',
+                     'readahead',
+                     'readv',
+                     'recvfrom',
+                     'sendfile',
+                     'sendfile64',
+                     'sendto',
+                     'setsockopt',
+                     'shutdown',
+                     'signalfd4',
+                     'splice',
+                     'sync_file_range',
+                     'syncfs',
+                     'tee',
+                     'utime',
+                     'utimensat',
+                     'vmsplice',
+                     'write',
+                     'writev']),
+ 'getppid': set(['capget',
+                 'clone',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'perf_event_open',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'getpriority': set(['capget',
+                     'clone',
+                     'fork',
+                     'get_robust_list',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getpriority',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setpriority',
+                     'setresuid',
+                     'setreuid',
+                     'setsid',
+                     'setuid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'vfork']),
+ 'getresgid': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'getresgid16': set(['capget',
+                     'clone',
+                     'fork',
+                     'get_robust_list',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getpriority',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setpriority',
+                     'setsid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'vfork']),
+ 'getresuid': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'getresuid16': set(['capget',
+                     'clone',
+                     'fork',
+                     'get_robust_list',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getpriority',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setpriority',
+                     'setsid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'vfork']),
+ 'getrlimit': set(['old_getrlimit', 'prlimit64', 'setrlimit']),
+ 'getrusage': set(['exit_group', 'timer_create']),
+ 'getsockname': set(['accept4',
+                     'bind',
+                     'bpf',
+                     'connect',
+                     'copy_file_range',
+                     'epoll_ctl',
+                     'epoll_wait',
+                     'fallocate',
+                     'fchdir',
+                     'fchmod',
+                     'fchown',
+                     'fcntl',
+                     'fcntl64',
+                     'fdatasync',
+                     'fgetxattr',
+                     'flistxattr',
+                     'flock',
+                     'fremovexattr',
+                     'fsetxattr',
+                     'fstatfs',
+                     'fstatfs64',
+                     'fsync',
+                     'ftruncate',
+                     'futimesat',
+                     'getdents',
+                     'getdents64',
+                     'getpeername',
+                     'getsockname',
+                     'getsockopt',
+                     'inotify_add_watch',
+                     'inotify_rm_watch',
+                     'ioctl',
+                     'listen',
+                     'llseek',
+                     'lseek',
+                     'mq_getsetattr',
+                     'mq_notify',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'old_readdir',
+                     'perf_event_open',
+                     'pread64',
+                     'preadv',
+                     'preadv2',
+                     'preadv64',
+                     'preadv64v2',
+                     'pwrite64',
+                     'pwritev',
+                     'pwritev2',
+                     'pwritev64',
+                     'pwritev64v2',
+                     'read',
+                     'readahead',
+                     'readv',
+                     'recvfrom',
+                     'sendfile',
+                     'sendfile64',
+                     'sendto',
+                     'setsockopt',
+                     'shutdown',
+                     'signalfd4',
+                     'splice',
+                     'sync_file_range',
+                     'syncfs',
+                     'tee',
+                     'utime',
+                     'utimensat',
+                     'vmsplice',
+                     'write',
+                     'writev']),
+ 'getsockopt': set(['accept4',
+                    'bind',
+                    'bpf',
+                    'connect',
+                    'copy_file_range',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'getdents',
+                    'getdents64',
+                    'getpeername',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'old_readdir',
+                    'perf_event_open',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setsockopt',
+                    'shutdown',
+                    'signalfd4',
+                    'splice',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'utime',
+                    'utimensat',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'getuid': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'getuid16': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'getxattr': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'getcwd',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'unshare',
+                  'uselib']),
+ 'init_module': set(['delete_module', 'finit_module', 'init_module']),
+ 'inotify_add_watch': set(['accept4',
+                           'acct',
+                           'bind',
+                           'bpf',
+                           'connect',
+                           'copy_file_range',
+                           'dup',
+                           'dup3',
+                           'epoll_create1',
+                           'epoll_ctl',
+                           'epoll_wait',
+                           'eventfd2',
+                           'fallocate',
+                           'fchdir',
+                           'fchmod',
+                           'fchown',
+                           'fcntl',
+                           'fcntl64',
+                           'fdatasync',
+                           'fgetxattr',
+                           'flistxattr',
+                           'flock',
+                           'fremovexattr',
+                           'fsetxattr',
+                           'fstatfs',
+                           'fstatfs64',
+                           'fsync',
+                           'ftruncate',
+                           'futimesat',
+                           'getcwd',
+                           'getdents',
+                           'getdents64',
+                           'getpeername',
+                           'getsockname',
+                           'getsockopt',
+                           'inotify_add_watch',
+                           'inotify_rm_watch',
+                           'ioctl',
+                           'linkat',
+                           'listen',
+                           'llseek',
+                           'lseek',
+                           'memfd_create',
+                           'mkdirat',
+                           'mknodat',
+                           'mmap_pgoff',
+                           'mq_getsetattr',
+                           'mq_notify',
+                           'mq_open',
+                           'mq_timedreceive',
+                           'mq_timedsend',
+                           'mq_unlink',
+                           'old_readdir',
+                           'open',
+                           'open_by_handle_at',
+                           'openat',
+                           'perf_event_open',
+                           'pipe2',
+                           'pivot_root',
+                           'pread64',
+                           'preadv',
+                           'preadv2',
+                           'preadv64',
+                           'preadv64v2',
+                           'pwrite64',
+                           'pwritev',
+                           'pwritev2',
+                           'pwritev64',
+                           'pwritev64v2',
+                           'read',
+                           'readahead',
+                           'readv',
+                           'recvfrom',
+                           'remap_file_pages',
+                           'renameat2',
+                           'rmdir',
+                           'sendfile',
+                           'sendfile64',
+                           'sendto',
+                           'setns',
+                           'setsockopt',
+                           'shmat',
+                           'shmctl',
+                           'shmdt',
+                           'shutdown',
+                           'signalfd4',
+                           'socket',
+                           'socketpair',
+                           'splice',
+                           'swapoff',
+                           'swapon',
+                           'symlinkat',
+                           'sync_file_range',
+                           'syncfs',
+                           'tee',
+                           'unlink',
+                           'unlinkat',
+                           'uselib',
+                           'utime',
+                           'utimensat',
+                           'vmsplice',
+                           'write',
+                           'writev']),
+ 'inotify_init1': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'inotify_add_watch',
+                       'inotify_init1',
+                       'inotify_rm_watch',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'inotify_rm_watch': set(['accept4',
+                          'acct',
+                          'bind',
+                          'bpf',
+                          'connect',
+                          'copy_file_range',
+                          'dup',
+                          'dup3',
+                          'epoll_create1',
+                          'epoll_ctl',
+                          'epoll_wait',
+                          'eventfd2',
+                          'fallocate',
+                          'fchdir',
+                          'fchmod',
+                          'fchown',
+                          'fcntl',
+                          'fcntl64',
+                          'fdatasync',
+                          'fgetxattr',
+                          'flistxattr',
+                          'flock',
+                          'fremovexattr',
+                          'fsetxattr',
+                          'fstatfs',
+                          'fstatfs64',
+                          'fsync',
+                          'ftruncate',
+                          'futimesat',
+                          'getdents',
+                          'getdents64',
+                          'getpeername',
+                          'getsockname',
+                          'getsockopt',
+                          'inotify_add_watch',
+                          'inotify_rm_watch',
+                          'ioctl',
+                          'listen',
+                          'llseek',
+                          'lseek',
+                          'memfd_create',
+                          'mmap_pgoff',
+                          'mq_getsetattr',
+                          'mq_notify',
+                          'mq_open',
+                          'mq_timedreceive',
+                          'mq_timedsend',
+                          'old_readdir',
+                          'open',
+                          'open_by_handle_at',
+                          'openat',
+                          'perf_event_open',
+                          'pipe2',
+                          'pread64',
+                          'preadv',
+                          'preadv2',
+                          'preadv64',
+                          'preadv64v2',
+                          'pwrite64',
+                          'pwritev',
+                          'pwritev2',
+                          'pwritev64',
+                          'pwritev64v2',
+                          'read',
+                          'readahead',
+                          'readv',
+                          'recvfrom',
+                          'remap_file_pages',
+                          'sendfile',
+                          'sendfile64',
+                          'sendto',
+                          'setns',
+                          'setsockopt',
+                          'shmat',
+                          'shmctl',
+                          'shmdt',
+                          'shutdown',
+                          'signalfd4',
+                          'socket',
+                          'socketpair',
+                          'splice',
+                          'swapoff',
+                          'swapon',
+                          'sync_file_range',
+                          'syncfs',
+                          'tee',
+                          'uselib',
+                          'utime',
+                          'utimensat',
+                          'vmsplice',
+                          'write',
+                          'writev']),
+ 'io_cancel': set(['brk',
+                   'get_mempolicy',
+                   'getrusage',
+                   'io_cancel',
+                   'io_destroy',
+                   'io_getevents',
+                   'io_setup',
+                   'io_submit',
+                   'mbind',
+                   'migrate_pages',
+                   'mincore',
+                   'modify_ldt',
+                   'move_pages',
+                   'mremap',
+                   'prctl',
+                   'remap_file_pages',
+                   'shmdt',
+                   'swapoff']),
+ 'io_destroy': set(['brk',
+                    'get_mempolicy',
+                    'getrusage',
+                    'io_cancel',
+                    'io_destroy',
+                    'io_getevents',
+                    'io_setup',
+                    'io_submit',
+                    'mbind',
+                    'migrate_pages',
+                    'mincore',
+                    'modify_ldt',
+                    'move_pages',
+                    'mremap',
+                    'prctl',
+                    'remap_file_pages',
+                    'shmdt',
+                    'swapoff']),
+ 'io_getevents': set(['brk',
+                      'capget',
+                      'clone',
+                      'fork',
+                      'get_mempolicy',
+                      'get_robust_list',
+                      'getitimer',
+                      'getpgid',
+                      'getppid',
+                      'getpriority',
+                      'getrusage',
+                      'getsid',
+                      'io_cancel',
+                      'io_destroy',
+                      'io_getevents',
+                      'io_setup',
+                      'io_submit',
+                      'ioprio_get',
+                      'ioprio_set',
+                      'keyctl',
+                      'kill',
+                      'mbind',
+                      'migrate_pages',
+                      'mincore',
+                      'modify_ldt',
+                      'move_pages',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'mremap',
+                      'msgrcv',
+                      'perf_event_open',
+                      'prctl',
+                      'prlimit64',
+                      'ptrace',
+                      'remap_file_pages',
+                      'rt_sigaction',
+                      'rt_sigprocmask',
+                      'rt_sigtimedwait',
+                      'sched_getaffinity',
+                      'sched_getattr',
+                      'sched_getparam',
+                      'sched_getscheduler',
+                      'sched_rr_get_interval',
+                      'sched_setaffinity',
+                      'sched_setattr',
+                      'sched_setparam',
+                      'sched_setscheduler',
+                      'semtimedop',
+                      'setitimer',
+                      'setns',
+                      'setpgid',
+                      'setpriority',
+                      'setsid',
+                      'shmdt',
+                      'sigaction',
+                      'sigaltstack',
+                      'signal',
+                      'swapoff',
+                      'umount',
+                      'vfork']),
+ 'io_setup': set(['io_cancel',
+                  'io_destroy',
+                  'io_getevents',
+                  'io_setup',
+                  'io_submit']),
+ 'io_submit': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioperm',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'ioctl': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'ioperm': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'ioprio_get': set(['capget',
+                    'clone',
+                    'fork',
+                    'get_robust_list',
+                    'getitimer',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'keyctl',
+                    'kill',
+                    'migrate_pages',
+                    'move_pages',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'perf_event_open',
+                    'prctl',
+                    'prlimit64',
+                    'ptrace',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'umount',
+                    'vfork']),
+ 'ioprio_set': set(['capget',
+                    'clone',
+                    'fork',
+                    'get_robust_list',
+                    'getitimer',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'keyctl',
+                    'kill',
+                    'migrate_pages',
+                    'move_pages',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'perf_event_open',
+                    'prctl',
+                    'prlimit64',
+                    'ptrace',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'umount',
+                    'vfork']),
+ 'keyctl': set(['capget',
+                'capset',
+                'clone',
+                'epoll_create1',
+                'faccessat',
+                'fork',
+                'get_robust_list',
+                'getgroups',
+                'getgroups16',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getresgid',
+                'getresgid16',
+                'getresuid',
+                'getresuid16',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'request_key',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setfsgid',
+                'setfsuid',
+                'setgid',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setregid',
+                'setresgid',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'unshare',
+                'vfork']),
+ 'kill': set(['capget',
+              'clone',
+              'fork',
+              'get_robust_list',
+              'getitimer',
+              'getpgid',
+              'getppid',
+              'getpriority',
+              'getrusage',
+              'getsid',
+              'ioprio_get',
+              'ioprio_set',
+              'keyctl',
+              'kill',
+              'migrate_pages',
+              'move_pages',
+              'mq_timedreceive',
+              'mq_timedsend',
+              'msgrcv',
+              'perf_event_open',
+              'prctl',
+              'prlimit64',
+              'ptrace',
+              'rt_sigaction',
+              'rt_sigprocmask',
+              'rt_sigtimedwait',
+              'sched_getaffinity',
+              'sched_getattr',
+              'sched_getparam',
+              'sched_getscheduler',
+              'sched_rr_get_interval',
+              'sched_setaffinity',
+              'sched_setattr',
+              'sched_setparam',
+              'sched_setscheduler',
+              'semtimedop',
+              'setitimer',
+              'setns',
+              'setpgid',
+              'setpriority',
+              'setsid',
+              'sigaction',
+              'sigaltstack',
+              'signal',
+              'umount',
+              'vfork']),
+ 'lgetxattr': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'getcwd',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'quotactl',
+                   'remap_file_pages',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'unshare',
+                   'uselib']),
+ 'linkat': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'getcwd',
+                'lookup_dcookie',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_open',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'quotactl',
+                'remap_file_pages',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'unshare',
+                'uselib']),
+ 'listen': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'listxattr': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'getcwd',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'quotactl',
+                   'remap_file_pages',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'unshare',
+                   'uselib']),
+ 'llistxattr': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'getcwd',
+                    'lookup_dcookie',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'pivot_root',
+                    'quotactl',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'unshare',
+                    'uselib']),
+ 'llseek': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'lremovexattr': set(['accept4',
+                      'acct',
+                      'dup',
+                      'dup3',
+                      'epoll_create1',
+                      'epoll_ctl',
+                      'eventfd2',
+                      'flock',
+                      'getcwd',
+                      'lookup_dcookie',
+                      'memfd_create',
+                      'mmap_pgoff',
+                      'mq_open',
+                      'open',
+                      'open_by_handle_at',
+                      'openat',
+                      'perf_event_open',
+                      'pipe2',
+                      'pivot_root',
+                      'quotactl',
+                      'remap_file_pages',
+                      'setns',
+                      'shmat',
+                      'shmctl',
+                      'shmdt',
+                      'socket',
+                      'socketpair',
+                      'swapoff',
+                      'swapon',
+                      'unshare',
+                      'uselib']),
+ 'lseek': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'lsetxattr': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'getcwd',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'quotactl',
+                   'remap_file_pages',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'unshare',
+                   'uselib']),
+ 'lstat': set(['fstat', 'lstat', 'newfstat', 'stat']),
+ 'madvise': set(['brk',
+                 'get_mempolicy',
+                 'madvise',
+                 'mincore',
+                 'mlockall',
+                 'mprotect',
+                 'mremap',
+                 'munlock',
+                 'munlockall',
+                 'pkey_mprotect',
+                 'prctl',
+                 'remap_file_pages',
+                 'shmdt']),
+ 'migrate_pages': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioperm',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setresuid',
+                       'setreuid',
+                       'setsid',
+                       'setuid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'mincore': set(['brk',
+                 'capget',
+                 'clone',
+                 'fork',
+                 'get_mempolicy',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioperm',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'madvise',
+                 'migrate_pages',
+                 'mincore',
+                 'mlockall',
+                 'move_pages',
+                 'mprotect',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'mremap',
+                 'msgrcv',
+                 'munlock',
+                 'munlockall',
+                 'perf_event_open',
+                 'pkey_mprotect',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'remap_file_pages',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'shmdt',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'mkdirat': set(['quotactl', 'swapon', 'syncfs', 'umount', 'ustat']),
+ 'mknodat': set(['quotactl', 'swapon', 'syncfs', 'umount', 'ustat']),
+ 'mlock': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'mlock2': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'mlockall': set(['brk',
+                  'capget',
+                  'clone',
+                  'fork',
+                  'get_mempolicy',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'io_cancel',
+                  'io_destroy',
+                  'io_getevents',
+                  'io_setup',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'madvise',
+                  'mbind',
+                  'migrate_pages',
+                  'mincore',
+                  'mlockall',
+                  'modify_ldt',
+                  'move_pages',
+                  'mprotect',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mremap',
+                  'msgrcv',
+                  'munlock',
+                  'munlockall',
+                  'perf_event_open',
+                  'personality',
+                  'pkey_mprotect',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'remap_file_pages',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'shmdt',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'swapoff',
+                  'umount',
+                  'vfork']),
+ 'mmap_pgoff': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'uselib']),
+ 'modify_ldt': set(['brk',
+                    'get_mempolicy',
+                    'get_thread_area',
+                    'getrusage',
+                    'io_cancel',
+                    'io_destroy',
+                    'io_getevents',
+                    'io_setup',
+                    'mbind',
+                    'migrate_pages',
+                    'mincore',
+                    'modify_ldt',
+                    'move_pages',
+                    'mremap',
+                    'prctl',
+                    'remap_file_pages',
+                    'set_thread_area',
+                    'shmdt',
+                    'swapoff']),
+ 'mount': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'mount',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'personality',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'mprotect': set(['brk',
+                  'capget',
+                  'clone',
+                  'fork',
+                  'get_mempolicy',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'madvise',
+                  'migrate_pages',
+                  'mincore',
+                  'mlockall',
+                  'move_pages',
+                  'mprotect',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mremap',
+                  'msgrcv',
+                  'munlock',
+                  'munlockall',
+                  'perf_event_open',
+                  'personality',
+                  'pkey_mprotect',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'remap_file_pages',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'shmdt',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'mq_getsetattr': set(['accept4',
+                       'acct',
+                       'bind',
+                       'bpf',
+                       'connect',
+                       'copy_file_range',
+                       'dup',
+                       'dup3',
+                       'epoll_create1',
+                       'epoll_ctl',
+                       'epoll_wait',
+                       'eventfd2',
+                       'fallocate',
+                       'fchdir',
+                       'fchmod',
+                       'fchown',
+                       'fcntl',
+                       'fcntl64',
+                       'fdatasync',
+                       'fgetxattr',
+                       'flistxattr',
+                       'flock',
+                       'fremovexattr',
+                       'fsetxattr',
+                       'fstatfs',
+                       'fstatfs64',
+                       'fsync',
+                       'ftruncate',
+                       'futimesat',
+                       'getdents',
+                       'getdents64',
+                       'getpeername',
+                       'getsockname',
+                       'getsockopt',
+                       'inotify_add_watch',
+                       'inotify_rm_watch',
+                       'ioctl',
+                       'listen',
+                       'llseek',
+                       'lseek',
+                       'memfd_create',
+                       'mmap_pgoff',
+                       'mq_getsetattr',
+                       'mq_notify',
+                       'mq_open',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'old_readdir',
+                       'open',
+                       'open_by_handle_at',
+                       'openat',
+                       'perf_event_open',
+                       'pipe2',
+                       'pread64',
+                       'preadv',
+                       'preadv2',
+                       'preadv64',
+                       'preadv64v2',
+                       'pwrite64',
+                       'pwritev',
+                       'pwritev2',
+                       'pwritev64',
+                       'pwritev64v2',
+                       'read',
+                       'readahead',
+                       'readv',
+                       'recvfrom',
+                       'remap_file_pages',
+                       'sendfile',
+                       'sendfile64',
+                       'sendto',
+                       'setns',
+                       'setsockopt',
+                       'shmat',
+                       'shmctl',
+                       'shmdt',
+                       'shutdown',
+                       'signalfd4',
+                       'socket',
+                       'socketpair',
+                       'splice',
+                       'swapoff',
+                       'swapon',
+                       'sync_file_range',
+                       'syncfs',
+                       'tee',
+                       'uselib',
+                       'utime',
+                       'utimensat',
+                       'vmsplice',
+                       'write',
+                       'writev']),
+ 'mq_notify': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'eventfd2',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'rt_sigqueueinfo',
+                   'rt_sigreturn',
+                   'rt_sigtimedwait',
+                   'rt_tgsigqueueinfo',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setns',
+                   'setsockopt',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'signalfd4',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'tgkill',
+                   'timer_create',
+                   'tkill',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'mq_open': set(['accept4',
+                 'acct',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'eventfd2',
+                 'flock',
+                 'getcwd',
+                 'lookup_dcookie',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_open',
+                 'mq_unlink',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'pivot_root',
+                 'quotactl',
+                 'remap_file_pages',
+                 'renameat2',
+                 'rmdir',
+                 'setns',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'socket',
+                 'socketpair',
+                 'swapoff',
+                 'swapon',
+                 'symlinkat',
+                 'sysfs',
+                 'unlink',
+                 'unlinkat',
+                 'unshare',
+                 'uselib']),
+ 'mq_timedreceive': set(['accept4',
+                         'acct',
+                         'bind',
+                         'bpf',
+                         'connect',
+                         'copy_file_range',
+                         'dup',
+                         'dup3',
+                         'epoll_create1',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'eventfd2',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchown',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'flistxattr',
+                         'flock',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'getdents',
+                         'getdents64',
+                         'getpeername',
+                         'getsockname',
+                         'getsockopt',
+                         'inotify_add_watch',
+                         'inotify_rm_watch',
+                         'ioctl',
+                         'listen',
+                         'llseek',
+                         'lseek',
+                         'memfd_create',
+                         'mmap_pgoff',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_open',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'msgsnd',
+                         'old_readdir',
+                         'open',
+                         'open_by_handle_at',
+                         'openat',
+                         'perf_event_open',
+                         'pipe2',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'read',
+                         'readahead',
+                         'readv',
+                         'recvfrom',
+                         'remap_file_pages',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'setns',
+                         'setsockopt',
+                         'shmat',
+                         'shmctl',
+                         'shmdt',
+                         'shutdown',
+                         'signalfd4',
+                         'socket',
+                         'socketpair',
+                         'splice',
+                         'swapoff',
+                         'swapon',
+                         'sync_file_range',
+                         'syncfs',
+                         'tee',
+                         'uselib',
+                         'utime',
+                         'utimensat',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'mq_timedsend': set(['accept4',
+                      'acct',
+                      'bind',
+                      'bpf',
+                      'connect',
+                      'copy_file_range',
+                      'dup',
+                      'dup3',
+                      'epoll_create1',
+                      'epoll_ctl',
+                      'epoll_wait',
+                      'eventfd2',
+                      'fallocate',
+                      'fchdir',
+                      'fchmod',
+                      'fchown',
+                      'fcntl',
+                      'fcntl64',
+                      'fdatasync',
+                      'fgetxattr',
+                      'flistxattr',
+                      'flock',
+                      'fremovexattr',
+                      'fsetxattr',
+                      'fstatfs',
+                      'fstatfs64',
+                      'fsync',
+                      'ftruncate',
+                      'futimesat',
+                      'getdents',
+                      'getdents64',
+                      'getpeername',
+                      'getsockname',
+                      'getsockopt',
+                      'inotify_add_watch',
+                      'inotify_rm_watch',
+                      'ioctl',
+                      'listen',
+                      'llseek',
+                      'lseek',
+                      'memfd_create',
+                      'mmap_pgoff',
+                      'mq_getsetattr',
+                      'mq_notify',
+                      'mq_open',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'old_readdir',
+                      'open',
+                      'open_by_handle_at',
+                      'openat',
+                      'perf_event_open',
+                      'pipe2',
+                      'pread64',
+                      'preadv',
+                      'preadv2',
+                      'preadv64',
+                      'preadv64v2',
+                      'pwrite64',
+                      'pwritev',
+                      'pwritev2',
+                      'pwritev64',
+                      'pwritev64v2',
+                      'read',
+                      'readahead',
+                      'readv',
+                      'recvfrom',
+                      'remap_file_pages',
+                      'sendfile',
+                      'sendfile64',
+                      'sendto',
+                      'setns',
+                      'setsockopt',
+                      'shmat',
+                      'shmctl',
+                      'shmdt',
+                      'shutdown',
+                      'signalfd4',
+                      'socket',
+                      'socketpair',
+                      'splice',
+                      'swapoff',
+                      'swapon',
+                      'sync_file_range',
+                      'syncfs',
+                      'tee',
+                      'uselib',
+                      'utime',
+                      'utimensat',
+                      'vmsplice',
+                      'write',
+                      'writev']),
+ 'mremap': set(['brk',
+                'capget',
+                'clone',
+                'fork',
+                'get_mempolicy',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'io_cancel',
+                'io_destroy',
+                'io_getevents',
+                'io_setup',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'madvise',
+                'mbind',
+                'migrate_pages',
+                'mincore',
+                'mlockall',
+                'modify_ldt',
+                'move_pages',
+                'mprotect',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mremap',
+                'msgrcv',
+                'munlock',
+                'munlockall',
+                'perf_event_open',
+                'personality',
+                'pkey_mprotect',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'remap_file_pages',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'shmdt',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'swapoff',
+                'umount',
+                'vfork']),
+ 'msgctl': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgctl',
+                'msgget',
+                'msgrcv',
+                'msgsnd',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semctl',
+                'semget',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'shmat',
+                'shmctl',
+                'shmget',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'msgrcv': set(['mq_timedreceive', 'mq_timedsend', 'msgrcv', 'msgsnd']),
+ 'msgsnd': set(['mq_open',
+                'mq_unlink',
+                'msgctl',
+                'msgget',
+                'msgrcv',
+                'msgsnd',
+                'semctl',
+                'semget',
+                'semtimedop',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmget']),
+ 'munlock': set(['brk',
+                 'capget',
+                 'clone',
+                 'fork',
+                 'get_mempolicy',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'madvise',
+                 'migrate_pages',
+                 'mincore',
+                 'mlockall',
+                 'move_pages',
+                 'mprotect',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'mremap',
+                 'msgrcv',
+                 'munlock',
+                 'munlockall',
+                 'perf_event_open',
+                 'pkey_mprotect',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'remap_file_pages',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'shmdt',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'munlockall': set(['brk',
+                    'get_mempolicy',
+                    'madvise',
+                    'mincore',
+                    'mlockall',
+                    'mprotect',
+                    'mremap',
+                    'munlock',
+                    'munlockall',
+                    'pkey_mprotect',
+                    'prctl',
+                    'remap_file_pages',
+                    'shmdt']),
+ 'name_to_handle_at': set(['accept4',
+                           'acct',
+                           'dup',
+                           'dup3',
+                           'epoll_create1',
+                           'epoll_ctl',
+                           'eventfd2',
+                           'flock',
+                           'getcwd',
+                           'lookup_dcookie',
+                           'memfd_create',
+                           'mmap_pgoff',
+                           'mq_open',
+                           'name_to_handle_at',
+                           'open',
+                           'open_by_handle_at',
+                           'openat',
+                           'perf_event_open',
+                           'pipe2',
+                           'pivot_root',
+                           'quotactl',
+                           'remap_file_pages',
+                           'setns',
+                           'shmat',
+                           'shmctl',
+                           'shmdt',
+                           'socket',
+                           'socketpair',
+                           'swapoff',
+                           'swapon',
+                           'syncfs',
+                           'umount',
+                           'unshare',
+                           'uselib',
+                           'ustat']),
+ 'nanosleep': set(['clock_nanosleep',
+                   'epoll_wait',
+                   'faccessat',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fstat',
+                   'ftruncate',
+                   'futex',
+                   'futimesat',
+                   'inotify_add_watch',
+                   'io_getevents',
+                   'ioctl',
+                   'linkat',
+                   'memfd_create',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'nanosleep',
+                   'newfstat',
+                   'poll',
+                   'ppoll',
+                   'pselect6',
+                   'readlinkat',
+                   'recvmmsg',
+                   'rt_sigtimedwait',
+                   'sched_rr_get_interval',
+                   'select',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'settimeofday',
+                   'stime',
+                   'swapoff',
+                   'swapon',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime']),
+ 'newfstat': set(['fstat', 'newfstat', 'newfstatat', 'newlstat', 'newstat']),
+ 'newfstatat': set(['fstat', 'newfstat', 'newfstatat', 'newlstat', 'newstat']),
+ 'newlstat': set(['fstat', 'newfstat', 'newfstatat', 'newlstat', 'newstat']),
+ 'newstat': set(['fstat', 'newfstat', 'newfstatat', 'newlstat', 'newstat']),
+ 'newuname': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'personality',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'old_getrlimit': set(['old_getrlimit', 'prlimit64', 'setrlimit']),
+ 'old_readdir': set(['accept4',
+                     'bind',
+                     'bpf',
+                     'connect',
+                     'copy_file_range',
+                     'epoll_ctl',
+                     'epoll_wait',
+                     'fallocate',
+                     'fchdir',
+                     'fchmod',
+                     'fchown',
+                     'fcntl',
+                     'fcntl64',
+                     'fdatasync',
+                     'fgetxattr',
+                     'flistxattr',
+                     'flock',
+                     'fremovexattr',
+                     'fsetxattr',
+                     'fstatfs',
+                     'fstatfs64',
+                     'fsync',
+                     'ftruncate',
+                     'futimesat',
+                     'getdents',
+                     'getdents64',
+                     'getpeername',
+                     'getsockname',
+                     'getsockopt',
+                     'inotify_add_watch',
+                     'inotify_rm_watch',
+                     'ioctl',
+                     'listen',
+                     'llseek',
+                     'lseek',
+                     'mq_getsetattr',
+                     'mq_notify',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'old_readdir',
+                     'perf_event_open',
+                     'pread64',
+                     'preadv',
+                     'preadv2',
+                     'preadv64',
+                     'preadv64v2',
+                     'pwrite64',
+                     'pwritev',
+                     'pwritev2',
+                     'pwritev64',
+                     'pwritev64v2',
+                     'read',
+                     'readahead',
+                     'readv',
+                     'recvfrom',
+                     'sendfile',
+                     'sendfile64',
+                     'sendto',
+                     'setsockopt',
+                     'shutdown',
+                     'signalfd4',
+                     'splice',
+                     'sync_file_range',
+                     'syncfs',
+                     'tee',
+                     'utime',
+                     'utimensat',
+                     'vmsplice',
+                     'write',
+                     'writev']),
+ 'olduname': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioperm',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'personality',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'open_by_handle_at': set(['accept4',
+                           'acct',
+                           'dup',
+                           'dup3',
+                           'epoll_create1',
+                           'epoll_ctl',
+                           'eventfd2',
+                           'flock',
+                           'getcwd',
+                           'lookup_dcookie',
+                           'memfd_create',
+                           'mmap_pgoff',
+                           'mq_open',
+                           'open',
+                           'open_by_handle_at',
+                           'openat',
+                           'perf_event_open',
+                           'pipe2',
+                           'pivot_root',
+                           'quotactl',
+                           'remap_file_pages',
+                           'setns',
+                           'shmat',
+                           'shmctl',
+                           'shmdt',
+                           'socket',
+                           'socketpair',
+                           'swapoff',
+                           'swapon',
+                           'unshare',
+                           'uselib']),
+ 'perf_event_open': set(['accept4',
+                         'acct',
+                         'bind',
+                         'bpf',
+                         'brk',
+                         'capget',
+                         'clone',
+                         'connect',
+                         'copy_file_range',
+                         'delete_module',
+                         'dup',
+                         'dup2',
+                         'dup3',
+                         'epoll_create1',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'eventfd2',
+                         'exit_group',
+                         'faccessat',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchmodat',
+                         'fchown',
+                         'fchownat',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'finit_module',
+                         'flistxattr',
+                         'flock',
+                         'fork',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'get_curr_temp',
+                         'get_mempolicy',
+                         'get_robust_list',
+                         'get_trip_temp',
+                         'getcwd',
+                         'getdents',
+                         'getdents64',
+                         'getgroups',
+                         'getgroups16',
+                         'getitimer',
+                         'getpeername',
+                         'getpgid',
+                         'getppid',
+                         'getpriority',
+                         'getrusage',
+                         'getsid',
+                         'getsockname',
+                         'getsockopt',
+                         'init_module',
+                         'inotify_add_watch',
+                         'inotify_init1',
+                         'inotify_rm_watch',
+                         'io_cancel',
+                         'io_destroy',
+                         'io_getevents',
+                         'io_setup',
+                         'io_submit',
+                         'ioctl',
+                         'ioperm',
+                         'ioprio_get',
+                         'ioprio_set',
+                         'kexec_load',
+                         'keyctl',
+                         'kill',
+                         'linkat',
+                         'listen',
+                         'llseek',
+                         'lookup_dcookie',
+                         'lseek',
+                         'madvise',
+                         'mbind',
+                         'memfd_create',
+                         'migrate_pages',
+                         'mincore',
+                         'mkdirat',
+                         'mknodat',
+                         'mlockall',
+                         'mmap_pgoff',
+                         'modify_ldt',
+                         'move_pages',
+                         'mprotect',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_open',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'mq_unlink',
+                         'mremap',
+                         'msgctl',
+                         'msgrcv',
+                         'msgsnd',
+                         'munlock',
+                         'munlockall',
+                         'old_readdir',
+                         'open',
+                         'open_by_handle_at',
+                         'openat',
+                         'perf_event_open',
+                         'pipe2',
+                         'pivot_root',
+                         'pkey_mprotect',
+                         'prctl',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'prlimit64',
+                         'ptrace',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'quotactl',
+                         'read',
+                         'readahead',
+                         'readlinkat',
+                         'readv',
+                         'reboot',
+                         'recvfrom',
+                         'remap_file_pages',
+                         'renameat2',
+                         'request_key',
+                         'rmdir',
+                         'rt_sigaction',
+                         'rt_sigprocmask',
+                         'rt_sigtimedwait',
+                         'sched_getaffinity',
+                         'sched_getattr',
+                         'sched_getparam',
+                         'sched_getscheduler',
+                         'sched_rr_get_interval',
+                         'sched_setaffinity',
+                         'sched_setattr',
+                         'sched_setparam',
+                         'sched_setscheduler',
+                         'sched_yield',
+                         'semctl',
+                         'semtimedop',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'set_trip_temp',
+                         'setgid',
+                         'setgroups',
+                         'setgroups16',
+                         'setitimer',
+                         'setns',
+                         'setpgid',
+                         'setpriority',
+                         'setregid',
+                         'setresgid',
+                         'setresuid',
+                         'setreuid',
+                         'setsid',
+                         'setsockopt',
+                         'setuid',
+                         'shmat',
+                         'shmctl',
+                         'shmdt',
+                         'shutdown',
+                         'sigaction',
+                         'sigaltstack',
+                         'signal',
+                         'signalfd4',
+                         'socket',
+                         'socketpair',
+                         'splice',
+                         'swapoff',
+                         'swapon',
+                         'symlinkat',
+                         'sync_file_range',
+                         'syncfs',
+                         'tee',
+                         'timer_create',
+                         'timer_delete',
+                         'timer_getoverrun',
+                         'timer_gettime',
+                         'timer_settime',
+                         'timerfd_create',
+                         'timerfd_gettime',
+                         'timerfd_settime',
+                         'umount',
+                         'unlink',
+                         'unlinkat',
+                         'unshare',
+                         'uselib',
+                         'ustat',
+                         'utime',
+                         'utimensat',
+                         'vfork',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'pivot_root': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'ftruncate',
+                    'getcwd',
+                    'linkat',
+                    'lookup_dcookie',
+                    'memfd_create',
+                    'mkdirat',
+                    'mknodat',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'mq_unlink',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'pivot_root',
+                    'quotactl',
+                    'remap_file_pages',
+                    'renameat2',
+                    'rmdir',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'symlinkat',
+                    'umount',
+                    'unlink',
+                    'unlinkat',
+                    'unshare',
+                    'uselib']),
+ 'pkey_alloc': set(['brk',
+                    'get_mempolicy',
+                    'getrusage',
+                    'io_cancel',
+                    'io_destroy',
+                    'io_getevents',
+                    'io_setup',
+                    'mbind',
+                    'migrate_pages',
+                    'mincore',
+                    'modify_ldt',
+                    'move_pages',
+                    'mremap',
+                    'pkey_alloc',
+                    'pkey_free',
+                    'prctl',
+                    'remap_file_pages',
+                    'shmdt',
+                    'swapoff']),
+ 'pkey_mprotect': set(['brk',
+                       'capget',
+                       'clone',
+                       'fork',
+                       'get_mempolicy',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'madvise',
+                       'migrate_pages',
+                       'mincore',
+                       'mlockall',
+                       'move_pages',
+                       'mprotect',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'mremap',
+                       'msgrcv',
+                       'munlock',
+                       'munlockall',
+                       'perf_event_open',
+                       'personality',
+                       'pkey_mprotect',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'remap_file_pages',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'shmdt',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'poll': set(['poll', 'ppoll']),
+ 'ppoll': set(['capget',
+               'clock_nanosleep',
+               'clone',
+               'epoll_wait',
+               'faccessat',
+               'fchmod',
+               'fchmodat',
+               'fchown',
+               'fchownat',
+               'fork',
+               'fstat',
+               'ftruncate',
+               'futex',
+               'futimesat',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'inotify_add_watch',
+               'io_getevents',
+               'ioctl',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'linkat',
+               'memfd_create',
+               'migrate_pages',
+               'move_pages',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mq_unlink',
+               'msgrcv',
+               'nanosleep',
+               'newfstat',
+               'perf_event_open',
+               'personality',
+               'poll',
+               'ppoll',
+               'prctl',
+               'prlimit64',
+               'pselect6',
+               'ptrace',
+               'readlinkat',
+               'recvmmsg',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'select',
+               'semtimedop',
+               'sendfile',
+               'sendfile64',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'settimeofday',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'stime',
+               'swapoff',
+               'swapon',
+               'timer_gettime',
+               'timer_settime',
+               'timerfd_gettime',
+               'timerfd_settime',
+               'umount',
+               'unlink',
+               'unlinkat',
+               'uselib',
+               'utime',
+               'vfork']),
+ 'prctl': set(['brk',
+               'capget',
+               'clone',
+               'fork',
+               'get_mempolicy',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'io_cancel',
+               'io_destroy',
+               'io_getevents',
+               'io_setup',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'mbind',
+               'migrate_pages',
+               'mincore',
+               'modify_ldt',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mremap',
+               'msgrcv',
+               'perf_event_open',
+               'personality',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'remap_file_pages',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setresuid',
+               'setreuid',
+               'setsid',
+               'setuid',
+               'shmdt',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'swapoff',
+               'umount',
+               'vfork']),
+ 'pread64': set(['accept4',
+                 'acct',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'eventfd2',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fcntl64',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'old_readdir',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'pread64',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'remap_file_pages',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setns',
+                 'setsockopt',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'shutdown',
+                 'signalfd4',
+                 'socket',
+                 'socketpair',
+                 'splice',
+                 'swapoff',
+                 'swapon',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'uselib',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'preadv': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'splice',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'preadv2': set(['accept4',
+                 'acct',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'eventfd2',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fcntl64',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'old_readdir',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'pread64',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'remap_file_pages',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setns',
+                 'setsockopt',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'shutdown',
+                 'signalfd4',
+                 'socket',
+                 'socketpair',
+                 'splice',
+                 'swapoff',
+                 'swapon',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'uselib',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'preadv64': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'preadv64v2': set(['accept4',
+                    'acct',
+                    'bind',
+                    'bpf',
+                    'connect',
+                    'copy_file_range',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'eventfd2',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'getdents',
+                    'getdents64',
+                    'getpeername',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_open',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'old_readdir',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'remap_file_pages',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setns',
+                    'setsockopt',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'shutdown',
+                    'signalfd4',
+                    'socket',
+                    'socketpair',
+                    'splice',
+                    'swapoff',
+                    'swapon',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'uselib',
+                    'utime',
+                    'utimensat',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'prlimit64': set(['capget',
+                   'capset',
+                   'clone',
+                   'epoll_create1',
+                   'faccessat',
+                   'fork',
+                   'get_robust_list',
+                   'getgroups',
+                   'getgroups16',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getresgid',
+                   'getresgid16',
+                   'getresuid',
+                   'getresuid16',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'old_getrlimit',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setfsgid',
+                   'setfsuid',
+                   'setgid',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresgid',
+                   'setresuid',
+                   'setreuid',
+                   'setrlimit',
+                   'setsid',
+                   'setuid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'unshare',
+                   'vfork']),
+ 'pselect6': set(['capget',
+                  'clock_nanosleep',
+                  'clone',
+                  'epoll_wait',
+                  'faccessat',
+                  'fchmod',
+                  'fchmodat',
+                  'fchown',
+                  'fchownat',
+                  'fork',
+                  'fstat',
+                  'ftruncate',
+                  'futex',
+                  'futimesat',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'inotify_add_watch',
+                  'io_getevents',
+                  'ioctl',
+                  'ioperm',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'linkat',
+                  'memfd_create',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mq_unlink',
+                  'msgrcv',
+                  'nanosleep',
+                  'newfstat',
+                  'perf_event_open',
+                  'poll',
+                  'ppoll',
+                  'prctl',
+                  'prlimit64',
+                  'pselect6',
+                  'ptrace',
+                  'readlinkat',
+                  'recvmmsg',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'select',
+                  'semtimedop',
+                  'sendfile',
+                  'sendfile64',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'settimeofday',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'stime',
+                  'swapoff',
+                  'swapon',
+                  'timer_gettime',
+                  'timer_settime',
+                  'timerfd_gettime',
+                  'timerfd_settime',
+                  'umount',
+                  'unlink',
+                  'unlinkat',
+                  'uselib',
+                  'utime',
+                  'vfork']),
+ 'ptrace': set(['capget',
+                'clone',
+                'epoll_wait',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'pause',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigsuspend',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'sigsuspend',
+                'umount',
+                'vfork']),
+ 'pwrite64': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'pwritev': set(['accept4',
+                 'acct',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'eventfd2',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fcntl64',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'old_readdir',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'pread64',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'remap_file_pages',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setns',
+                 'setsockopt',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'shutdown',
+                 'signalfd4',
+                 'socket',
+                 'socketpair',
+                 'splice',
+                 'swapoff',
+                 'swapon',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'uselib',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'pwritev2': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'pwritev64': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'eventfd2',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setns',
+                   'setsockopt',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'signalfd4',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'pwritev64v2': set(['accept4',
+                     'acct',
+                     'bind',
+                     'bpf',
+                     'connect',
+                     'copy_file_range',
+                     'dup',
+                     'dup3',
+                     'epoll_create1',
+                     'epoll_ctl',
+                     'epoll_wait',
+                     'eventfd2',
+                     'fallocate',
+                     'fchdir',
+                     'fchmod',
+                     'fchown',
+                     'fcntl',
+                     'fcntl64',
+                     'fdatasync',
+                     'fgetxattr',
+                     'flistxattr',
+                     'flock',
+                     'fremovexattr',
+                     'fsetxattr',
+                     'fstatfs',
+                     'fstatfs64',
+                     'fsync',
+                     'ftruncate',
+                     'futimesat',
+                     'getdents',
+                     'getdents64',
+                     'getpeername',
+                     'getsockname',
+                     'getsockopt',
+                     'inotify_add_watch',
+                     'inotify_rm_watch',
+                     'ioctl',
+                     'listen',
+                     'llseek',
+                     'lseek',
+                     'memfd_create',
+                     'mmap_pgoff',
+                     'mq_getsetattr',
+                     'mq_notify',
+                     'mq_open',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'old_readdir',
+                     'open',
+                     'open_by_handle_at',
+                     'openat',
+                     'perf_event_open',
+                     'pipe2',
+                     'pread64',
+                     'preadv',
+                     'preadv2',
+                     'preadv64',
+                     'preadv64v2',
+                     'pwrite64',
+                     'pwritev',
+                     'pwritev2',
+                     'pwritev64',
+                     'pwritev64v2',
+                     'read',
+                     'readahead',
+                     'readv',
+                     'recvfrom',
+                     'remap_file_pages',
+                     'sendfile',
+                     'sendfile64',
+                     'sendto',
+                     'setns',
+                     'setsockopt',
+                     'shmat',
+                     'shmctl',
+                     'shmdt',
+                     'shutdown',
+                     'signalfd4',
+                     'socket',
+                     'socketpair',
+                     'splice',
+                     'swapoff',
+                     'swapon',
+                     'sync_file_range',
+                     'syncfs',
+                     'tee',
+                     'uselib',
+                     'utime',
+                     'utimensat',
+                     'vmsplice',
+                     'write',
+                     'writev']),
+ 'quotactl': set(['acct',
+                  'mq_open',
+                  'mq_unlink',
+                  'open',
+                  'openat',
+                  'quotactl',
+                  'renameat2',
+                  'rmdir',
+                  'swapoff',
+                  'swapon',
+                  'symlinkat',
+                  'syncfs',
+                  'sysfs',
+                  'umount',
+                  'unlink',
+                  'unlinkat',
+                  'uselib',
+                  'ustat']),
+ 'read': set(['accept4',
+              'bind',
+              'bpf',
+              'connect',
+              'copy_file_range',
+              'epoll_ctl',
+              'epoll_wait',
+              'fallocate',
+              'fchdir',
+              'fchmod',
+              'fchown',
+              'fcntl',
+              'fcntl64',
+              'fdatasync',
+              'fgetxattr',
+              'flistxattr',
+              'flock',
+              'fremovexattr',
+              'fsetxattr',
+              'fstatfs',
+              'fstatfs64',
+              'fsync',
+              'ftruncate',
+              'futimesat',
+              'getdents',
+              'getdents64',
+              'getpeername',
+              'getsockname',
+              'getsockopt',
+              'inotify_add_watch',
+              'inotify_rm_watch',
+              'ioctl',
+              'listen',
+              'llseek',
+              'lseek',
+              'mq_getsetattr',
+              'mq_notify',
+              'mq_timedreceive',
+              'mq_timedsend',
+              'old_readdir',
+              'perf_event_open',
+              'pread64',
+              'preadv',
+              'preadv2',
+              'preadv64',
+              'preadv64v2',
+              'pwrite64',
+              'pwritev',
+              'pwritev2',
+              'pwritev64',
+              'pwritev64v2',
+              'read',
+              'readahead',
+              'readv',
+              'recvfrom',
+              'sendfile',
+              'sendfile64',
+              'sendto',
+              'setsockopt',
+              'shutdown',
+              'signalfd4',
+              'splice',
+              'sync_file_range',
+              'syncfs',
+              'tee',
+              'utime',
+              'utimensat',
+              'vmsplice',
+              'write',
+              'writev']),
+ 'readahead': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'eventfd2',
+                   'faccessat',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'linkat',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readlinkat',
+                   'readv',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setns',
+                   'setsockopt',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'signalfd4',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'readlinkat': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'getcwd',
+                    'lookup_dcookie',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'pivot_root',
+                    'quotactl',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'unshare',
+                    'uselib']),
+ 'readv': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'reboot': set(['acct', 'perf_event_open', 'reboot', 'setns']),
+ 'recvfrom': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'recvmmsg': set(['accept4',
+                  'bind',
+                  'clock_nanosleep',
+                  'connect',
+                  'epoll_wait',
+                  'faccessat',
+                  'fchmod',
+                  'fchmodat',
+                  'fchown',
+                  'fchownat',
+                  'fstat',
+                  'ftruncate',
+                  'futex',
+                  'futimesat',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'io_getevents',
+                  'ioctl',
+                  'linkat',
+                  'listen',
+                  'memfd_create',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mq_unlink',
+                  'nanosleep',
+                  'newfstat',
+                  'poll',
+                  'ppoll',
+                  'pselect6',
+                  'readlinkat',
+                  'recvfrom',
+                  'recvmmsg',
+                  'recvmsg',
+                  'rt_sigtimedwait',
+                  'sched_rr_get_interval',
+                  'select',
+                  'semtimedop',
+                  'sendfile',
+                  'sendfile64',
+                  'sendmmsg',
+                  'sendmsg',
+                  'sendto',
+                  'setsockopt',
+                  'settimeofday',
+                  'shutdown',
+                  'stime',
+                  'swapoff',
+                  'swapon',
+                  'timer_gettime',
+                  'timer_settime',
+                  'timerfd_gettime',
+                  'timerfd_settime',
+                  'unlink',
+                  'unlinkat',
+                  'uselib',
+                  'utime']),
+ 'recvmsg': set(['accept4',
+                 'bind',
+                 'connect',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'listen',
+                 'recvfrom',
+                 'recvmmsg',
+                 'recvmsg',
+                 'sendmmsg',
+                 'sendmsg',
+                 'sendto',
+                 'setsockopt',
+                 'shutdown']),
+ 'remap_file_pages': set(['brk',
+                          'get_mempolicy',
+                          'madvise',
+                          'mincore',
+                          'mlockall',
+                          'mprotect',
+                          'mremap',
+                          'munlock',
+                          'munlockall',
+                          'pkey_mprotect',
+                          'prctl',
+                          'remap_file_pages',
+                          'shmdt']),
+ 'removexattr': set(['accept4',
+                     'acct',
+                     'dup',
+                     'dup3',
+                     'epoll_create1',
+                     'epoll_ctl',
+                     'eventfd2',
+                     'flock',
+                     'getcwd',
+                     'lookup_dcookie',
+                     'memfd_create',
+                     'mmap_pgoff',
+                     'mq_open',
+                     'open',
+                     'open_by_handle_at',
+                     'openat',
+                     'perf_event_open',
+                     'pipe2',
+                     'pivot_root',
+                     'quotactl',
+                     'remap_file_pages',
+                     'setns',
+                     'shmat',
+                     'shmctl',
+                     'shmdt',
+                     'socket',
+                     'socketpair',
+                     'swapoff',
+                     'swapon',
+                     'unshare',
+                     'uselib']),
+ 'renameat2': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'ftruncate',
+                   'getcwd',
+                   'linkat',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'mkdirat',
+                   'mknodat',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'mq_unlink',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'quotactl',
+                   'remap_file_pages',
+                   'renameat2',
+                   'rmdir',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'symlinkat',
+                   'sysfs',
+                   'unlink',
+                   'unlinkat',
+                   'unshare',
+                   'uselib']),
+ 'rmdir': set(['accept4',
+               'acct',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'eventfd2',
+               'flock',
+               'ftruncate',
+               'getcwd',
+               'linkat',
+               'lookup_dcookie',
+               'memfd_create',
+               'mkdirat',
+               'mknodat',
+               'mmap_pgoff',
+               'mq_open',
+               'mq_unlink',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pivot_root',
+               'quotactl',
+               'remap_file_pages',
+               'renameat2',
+               'rmdir',
+               'setns',
+               'shmat',
+               'shmctl',
+               'shmdt',
+               'socket',
+               'socketpair',
+               'swapoff',
+               'swapon',
+               'symlinkat',
+               'unlink',
+               'unlinkat',
+               'unshare',
+               'uselib']),
+ 'rt_sigqueueinfo': set(['kill',
+                         'rt_sigqueueinfo',
+                         'rt_sigreturn',
+                         'rt_sigtimedwait',
+                         'rt_tgsigqueueinfo',
+                         'tgkill',
+                         'timer_create',
+                         'tkill']),
+ 'rt_sigreturn': set(['capget',
+                      'clone',
+                      'fork',
+                      'get_robust_list',
+                      'getitimer',
+                      'getpgid',
+                      'getppid',
+                      'getpriority',
+                      'getrusage',
+                      'getsid',
+                      'ioperm',
+                      'ioprio_get',
+                      'ioprio_set',
+                      'keyctl',
+                      'kill',
+                      'migrate_pages',
+                      'move_pages',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'msgrcv',
+                      'perf_event_open',
+                      'prctl',
+                      'prlimit64',
+                      'ptrace',
+                      'rt_sigaction',
+                      'rt_sigprocmask',
+                      'rt_sigreturn',
+                      'rt_sigtimedwait',
+                      'sched_getaffinity',
+                      'sched_getattr',
+                      'sched_getparam',
+                      'sched_getscheduler',
+                      'sched_rr_get_interval',
+                      'sched_setaffinity',
+                      'sched_setattr',
+                      'sched_setparam',
+                      'sched_setscheduler',
+                      'semtimedop',
+                      'setitimer',
+                      'setns',
+                      'setpgid',
+                      'setpriority',
+                      'setsid',
+                      'sigaction',
+                      'sigaltstack',
+                      'signal',
+                      'umount',
+                      'vfork']),
+ 'rt_sigtimedwait': set(['capget',
+                         'clone',
+                         'fork',
+                         'get_robust_list',
+                         'getitimer',
+                         'getpgid',
+                         'getppid',
+                         'getpriority',
+                         'getrusage',
+                         'getsid',
+                         'ioperm',
+                         'ioprio_get',
+                         'ioprio_set',
+                         'keyctl',
+                         'kill',
+                         'migrate_pages',
+                         'move_pages',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'perf_event_open',
+                         'prctl',
+                         'prlimit64',
+                         'ptrace',
+                         'rt_sigaction',
+                         'rt_sigprocmask',
+                         'rt_sigqueueinfo',
+                         'rt_sigreturn',
+                         'rt_sigtimedwait',
+                         'rt_tgsigqueueinfo',
+                         'sched_getaffinity',
+                         'sched_getattr',
+                         'sched_getparam',
+                         'sched_getscheduler',
+                         'sched_rr_get_interval',
+                         'sched_setaffinity',
+                         'sched_setattr',
+                         'sched_setparam',
+                         'sched_setscheduler',
+                         'semtimedop',
+                         'setitimer',
+                         'setns',
+                         'setpgid',
+                         'setpriority',
+                         'setsid',
+                         'sigaction',
+                         'sigaltstack',
+                         'signal',
+                         'tgkill',
+                         'timer_create',
+                         'tkill',
+                         'umount',
+                         'vfork']),
+ 'rt_tgsigqueueinfo': set(['kill',
+                           'rt_sigqueueinfo',
+                           'rt_sigreturn',
+                           'rt_sigtimedwait',
+                           'rt_tgsigqueueinfo',
+                           'tgkill',
+                           'timer_create',
+                           'tkill']),
+ 'sched_getattr': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioperm',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'sched_getparam': set(['capget',
+                        'clone',
+                        'fork',
+                        'get_robust_list',
+                        'getitimer',
+                        'getpgid',
+                        'getppid',
+                        'getpriority',
+                        'getrusage',
+                        'getsid',
+                        'ioprio_get',
+                        'ioprio_set',
+                        'keyctl',
+                        'kill',
+                        'migrate_pages',
+                        'move_pages',
+                        'mq_timedreceive',
+                        'mq_timedsend',
+                        'msgrcv',
+                        'perf_event_open',
+                        'prctl',
+                        'prlimit64',
+                        'ptrace',
+                        'rt_sigaction',
+                        'rt_sigprocmask',
+                        'rt_sigtimedwait',
+                        'sched_getaffinity',
+                        'sched_getattr',
+                        'sched_getparam',
+                        'sched_getscheduler',
+                        'sched_rr_get_interval',
+                        'sched_setaffinity',
+                        'sched_setattr',
+                        'sched_setparam',
+                        'sched_setscheduler',
+                        'semtimedop',
+                        'setitimer',
+                        'setns',
+                        'setpgid',
+                        'setpriority',
+                        'setsid',
+                        'sigaction',
+                        'sigaltstack',
+                        'signal',
+                        'umount',
+                        'vfork']),
+ 'sched_getscheduler': set(['capget',
+                            'clone',
+                            'fork',
+                            'get_robust_list',
+                            'getitimer',
+                            'getpgid',
+                            'getppid',
+                            'getpriority',
+                            'getrusage',
+                            'getsid',
+                            'ioprio_get',
+                            'ioprio_set',
+                            'keyctl',
+                            'kill',
+                            'migrate_pages',
+                            'move_pages',
+                            'mq_timedreceive',
+                            'mq_timedsend',
+                            'msgrcv',
+                            'perf_event_open',
+                            'prctl',
+                            'prlimit64',
+                            'ptrace',
+                            'rt_sigaction',
+                            'rt_sigprocmask',
+                            'rt_sigtimedwait',
+                            'sched_getaffinity',
+                            'sched_getattr',
+                            'sched_getparam',
+                            'sched_getscheduler',
+                            'sched_rr_get_interval',
+                            'sched_setaffinity',
+                            'sched_setattr',
+                            'sched_setparam',
+                            'sched_setscheduler',
+                            'semtimedop',
+                            'setitimer',
+                            'setns',
+                            'setpgid',
+                            'setpriority',
+                            'setsid',
+                            'sigaction',
+                            'sigaltstack',
+                            'signal',
+                            'umount',
+                            'vfork']),
+ 'sched_rr_get_interval': set(['sched_rr_get_interval']),
+ 'sched_setaffinity': set(['capget',
+                           'capset',
+                           'clone',
+                           'epoll_create1',
+                           'faccessat',
+                           'fork',
+                           'get_robust_list',
+                           'getgroups',
+                           'getgroups16',
+                           'getitimer',
+                           'getpgid',
+                           'getppid',
+                           'getpriority',
+                           'getresgid',
+                           'getresgid16',
+                           'getresuid',
+                           'getresuid16',
+                           'getrusage',
+                           'getsid',
+                           'ioprio_get',
+                           'ioprio_set',
+                           'keyctl',
+                           'kill',
+                           'migrate_pages',
+                           'move_pages',
+                           'mq_timedreceive',
+                           'mq_timedsend',
+                           'msgrcv',
+                           'perf_event_open',
+                           'prctl',
+                           'prlimit64',
+                           'ptrace',
+                           'rt_sigaction',
+                           'rt_sigprocmask',
+                           'rt_sigtimedwait',
+                           'sched_getaffinity',
+                           'sched_getattr',
+                           'sched_getparam',
+                           'sched_getscheduler',
+                           'sched_rr_get_interval',
+                           'sched_setaffinity',
+                           'sched_setattr',
+                           'sched_setparam',
+                           'sched_setscheduler',
+                           'semtimedop',
+                           'setfsgid',
+                           'setfsuid',
+                           'setgid',
+                           'setitimer',
+                           'setns',
+                           'setpgid',
+                           'setpriority',
+                           'setregid',
+                           'setresgid',
+                           'setresuid',
+                           'setreuid',
+                           'setsid',
+                           'setuid',
+                           'sigaction',
+                           'sigaltstack',
+                           'signal',
+                           'umount',
+                           'unshare',
+                           'vfork']),
+ 'sched_setattr': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioperm',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'select': set(['capget',
+                'clock_nanosleep',
+                'clone',
+                'dup2',
+                'dup3',
+                'epoll_wait',
+                'faccessat',
+                'fchmod',
+                'fchmodat',
+                'fchown',
+                'fchownat',
+                'fork',
+                'fstat',
+                'ftruncate',
+                'futex',
+                'futimesat',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'inotify_add_watch',
+                'io_getevents',
+                'ioctl',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'linkat',
+                'memfd_create',
+                'migrate_pages',
+                'move_pages',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgrcv',
+                'nanosleep',
+                'newfstat',
+                'perf_event_open',
+                'personality',
+                'poll',
+                'ppoll',
+                'prctl',
+                'prlimit64',
+                'pselect6',
+                'ptrace',
+                'readlinkat',
+                'recvmmsg',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'select',
+                'semtimedop',
+                'sendfile',
+                'sendfile64',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'settimeofday',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'stime',
+                'swapoff',
+                'swapon',
+                'timer_gettime',
+                'timer_settime',
+                'timerfd_gettime',
+                'timerfd_settime',
+                'umount',
+                'unlink',
+                'unlinkat',
+                'unshare',
+                'uselib',
+                'utime',
+                'vfork']),
+ 'semctl': set(['semctl', 'semtimedop']),
+ 'semtimedop': set(['accept4',
+                    'acct',
+                    'bpf',
+                    'brk',
+                    'capget',
+                    'clock_nanosleep',
+                    'clone',
+                    'delete_module',
+                    'dup',
+                    'dup2',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'eventfd2',
+                    'exit_group',
+                    'faccessat',
+                    'fchmod',
+                    'fchmodat',
+                    'fchown',
+                    'fchownat',
+                    'finit_module',
+                    'flock',
+                    'fork',
+                    'fstat',
+                    'ftruncate',
+                    'futex',
+                    'futimesat',
+                    'get_curr_temp',
+                    'get_mempolicy',
+                    'get_robust_list',
+                    'get_trip_temp',
+                    'getcwd',
+                    'getgroups',
+                    'getgroups16',
+                    'getitimer',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'init_module',
+                    'inotify_add_watch',
+                    'inotify_init1',
+                    'inotify_rm_watch',
+                    'io_cancel',
+                    'io_destroy',
+                    'io_getevents',
+                    'io_setup',
+                    'io_submit',
+                    'ioctl',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'kexec_load',
+                    'keyctl',
+                    'kill',
+                    'linkat',
+                    'lookup_dcookie',
+                    'madvise',
+                    'mbind',
+                    'memfd_create',
+                    'migrate_pages',
+                    'mincore',
+                    'mkdirat',
+                    'mknodat',
+                    'mlockall',
+                    'mmap_pgoff',
+                    'modify_ldt',
+                    'move_pages',
+                    'mprotect',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_open',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'mq_unlink',
+                    'mremap',
+                    'msgctl',
+                    'msgrcv',
+                    'msgsnd',
+                    'munlock',
+                    'munlockall',
+                    'nanosleep',
+                    'newfstat',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'pivot_root',
+                    'pkey_mprotect',
+                    'poll',
+                    'ppoll',
+                    'prctl',
+                    'prlimit64',
+                    'pselect6',
+                    'ptrace',
+                    'quotactl',
+                    'readahead',
+                    'readlinkat',
+                    'reboot',
+                    'recvmmsg',
+                    'remap_file_pages',
+                    'renameat2',
+                    'request_key',
+                    'rmdir',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'sched_yield',
+                    'select',
+                    'semctl',
+                    'semtimedop',
+                    'sendfile',
+                    'sendfile64',
+                    'set_trip_temp',
+                    'setgid',
+                    'setgroups',
+                    'setgroups16',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setregid',
+                    'setresgid',
+                    'setresuid',
+                    'setreuid',
+                    'setsid',
+                    'settimeofday',
+                    'setuid',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'socket',
+                    'socketpair',
+                    'splice',
+                    'stime',
+                    'swapoff',
+                    'swapon',
+                    'symlinkat',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'timer_create',
+                    'timer_delete',
+                    'timer_getoverrun',
+                    'timer_gettime',
+                    'timer_settime',
+                    'timerfd_create',
+                    'timerfd_gettime',
+                    'timerfd_settime',
+                    'umount',
+                    'unlink',
+                    'unlinkat',
+                    'unshare',
+                    'uselib',
+                    'ustat',
+                    'utime',
+                    'vfork',
+                    'vmsplice']),
+ 'sendfile': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'sendfile64': set(['accept4',
+                    'acct',
+                    'bind',
+                    'bpf',
+                    'connect',
+                    'copy_file_range',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'eventfd2',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'getdents',
+                    'getdents64',
+                    'getpeername',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_open',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'old_readdir',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'remap_file_pages',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setns',
+                    'setsockopt',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'shutdown',
+                    'signalfd4',
+                    'socket',
+                    'socketpair',
+                    'splice',
+                    'swapoff',
+                    'swapon',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'uselib',
+                    'utime',
+                    'utimensat',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'sendmmsg': set(['accept4',
+                  'bind',
+                  'connect',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'listen',
+                  'recvfrom',
+                  'recvmmsg',
+                  'recvmsg',
+                  'sendmmsg',
+                  'sendmsg',
+                  'sendto',
+                  'setsockopt',
+                  'shutdown']),
+ 'sendmsg': set(['accept4',
+                 'bind',
+                 'connect',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'listen',
+                 'recvfrom',
+                 'recvmmsg',
+                 'recvmsg',
+                 'sendmmsg',
+                 'sendmsg',
+                 'sendto',
+                 'setsockopt',
+                 'shutdown']),
+ 'sendto': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'splice',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'set_mempolicy': set(['get_mempolicy', 'mbind', 'set_mempolicy']),
+ 'set_thread_area': set(['arch_prctl',
+                         'capget',
+                         'clone',
+                         'fork',
+                         'get_robust_list',
+                         'getitimer',
+                         'getpgid',
+                         'getppid',
+                         'getpriority',
+                         'getrusage',
+                         'getsid',
+                         'ioperm',
+                         'ioprio_get',
+                         'ioprio_set',
+                         'keyctl',
+                         'kill',
+                         'migrate_pages',
+                         'move_pages',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'perf_event_open',
+                         'prctl',
+                         'prlimit64',
+                         'ptrace',
+                         'rt_sigaction',
+                         'rt_sigprocmask',
+                         'rt_sigtimedwait',
+                         'sched_getaffinity',
+                         'sched_getattr',
+                         'sched_getparam',
+                         'sched_getscheduler',
+                         'sched_rr_get_interval',
+                         'sched_setaffinity',
+                         'sched_setattr',
+                         'sched_setparam',
+                         'sched_setscheduler',
+                         'semtimedop',
+                         'setitimer',
+                         'setns',
+                         'setpgid',
+                         'setpriority',
+                         'setsid',
+                         'sigaction',
+                         'sigaltstack',
+                         'signal',
+                         'umount',
+                         'vfork']),
+ 'set_trip_temp': set(['get_curr_temp', 'get_trip_temp', 'set_trip_temp']),
+ 'setdomainname': set(['setns']),
+ 'setfsgid': set(['capget',
+                  'capset',
+                  'clone',
+                  'epoll_create1',
+                  'faccessat',
+                  'fork',
+                  'get_robust_list',
+                  'getgroups',
+                  'getgroups16',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getresgid',
+                  'getresgid16',
+                  'getresuid',
+                  'getresuid16',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setfsgid',
+                  'setfsuid',
+                  'setgid',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setregid',
+                  'setresgid',
+                  'setresuid',
+                  'setreuid',
+                  'setsid',
+                  'setuid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'unshare',
+                  'vfork']),
+ 'setfsuid': set(['capget',
+                  'capset',
+                  'clone',
+                  'epoll_create1',
+                  'faccessat',
+                  'fork',
+                  'get_robust_list',
+                  'getgroups',
+                  'getgroups16',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getresgid',
+                  'getresgid16',
+                  'getresuid',
+                  'getresuid16',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setfsgid',
+                  'setfsuid',
+                  'setgid',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setregid',
+                  'setresgid',
+                  'setresuid',
+                  'setreuid',
+                  'setsid',
+                  'setuid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'unshare',
+                  'vfork']),
+ 'setgid': set(['capget',
+                'capset',
+                'clone',
+                'epoll_create1',
+                'faccessat',
+                'fork',
+                'get_robust_list',
+                'getgroups',
+                'getgroups16',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getresgid',
+                'getresgid16',
+                'getresuid',
+                'getresuid16',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setfsgid',
+                'setfsuid',
+                'setgid',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setregid',
+                'setresgid',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'unshare',
+                'vfork']),
+ 'setgroups16': set(['setgroups', 'setgroups16']),
+ 'sethostname': set(['setns']),
+ 'setitimer': set(['adjtimex',
+                   'alarm',
+                   'clock_adjtime',
+                   'exit_group',
+                   'getitimer',
+                   'getrusage',
+                   'ppoll',
+                   'select',
+                   'setitimer',
+                   'settimeofday',
+                   'timer_create',
+                   'wait4',
+                   'waitid']),
+ 'setns': set(['setns']),
+ 'setpgid': set(['capget',
+                 'clone',
+                 'exit_group',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'perf_event_open',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setresuid',
+                 'setreuid',
+                 'setsid',
+                 'setuid',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'timer_create',
+                 'umount',
+                 'vfork']),
+ 'setpriority': set(['capget',
+                     'clone',
+                     'fork',
+                     'get_robust_list',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getpriority',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setpriority',
+                     'setresuid',
+                     'setreuid',
+                     'setsid',
+                     'setuid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'vfork']),
+ 'setregid': set(['capget',
+                  'capset',
+                  'clone',
+                  'epoll_create1',
+                  'faccessat',
+                  'fork',
+                  'get_robust_list',
+                  'getgroups',
+                  'getgroups16',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getresgid',
+                  'getresgid16',
+                  'getresuid',
+                  'getresuid16',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setfsgid',
+                  'setfsuid',
+                  'setgid',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setregid',
+                  'setresgid',
+                  'setresuid',
+                  'setreuid',
+                  'setsid',
+                  'setuid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'unshare',
+                  'vfork']),
+ 'setresgid': set(['capget',
+                   'capset',
+                   'clone',
+                   'epoll_create1',
+                   'faccessat',
+                   'fork',
+                   'get_robust_list',
+                   'getgroups',
+                   'getgroups16',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getresgid',
+                   'getresgid16',
+                   'getresuid',
+                   'getresuid16',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setfsgid',
+                   'setfsuid',
+                   'setgid',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresgid',
+                   'setresuid',
+                   'setreuid',
+                   'setsid',
+                   'setuid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'unshare',
+                   'vfork']),
+ 'setresuid': set(['capget',
+                   'capset',
+                   'clone',
+                   'epoll_create1',
+                   'faccessat',
+                   'fork',
+                   'get_robust_list',
+                   'getgroups',
+                   'getgroups16',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getresgid',
+                   'getresgid16',
+                   'getresuid',
+                   'getresuid16',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setfsgid',
+                   'setfsuid',
+                   'setgid',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresgid',
+                   'setresuid',
+                   'setreuid',
+                   'setsid',
+                   'setuid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'unshare',
+                   'vfork']),
+ 'setreuid': set(['capget',
+                  'capset',
+                  'clone',
+                  'epoll_create1',
+                  'faccessat',
+                  'fork',
+                  'get_robust_list',
+                  'getgroups',
+                  'getgroups16',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getresgid',
+                  'getresgid16',
+                  'getresuid',
+                  'getresuid16',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setfsgid',
+                  'setfsuid',
+                  'setgid',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setregid',
+                  'setresgid',
+                  'setresuid',
+                  'setreuid',
+                  'setsid',
+                  'setuid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'unshare',
+                  'vfork']),
+ 'setrlimit': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrlimit',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'old_getrlimit',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setrlimit',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'setsid': set(['exit_group', 'setsid', 'timer_create']),
+ 'setsockopt': set(['accept4',
+                    'bind',
+                    'bpf',
+                    'connect',
+                    'copy_file_range',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'getdents',
+                    'getdents64',
+                    'getpeername',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'old_readdir',
+                    'perf_event_open',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setsockopt',
+                    'shutdown',
+                    'signalfd4',
+                    'splice',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'utime',
+                    'utimensat',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'settimeofday': set(['adjtimex',
+                      'alarm',
+                      'clock_adjtime',
+                      'getitimer',
+                      'getrusage',
+                      'ppoll',
+                      'select',
+                      'setitimer',
+                      'settimeofday',
+                      'wait4',
+                      'waitid']),
+ 'setuid': set(['capget',
+                'capset',
+                'clone',
+                'epoll_create1',
+                'faccessat',
+                'fork',
+                'get_robust_list',
+                'getgroups',
+                'getgroups16',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getresgid',
+                'getresgid16',
+                'getresuid',
+                'getresuid16',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setfsgid',
+                'setfsuid',
+                'setgid',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setregid',
+                'setresgid',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'unshare',
+                'vfork']),
+ 'setxattr': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'getcwd',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'unshare',
+                  'uselib']),
+ 'shmat': set(['accept4',
+               'acct',
+               'capget',
+               'clone',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'eventfd2',
+               'flock',
+               'fork',
+               'get_robust_list',
+               'getcwd',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'lookup_dcookie',
+               'memfd_create',
+               'migrate_pages',
+               'mmap_pgoff',
+               'move_pages',
+               'mq_open',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pivot_root',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'quotactl',
+               'remap_file_pages',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'shmat',
+               'shmctl',
+               'shmdt',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'socket',
+               'socketpair',
+               'swapoff',
+               'swapon',
+               'umount',
+               'unshare',
+               'uselib',
+               'vfork']),
+ 'shmctl': set(['accept4',
+                'acct',
+                'capget',
+                'clone',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'memfd_create',
+                'migrate_pages',
+                'mmap_pgoff',
+                'move_pages',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgctl',
+                'msgget',
+                'msgrcv',
+                'msgsnd',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'remap_file_pages',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semctl',
+                'semget',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shmget',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'umount',
+                'uselib',
+                'vfork']),
+ 'shmdt': set(['brk',
+               'get_mempolicy',
+               'madvise',
+               'mincore',
+               'mlockall',
+               'mprotect',
+               'mremap',
+               'munlock',
+               'munlockall',
+               'pkey_mprotect',
+               'prctl',
+               'remap_file_pages',
+               'shmdt']),
+ 'shutdown': set(['accept4',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'old_readdir',
+                  'perf_event_open',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setsockopt',
+                  'shutdown',
+                  'signalfd4',
+                  'splice',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'utime',
+                  'utimensat',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'sigaction': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioperm',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'signalfd4': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'eventfd2',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setns',
+                   'setsockopt',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'signalfd4',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'splice': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'splice',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'stat': set(['fstat', 'lstat', 'newfstat', 'stat']),
+ 'statfs': set(['fstatfs', 'fstatfs64', 'statfs', 'statfs64', 'ustat']),
+ 'statfs64': set(['fstatfs', 'fstatfs64', 'statfs', 'statfs64', 'ustat']),
+ 'swapoff': set(['accept4',
+                 'acct',
+                 'capget',
+                 'clone',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'eventfd2',
+                 'flock',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'memfd_create',
+                 'migrate_pages',
+                 'mmap_pgoff',
+                 'move_pages',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'remap_file_pages',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'socket',
+                 'socketpair',
+                 'swapoff',
+                 'swapon',
+                 'umount',
+                 'uselib',
+                 'vfork']),
+ 'swapon': set(['faccessat',
+                'fchmod',
+                'fchmodat',
+                'fchown',
+                'fchownat',
+                'ftruncate',
+                'inotify_add_watch',
+                'ioctl',
+                'linkat',
+                'memfd_create',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'readlinkat',
+                'sendfile',
+                'sendfile64',
+                'swapoff',
+                'swapon',
+                'unlink',
+                'unlinkat',
+                'uselib']),
+ 'symlinkat': set(['acct',
+                   'mq_open',
+                   'mq_unlink',
+                   'open',
+                   'openat',
+                   'quotactl',
+                   'renameat2',
+                   'rmdir',
+                   'swapoff',
+                   'swapon',
+                   'symlinkat',
+                   'sysfs',
+                   'unlink',
+                   'unlinkat',
+                   'uselib']),
+ 'sync_file_range': set(['accept4',
+                         'bind',
+                         'bpf',
+                         'connect',
+                         'copy_file_range',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchown',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'flistxattr',
+                         'flock',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'getdents',
+                         'getdents64',
+                         'getpeername',
+                         'getsockname',
+                         'getsockopt',
+                         'inotify_add_watch',
+                         'inotify_rm_watch',
+                         'ioctl',
+                         'listen',
+                         'llseek',
+                         'lseek',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'old_readdir',
+                         'perf_event_open',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'read',
+                         'readahead',
+                         'readv',
+                         'recvfrom',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'setsockopt',
+                         'shutdown',
+                         'signalfd4',
+                         'splice',
+                         'sync_file_range',
+                         'syncfs',
+                         'tee',
+                         'utime',
+                         'utimensat',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'syncfs': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'sysctl': set(['sysctl']),
+ 'sysfs': set(['acct',
+               'mq_open',
+               'mq_unlink',
+               'open',
+               'openat',
+               'quotactl',
+               'renameat2',
+               'rmdir',
+               'swapoff',
+               'swapon',
+               'symlinkat',
+               'sysfs',
+               'unlink',
+               'unlinkat',
+               'uselib']),
+ 'sysinfo': set(['capget',
+                 'clock_nanosleep',
+                 'clone',
+                 'epoll_wait',
+                 'faccessat',
+                 'fchmod',
+                 'fchmodat',
+                 'fchown',
+                 'fchownat',
+                 'fork',
+                 'fstat',
+                 'ftruncate',
+                 'futex',
+                 'futimesat',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'inotify_add_watch',
+                 'io_getevents',
+                 'ioctl',
+                 'ioperm',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'linkat',
+                 'memfd_create',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'mq_unlink',
+                 'msgrcv',
+                 'nanosleep',
+                 'newfstat',
+                 'perf_event_open',
+                 'poll',
+                 'ppoll',
+                 'prctl',
+                 'prlimit64',
+                 'pselect6',
+                 'ptrace',
+                 'readlinkat',
+                 'recvmmsg',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'select',
+                 'semtimedop',
+                 'sendfile',
+                 'sendfile64',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'settimeofday',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'stime',
+                 'swapoff',
+                 'swapon',
+                 'sysinfo',
+                 'timer_gettime',
+                 'timer_settime',
+                 'timerfd_gettime',
+                 'timerfd_settime',
+                 'umount',
+                 'unlink',
+                 'unlinkat',
+                 'uselib',
+                 'utime',
+                 'vfork']),
+ 'syslog': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'tee': set(['accept4',
+             'acct',
+             'bind',
+             'bpf',
+             'connect',
+             'copy_file_range',
+             'dup',
+             'dup3',
+             'epoll_create1',
+             'epoll_ctl',
+             'epoll_wait',
+             'eventfd2',
+             'fallocate',
+             'fchdir',
+             'fchmod',
+             'fchown',
+             'fcntl',
+             'fcntl64',
+             'fdatasync',
+             'fgetxattr',
+             'flistxattr',
+             'flock',
+             'fremovexattr',
+             'fsetxattr',
+             'fstatfs',
+             'fstatfs64',
+             'fsync',
+             'ftruncate',
+             'futimesat',
+             'getdents',
+             'getdents64',
+             'getpeername',
+             'getsockname',
+             'getsockopt',
+             'inotify_add_watch',
+             'inotify_rm_watch',
+             'ioctl',
+             'listen',
+             'llseek',
+             'lseek',
+             'memfd_create',
+             'mmap_pgoff',
+             'mq_getsetattr',
+             'mq_notify',
+             'mq_open',
+             'mq_timedreceive',
+             'mq_timedsend',
+             'old_readdir',
+             'open',
+             'open_by_handle_at',
+             'openat',
+             'perf_event_open',
+             'pipe2',
+             'pread64',
+             'preadv',
+             'preadv2',
+             'preadv64',
+             'preadv64v2',
+             'pwrite64',
+             'pwritev',
+             'pwritev2',
+             'pwritev64',
+             'pwritev64v2',
+             'read',
+             'readahead',
+             'readv',
+             'recvfrom',
+             'remap_file_pages',
+             'sendfile',
+             'sendfile64',
+             'sendto',
+             'setns',
+             'setsockopt',
+             'shmat',
+             'shmctl',
+             'shmdt',
+             'shutdown',
+             'signalfd4',
+             'socket',
+             'socketpair',
+             'splice',
+             'swapoff',
+             'swapon',
+             'sync_file_range',
+             'syncfs',
+             'tee',
+             'uselib',
+             'utime',
+             'utimensat',
+             'vmsplice',
+             'write',
+             'writev']),
+ 'tgkill': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'timer_create': set(['clock_adjtime',
+                      'clock_getres',
+                      'clock_gettime',
+                      'clock_nanosleep',
+                      'clock_settime',
+                      'timer_create',
+                      'timer_delete',
+                      'timer_getoverrun',
+                      'timer_gettime',
+                      'timer_settime']),
+ 'timer_delete': set(['capget',
+                      'clock_adjtime',
+                      'clock_getres',
+                      'clock_gettime',
+                      'clock_nanosleep',
+                      'clock_settime',
+                      'clone',
+                      'fork',
+                      'get_robust_list',
+                      'getitimer',
+                      'getpgid',
+                      'getppid',
+                      'getpriority',
+                      'getrusage',
+                      'getsid',
+                      'ioprio_get',
+                      'ioprio_set',
+                      'keyctl',
+                      'kill',
+                      'migrate_pages',
+                      'move_pages',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'msgrcv',
+                      'perf_event_open',
+                      'prctl',
+                      'prlimit64',
+                      'ptrace',
+                      'rt_sigaction',
+                      'rt_sigprocmask',
+                      'rt_sigtimedwait',
+                      'sched_getaffinity',
+                      'sched_getattr',
+                      'sched_getparam',
+                      'sched_getscheduler',
+                      'sched_rr_get_interval',
+                      'sched_setaffinity',
+                      'sched_setattr',
+                      'sched_setparam',
+                      'sched_setscheduler',
+                      'semtimedop',
+                      'setitimer',
+                      'setns',
+                      'setpgid',
+                      'setpriority',
+                      'setsid',
+                      'sigaction',
+                      'sigaltstack',
+                      'signal',
+                      'timer_create',
+                      'timer_delete',
+                      'timer_getoverrun',
+                      'timer_gettime',
+                      'timer_settime',
+                      'umount',
+                      'vfork']),
+ 'timer_getoverrun': set(['capget',
+                          'clone',
+                          'fork',
+                          'get_robust_list',
+                          'getitimer',
+                          'getpgid',
+                          'getppid',
+                          'getpriority',
+                          'getrusage',
+                          'getsid',
+                          'ioprio_get',
+                          'ioprio_set',
+                          'keyctl',
+                          'kill',
+                          'migrate_pages',
+                          'move_pages',
+                          'mq_timedreceive',
+                          'mq_timedsend',
+                          'msgrcv',
+                          'perf_event_open',
+                          'prctl',
+                          'prlimit64',
+                          'ptrace',
+                          'rt_sigaction',
+                          'rt_sigprocmask',
+                          'rt_sigtimedwait',
+                          'sched_getaffinity',
+                          'sched_getattr',
+                          'sched_getparam',
+                          'sched_getscheduler',
+                          'sched_rr_get_interval',
+                          'sched_setaffinity',
+                          'sched_setattr',
+                          'sched_setparam',
+                          'sched_setscheduler',
+                          'semtimedop',
+                          'setitimer',
+                          'setns',
+                          'setpgid',
+                          'setpriority',
+                          'setsid',
+                          'sigaction',
+                          'sigaltstack',
+                          'signal',
+                          'timer_create',
+                          'timer_delete',
+                          'timer_getoverrun',
+                          'timer_gettime',
+                          'timer_settime',
+                          'umount',
+                          'vfork']),
+ 'timer_gettime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime',
+                       'timer_settime']),
+ 'timer_settime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime',
+                       'timer_settime']),
+ 'timerfd_create': set(['timerfd_create',
+                        'timerfd_gettime',
+                        'timerfd_settime']),
+ 'timerfd_gettime': set(['timerfd_create',
+                         'timerfd_gettime',
+                         'timerfd_settime']),
+ 'timerfd_settime': set(['timerfd_create',
+                         'timerfd_gettime',
+                         'timerfd_settime']),
+ 'tkill': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'umount': set(['accept4',
+                'acct',
+                'capget',
+                'clone',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'fork',
+                'get_robust_list',
+                'getcwd',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'lookup_dcookie',
+                'memfd_create',
+                'migrate_pages',
+                'mmap_pgoff',
+                'move_pages',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgrcv',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'quotactl',
+                'remap_file_pages',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'syncfs',
+                'umount',
+                'unshare',
+                'uselib',
+                'ustat',
+                'vfork']),
+ 'uname': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'personality',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'unlink': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'ftruncate',
+                'getcwd',
+                'linkat',
+                'lookup_dcookie',
+                'memfd_create',
+                'mkdirat',
+                'mknodat',
+                'mmap_pgoff',
+                'mq_open',
+                'mq_unlink',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'quotactl',
+                'remap_file_pages',
+                'renameat2',
+                'rmdir',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'symlinkat',
+                'unlink',
+                'unlinkat',
+                'unshare',
+                'uselib']),
+ 'unlinkat': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'ftruncate',
+                  'getcwd',
+                  'linkat',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mkdirat',
+                  'mknodat',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'mq_unlink',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'renameat2',
+                  'rmdir',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'symlinkat',
+                  'unlink',
+                  'unlinkat',
+                  'unshare',
+                  'uselib']),
+ 'unshare': set(['unshare']),
+ 'uselib': set(['acct',
+                'getcwd',
+                'mq_open',
+                'mq_unlink',
+                'pivot_root',
+                'quotactl',
+                'swapon',
+                'syncfs',
+                'umount',
+                'uselib',
+                'ustat']),
+ 'ustat': set(['quotactl', 'swapon', 'syncfs', 'umount', 'ustat']),
+ 'utime': set(['accept4',
+               'bind',
+               'bpf',
+               'clock_nanosleep',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'faccessat',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchmodat',
+               'fchown',
+               'fchownat',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstat',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futex',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'io_getevents',
+               'ioctl',
+               'linkat',
+               'listen',
+               'llseek',
+               'lseek',
+               'memfd_create',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mq_unlink',
+               'nanosleep',
+               'newfstat',
+               'old_readdir',
+               'perf_event_open',
+               'poll',
+               'ppoll',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pselect6',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readlinkat',
+               'readv',
+               'recvfrom',
+               'recvmmsg',
+               'rt_sigtimedwait',
+               'sched_rr_get_interval',
+               'select',
+               'semtimedop',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'settimeofday',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'stime',
+               'swapoff',
+               'swapon',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'timer_gettime',
+               'timer_settime',
+               'timerfd_gettime',
+               'timerfd_settime',
+               'unlink',
+               'unlinkat',
+               'uselib',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'utimensat': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'clock_nanosleep',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'faccessat',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstat',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futex',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'io_getevents',
+                   'ioctl',
+                   'linkat',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'nanosleep',
+                   'newfstat',
+                   'old_readdir',
+                   'perf_event_open',
+                   'poll',
+                   'ppoll',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pselect6',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readlinkat',
+                   'readv',
+                   'recvfrom',
+                   'recvmmsg',
+                   'rt_sigtimedwait',
+                   'sched_rr_get_interval',
+                   'select',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'settimeofday',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'stime',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'vmsplice': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'write': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'writev': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev'])}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies.json b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies.json
new file mode 100644
index 0000000000..49586bd727
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies.json
@@ -0,0 +1 @@
+{"setdomainname": ["setns"], "name_to_handle_at": ["epoll_ctl", "syncfs", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "ustat", "socket", "open_by_handle_at", "unshare", "pipe2", "umount", "eventfd2", "perf_event_open"], "syncfs": ["lseek", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "fremovexattr", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "writev", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "lseek": ["epoll_ctl", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "flistxattr", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "rt_sigtimedwait": ["clone", "rt_sigaction", "msgrcv", "rt_sigqueueinfo", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "tgkill", "sched_getparam", "getpriority", "rt_sigprocmask", "rt_tgsigqueueinfo", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "tkill", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "timer_create", "perf_event_open", "ioprio_get", "vfork", "rt_sigreturn", "ptrace"], "vmsplice": ["lseek", "syncfs", "flistxattr", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "setfsuid": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "msgrcv": ["mq_timedsend", "msgsnd", "mq_timedreceive"], "uname": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "personality", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "kill": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "io_getevents": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "io_destroy", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "move_pages", "getitimer", "io_setup", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "modify_ldt", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "fork", "get_mempolicy", "io_submit", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mbind", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "io_cancel", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "swapoff": ["clone", "epoll_ctl", "shmdt", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "mmap_pgoff", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "acct", "flock", "open", "getitimer", "sched_getparam", "getpriority", "uselib", "swapon", "rt_sigprocmask", "accept4", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "memfd_create", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "remap_file_pages", "dup3", "setpgid", "mq_timedsend", "openat", "keyctl", "getppid", "sched_getscheduler", "mq_open", "dup", "mq_timedreceive", "shmctl", "move_pages", "capget", "sigaction", "getsid", "shmat", "sched_setaffinity", "socket", "open_by_handle_at", "setns", "signal", "pipe2", "sched_getattr", "semtimedop", "umount", "socketpair", "eventfd2", "sched_setscheduler", "prlimit64", "setitimer", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "getgroups16": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "setresuid", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "setgroups", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setgroups16", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "newlstat": ["newstat", "fstat", "newfstat", "newfstatat"], "pkey_alloc": ["get_mempolicy", "migrate_pages", "move_pages", "remap_file_pages", "io_setup", "shmdt", "getrusage", "modify_ldt", "io_destroy", "pkey_free", "brk", "mremap", "io_getevents", "swapoff", "prctl", "io_cancel", "mincore", "mbind"], "readahead": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "mq_unlink", "swapoff", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "readlinkat", "fsync", "bpf", "recvfrom", "old_readdir", "sendto", "linkat", "shutdown", "epoll_create1", "tee", "fchownat", "connect", "getsockname", "flock", "pwritev", "eventfd2", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "fchmodat", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "setsockopt", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "faccessat", "dup", "fallocate", "setns", "listen", "futimesat", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "unlink", "unlinkat", "open_by_handle_at", "bind", "sendfile64"], "newfstatat": ["newstat", "newlstat", "fstat", "newfstat"], "preadv": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "getdents": ["lseek", "syncfs", "flistxattr", "rt_sigtimedwait", "mq_timedreceive", "kill", "readahead", "preadv", "sched_getaffinity", "writev", "pwritev2", "fchmod", "signalfd4", "epoll_wait", "ioprio_set", "read", "getppid", "fchown", "sched_setattr", "msgrcv", "capget", "utime", "sched_setaffinity", "fsync", "bpf", "signal", "semtimedop", "umount", "recvfrom", "old_readdir", "sendto", "fsetxattr", "tee", "sync_file_range", "connect", "getsockname", "flock", "pwritev", "rt_sigprocmask", "accept4", "fremovexattr", "setsid", "sigaltstack", "ioperm", "inotify_rm_watch", "fstatfs64", "fcntl", "migrate_pages", "getitimer", "setpgid", "keyctl", "inotify_add_watch", "preadv2", "fchdir", "ioprio_get", "getpeername", "sigaction", "getsid", "setsockopt", "getpriority", "prlimit64", "pwrite64", "perf_event_open", "clone", "epoll_ctl", "pwritev64v2", "splice", "rt_sigaction", "getpgid", "sched_rr_get_interval", "getsockopt", "sched_setparam", "mq_getsetattr", "fdatasync", "setns", "listen", "fork", "shutdown", "get_robust_list", "futimesat", "mq_timedsend", "sched_getscheduler", "fgetxattr", "ptrace", "vmsplice", "fcntl64", "fallocate", "sched_getattr", "getrusage", "sched_setscheduler", "utimensat", "bind", "ftruncate", "vfork", "llseek", "getdents64", "pread64", "preadv64v2", "readv", "prctl", "move_pages", "copy_file_range", "fstatfs", "sched_getparam", "write", "setpriority", "mq_notify", "sendfile", "preadv64", "pwritev64", "ioctl", "setitimer", "sendfile64"], "getresgid": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "sethostname": ["setns"], "timer_delete": ["clone", "clock_gettime", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "clock_settime", "clock_getres", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "timer_settime", "mq_timedreceive", "timer_gettime", "capget", "clock_nanosleep", "sigaction", "getsid", "sched_setaffinity", "clock_adjtime", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "timer_create", "perf_event_open", "ioprio_get", "vfork", "timer_getoverrun", "ptrace"], "pwritev2": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "fchmod": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "pivot_root", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "unshare", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "eventfd2", "lookup_dcookie", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "getcwd", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "quotactl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "setgid": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "ptrace", "sigaltstack", "sched_setattr", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "pivot_root": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "mq_unlink", "symlinkat", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "rmdir", "linkat", "renameat2", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "memfd_create", "dup", "shmctl", "unlink", "swapon", "unlinkat", "mknodat", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "umount", "eventfd2", "perf_event_open", "ftruncate", "mkdirat"], "getuid16": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "epoll_wait": ["lseek", "syncfs", "flistxattr", "rt_sigtimedwait", "shmctl", "msgrcv", "kill", "swapoff", "readahead", "preadv", "getdents", "sched_getaffinity", "writev", "preadv64", "pwritev2", "fchmod", "signalfd4", "memfd_create", "ioprio_set", "remap_file_pages", "dup3", "read", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "fsync", "bpf", "signal", "semtimedop", "umount", "recvfrom", "old_readdir", "sendto", "fsetxattr", "epoll_create1", "tee", "sync_file_range", "connect", "getsockname", "flock", "pwritev", "eventfd2", "uselib", "rt_sigprocmask", "accept4", "fremovexattr", "setsid", "sigaltstack", "ioperm", "inotify_rm_watch", "socketpair", "fcntl", "migrate_pages", "getitimer", "setpgid", "keyctl", "inotify_add_watch", "preadv2", "fchdir", "ioprio_get", "getpeername", "sigaction", "getsid", "shmat", "setsockopt", "socket", "pipe2", "prlimit64", "pwrite64", "perf_event_open", "clone", "epoll_ctl", "pwritev64v2", "splice", "rt_sigaction", "getpgid", "sched_rr_get_interval", "acct", "open", "getsockopt", "sched_setparam", "shmdt", "mq_getsetattr", "dup", "fdatasync", "setns", "listen", "fork", "shutdown", "get_robust_list", "futimesat", "mq_timedsend", "sched_getscheduler", "fgetxattr", "ptrace", "vmsplice", "fcntl64", "swapon", "fallocate", "getpriority", "sched_getattr", "getrusage", "sched_setscheduler", "utimensat", "bind", "ftruncate", "vfork", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "prctl", "move_pages", "copy_file_range", "fstatfs", "sched_getparam", "fstatfs64", "write", "setpriority", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "setitimer", "sendfile64"], "ioprio_set": ["rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "clone", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "capset": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "delete_module": ["init_module", "finit_module"], "remap_file_pages": ["get_mempolicy", "munlockall", "madvise", "mprotect", "shmdt", "mremap", "munlock", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "dup3": ["unshare", "select", "dup2"], "readlinkat": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "read": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "mq_timedsend", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "llseek", "connect"], "getppid": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "fchown": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "pivot_root", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "utime", "fsync", "bpf", "unshare", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "eventfd2", "lookup_dcookie", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "getcwd", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "quotactl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "stat": ["fstat", "newfstat", "lstat"], "ioperm": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "mq_timedreceive": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "msgrcv", "swapoff", "acct", "flock", "open", "uselib", "accept4", "mq_getsetattr", "dup", "memfd_create", "socketpair", "mq_notify", "remap_file_pages", "dup3", "mq_timedsend", "openat", "mq_open", "shmctl", "msgsnd", "swapon", "shmat", "socket", "open_by_handle_at", "setns", "pipe2", "eventfd2", "perf_event_open"], "utime": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "newfstat", "pselect6", "uselib", "nanosleep", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "fstat", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "timerfd_settime", "sendfile64", "ftruncate", "ppoll"], "sched_setaffinity": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "getpriority", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "ustat": ["syncfs", "quotactl", "swapon", "umount"], "setfsgid": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "bpf": ["clone", "epoll_ctl", "shmdt", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "mmap_pgoff", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "acct", "flock", "open", "getitimer", "sched_getparam", "getpriority", "uselib", "swapon", "rt_sigprocmask", "accept4", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "memfd_create", "ioprio_set", "dup", "fork", "migrate_pages", "get_robust_list", "remap_file_pages", "dup3", "setpgid", "mq_timedsend", "openat", "keyctl", "getppid", "sched_getscheduler", "mq_open", "sched_setattr", "mq_timedreceive", "shmctl", "move_pages", "capget", "sigaction", "getsid", "shmat", "sched_setaffinity", "socket", "open_by_handle_at", "setns", "signal", "pipe2", "sched_getattr", "semtimedop", "umount", "socketpair", "eventfd2", "sched_setscheduler", "prlimit64", "setitimer", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "newstat": ["newlstat", "fstat", "newfstat", "newfstatat"], "setreuid": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "getpriority", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "semtimedop": ["syncfs", "rt_sigtimedwait", "shmctl", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "readahead", "timer_delete", "sched_getaffinity", "sched_setparam", "fchmod", "setgid", "pivot_root", "memfd_create", "ioprio_set", "setgroups16", "delete_module", "remap_file_pages", "dup3", "readlinkat", "getppid", "fchown", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "ustat", "bpf", "unshare", "signal", "setreuid", "umount", "socketpair", "eventfd2", "getpgid", "timer_create", "inotify_init1", "mkdirat", "linkat", "epoll_create1", "sched_getattr", "tee", "semctl", "fchownat", "sync_file_range", "flock", "lookup_dcookie", "pselect6", "uselib", "rt_sigprocmask", "accept4", "msgctl", "reboot", "setsid", "timerfd_create", "set_trip_temp", "sigaltstack", "sched_setattr", "inotify_rm_watch", "renameat2", "keyctl", "settimeofday", "migrate_pages", "getitimer", "fchmodat", "inotify_add_watch", "init_module", "setresgid", "getcwd", "timer_settime", "stime", "splice", "ioprio_get", "timer_gettime", "msgsnd", "sigaction", "getsid", "mknodat", "shmat", "futimesat", "munlockall", "socket", "pipe2", "prlimit64", "perf_event_open", "setregid", "epoll_ctl", "kexec_load", "quotactl", "rt_sigaction", "request_key", "symlinkat", "brk", "sched_rr_get_interval", "acct", "poll", "open", "select", "clock_nanosleep", "exit_group", "getpriority", "nanosleep", "shmdt", "mq_getsetattr", "faccessat", "rmdir", "dup", "setns", "fork", "get_mempolicy", "io_submit", "get_robust_list", "mq_timedsend", "sched_yield", "sched_getscheduler", "ptrace", "vmsplice", "swapon", "pkey_mprotect", "madvise", "epoll_wait", "timerfd_gettime", "getrusage", "fstat", "timerfd_settime", "sched_setscheduler", "setresuid", "ftruncate", "vfork", "setuid", "setpgid", "io_setup", "mprotect", "mmap_pgoff", "mremap", "io_destroy", "mbind", "prctl", "move_pages", "modify_ldt", "getgroups", "ppoll", "dup2", "get_curr_temp", "munlock", "setpriority", "mincore", "mq_notify", "sendfile", "get_trip_temp", "timer_getoverrun", "newfstat", "openat", "clone", "mq_open", "ioctl", "setgroups", "unlink", "unlinkat", "sched_getparam", "getgroups16", "io_cancel", "open_by_handle_at", "setitimer", "futex", "recvmmsg", "finit_module", "sendfile64", "mlockall"], "umount": ["setuid", "epoll_ctl", "syncfs", "pipe2", "quotactl", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "mmap_pgoff", "msgrcv", "setns", "mq_unlink", "getpgid", "kill", "sched_rr_get_interval", "swapoff", "prctl", "acct", "flock", "clone", "open", "getitimer", "lookup_dcookie", "sched_getparam", "getpriority", "uselib", "swapon", "rt_sigprocmask", "accept4", "sched_getaffinity", "sched_setparam", "setsid", "shmdt", "sigaltstack", "sched_setattr", "pivot_root", "setpriority", "memfd_create", "ioprio_set", "setresuid", "fork", "migrate_pages", "getcwd", "remap_file_pages", "dup3", "setpgid", "mq_timedsend", "openat", "keyctl", "getppid", "sched_getscheduler", "mq_open", "dup", "mq_timedreceive", "shmctl", "move_pages", "capget", "sigaction", "getsid", "shmat", "sched_setaffinity", "ustat", "socket", "open_by_handle_at", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "getrusage", "socketpair", "eventfd2", "sched_setscheduler", "prlimit64", "get_robust_list", "setitimer", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "recvfrom": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "mq_getsetattr", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "old_readdir": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "sendfile64", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "setrlimit": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "getrlimit", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "old_getrlimit", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "timer_create": ["clock_gettime", "clock_adjtime", "timer_getoverrun", "timer_delete", "timer_settime", "timer_gettime", "clock_nanosleep", "clock_settime", "clock_getres"], "sendto": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "mq_getsetattr", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "mkdirat": ["syncfs", "quotactl", "swapon", "ustat", "umount"], "lgetxattr": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "linkat": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "getresuid16": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "newuname": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "personality", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "epoll_create1": ["setuid", "epoll_ctl", "sched_rr_get_interval", "rt_sigaction", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "epoll_wait", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "olduname": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "personality", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "tee": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "connect", "getsockname", "flock", "pwritev", "eventfd2", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "semctl": ["semtimedop"], "syslog": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "rt_sigqueueinfo": ["tgkill", "rt_sigtimedwait", "rt_sigreturn", "rt_tgsigqueueinfo", "tkill", "kill", "timer_create"], "sync_file_range": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "llseek": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "connect"], "getgid": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "lsetxattr": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "pwritev": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "llistxattr": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "tgkill": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "pselect6": ["rt_sigtimedwait", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "sched_getaffinity", "sched_setparam", "fchmod", "memfd_create", "fstat", "readlinkat", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "signal", "semtimedop", "umount", "linkat", "timerfd_gettime", "fchownat", "uselib", "rt_sigprocmask", "inotify_add_watch", "setsid", "sigaltstack", "ioperm", "settimeofday", "migrate_pages", "getitimer", "fchmodat", "setpgid", "keyctl", "timer_settime", "stime", "ftruncate", "timer_gettime", "sigaction", "getsid", "futimesat", "prlimit64", "perf_event_open", "rt_sigaction", "getpgid", "sched_rr_get_interval", "poll", "select", "unlink", "getpriority", "nanosleep", "mq_getsetattr", "faccessat", "setns", "fork", "move_pages", "mq_timedsend", "sched_getscheduler", "ptrace", "swapon", "epoll_wait", "sched_getattr", "getrusage", "ioprio_set", "timerfd_settime", "sched_setscheduler", "ioprio_get", "vfork", "prctl", "get_robust_list", "sched_getparam", "ppoll", "setpriority", "mq_notify", "sendfile", "newfstat", "clone", "ioctl", "clock_nanosleep", "unlinkat", "setitimer", "futex", "recvmmsg", "sendfile64"], "uselib": ["syncfs", "quotactl", "getcwd", "ustat", "umount", "mq_unlink", "mq_open", "acct", "pivot_root", "swapon"], "sysfs": ["swapon", "open", "uselib", "openat", "quotactl", "mq_open", "mq_unlink", "symlinkat", "rmdir", "swapoff", "acct", "unlink", "renameat2", "unlinkat"], "msgctl": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "mq_unlink", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "msgsnd", "shmget", "sched_getparam", "getpriority", "rt_sigprocmask", "setpgid", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "semctl", "fork", "migrate_pages", "get_robust_list", "getitimer", "msgget", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_open", "sched_setattr", "mq_timedreceive", "shmctl", "capget", "sigaction", "getsid", "shmat", "sched_setaffinity", "semget", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "reboot": ["perf_event_open", "acct", "setns"], "fremovexattr": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "copy_file_range", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "writev", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "setsid": ["exit_group", "timer_create"], "timerfd_create": ["timerfd_settime", "timerfd_gettime"], "set_trip_temp": ["get_trip_temp", "get_curr_temp"], "sched_setattr": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "inotify_rm_watch": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "eventfd2", "uselib", "accept4", "fremovexattr", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fdatasync", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fallocate", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "renameat2": ["epoll_ctl", "accept4", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "mq_unlink", "symlinkat", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "sysfs", "shmdt", "rmdir", "linkat", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "dup", "shmctl", "unlink", "swapon", "unlinkat", "mknodat", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open", "ftruncate", "mkdirat"], "keyctl": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "request_key", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "clone", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "settimeofday": ["wait4", "clock_adjtime", "getitimer", "setitimer", "waitid", "adjtimex", "getrusage", "alarm", "select", "ppoll"], "utimensat": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "newfstat", "pselect6", "uselib", "nanosleep", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "fstat", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "timerfd_settime", "sendfile64", "ftruncate", "ppoll"], "fcntl": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "eventfd2", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "migrate_pages": ["setuid", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "clone", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "getitimer": ["setitimer", "exit_group", "timer_create"], "fchmodat": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "lstat": ["stat", "fstat", "newfstat"], "init_module": ["delete_module", "finit_module"], "setresgid": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "getcwd": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "mq_unlink", "symlinkat", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "rmdir", "linkat", "pivot_root", "renameat2", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "memfd_create", "dup", "shmctl", "unlink", "swapon", "unlinkat", "mknodat", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "umount", "eventfd2", "perf_event_open", "ftruncate", "mkdirat"], "inotify_add_watch": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "mq_unlink", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "pivot_root", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "recvfrom", "old_readdir", "sendto", "mkdirat", "linkat", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "eventfd2", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "renameat2", "socketpair", "fcntl", "sync_file_range", "fstatfs64", "getcwd", "preadv2", "fchdir", "getpeername", "mknodat", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "symlinkat", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "rmdir", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "unlink", "unlinkat", "open_by_handle_at", "bind", "sendfile64"], "preadv2": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "timer_settime": ["clock_gettime", "clock_adjtime", "timer_delete", "timer_create", "timer_gettime", "clock_nanosleep", "clock_settime", "clock_getres"], "setregid": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "ptrace"], "fchdir": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "pivot_root", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "unshare", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "eventfd2", "lookup_dcookie", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "getcwd", "preadv2", "splice", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "quotactl", "pwritev64v2", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "ftruncate": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "mq_timedreceive", "mq_unlink", "fchownat", "swapoff", "acct", "flock", "open", "fchmodat", "uselib", "accept4", "mq_getsetattr", "faccessat", "fchmod", "linkat", "memfd_create", "socketpair", "mq_notify", "sendfile", "remap_file_pages", "dup3", "inotify_add_watch", "mq_timedsend", "openat", "mq_open", "fchown", "dup", "ioctl", "shmctl", "unlink", "swapon", "unlinkat", "shmat", "readlinkat", "socket", "open_by_handle_at", "setns", "pipe2", "eventfd2", "sendfile64", "perf_event_open"], "timer_gettime": ["clock_gettime", "clock_adjtime", "timer_delete", "timer_settime", "timer_create", "clock_nanosleep", "clock_settime", "clock_getres"], "msgsnd": ["shmat", "shmget", "msgget", "semget", "msgctl", "semtimedop", "semctl", "mq_unlink", "msgrcv", "shmctl", "mq_open", "setns"], "sysinfo": ["rt_sigtimedwait", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "sched_getaffinity", "sched_setparam", "fchmod", "memfd_create", "fstat", "readlinkat", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "signal", "semtimedop", "umount", "linkat", "timerfd_gettime", "fchownat", "pselect6", "uselib", "rt_sigprocmask", "inotify_add_watch", "setsid", "sigaltstack", "ioperm", "settimeofday", "migrate_pages", "getitimer", "fchmodat", "setpgid", "keyctl", "timer_settime", "stime", "ftruncate", "timer_gettime", "sigaction", "getsid", "futimesat", "prlimit64", "perf_event_open", "rt_sigaction", "getpgid", "sched_rr_get_interval", "poll", "select", "unlink", "getpriority", "nanosleep", "mq_getsetattr", "faccessat", "setns", "fork", "move_pages", "mq_timedsend", "sched_getscheduler", "ptrace", "swapon", "epoll_wait", "sched_getattr", "getrusage", "ioprio_set", "timerfd_settime", "sched_setscheduler", "ioprio_get", "vfork", "prctl", "get_robust_list", "sched_getparam", "ppoll", "setpriority", "mq_notify", "sendfile", "newfstat", "clone", "ioctl", "clock_nanosleep", "unlinkat", "setitimer", "futex", "recvmmsg", "sendfile64"], "geteuid16": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "setpgid": ["setuid", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "clone", "sched_getparam", "exit_group", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "timer_create", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "mknodat": ["syncfs", "quotactl", "swapon", "ustat", "umount"], "shmat": ["clone", "epoll_ctl", "shmdt", "quotactl", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "mmap_pgoff", "msgrcv", "setns", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "acct", "flock", "open", "getitimer", "lookup_dcookie", "sched_getparam", "getpriority", "uselib", "swapon", "rt_sigprocmask", "accept4", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "pivot_root", "memfd_create", "ioprio_set", "fork", "migrate_pages", "getcwd", "remap_file_pages", "dup3", "setpgid", "mq_timedsend", "openat", "keyctl", "getppid", "sched_getscheduler", "mq_open", "dup", "mq_timedreceive", "shmctl", "move_pages", "capget", "sigaction", "getsid", "sched_setaffinity", "get_robust_list", "socket", "open_by_handle_at", "unshare", "signal", "pipe2", "sched_getattr", "semtimedop", "umount", "socketpair", "eventfd2", "sched_setscheduler", "prlimit64", "setitimer", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "setsockopt": ["accept4"], "old_getrlimit": ["prlimit64", "setrlimit"], "msync": ["get_mempolicy", "munlockall", "remap_file_pages", "madvise", "mprotect", "shmdt", "mremap", "munlock", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "getegid16": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "ioctl": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "fgetxattr", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "prlimit64": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "setresuid", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "old_getrlimit", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "setrlimit", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "set_mempolicy": ["get_mempolicy", "mbind"], "pwrite64": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "eventfd2", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "perf_event_open": ["lseek", "syncfs", "flistxattr", "rt_sigtimedwait", "shmctl", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "readahead", "preadv", "getdents", "timer_delete", "sched_getaffinity", "writev", "preadv64", "sched_setparam", "fchmod", "setgid", "pivot_root", "signalfd4", "memfd_create", "ioprio_set", "setgroups16", "delete_module", "remap_file_pages", "dup3", "readlinkat", "read", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "ustat", "fsync", "bpf", "unshare", "signal", "setreuid", "semtimedop", "umount", "socketpair", "recvfrom", "getpgid", "old_readdir", "timer_create", "sendto", "mbind", "mkdirat", "linkat", "sched_rr_get_interval", "epoll_create1", "sched_getattr", "tee", "semctl", "fchownat", "sync_file_range", "connect", "getsockname", "flock", "pwritev", "eventfd2", "lookup_dcookie", "uselib", "rt_sigprocmask", "accept4", "msgctl", "reboot", "fremovexattr", "setsid", "timerfd_create", "set_trip_temp", "sigaltstack", "ioperm", "inotify_rm_watch", "renameat2", "keyctl", "setresuid", "fcntl", "migrate_pages", "getitimer", "fchmodat", "setpgid", "init_module", "setresgid", "getcwd", "inotify_add_watch", "preadv2", "timer_settime", "setregid", "fchdir", "ioprio_get", "timer_gettime", "getpeername", "sigaction", "getsid", "mknodat", "shmat", "setsockopt", "munlockall", "socket", "pipe2", "prlimit64", "pwrite64", "clone", "epoll_ctl", "kexec_load", "quotactl", "pwritev64v2", "splice", "rt_sigaction", "request_key", "symlinkat", "brk", "fsetxattr", "acct", "open", "msgsnd", "getsockopt", "exit_group", "pwritev2", "shmdt", "mq_getsetattr", "faccessat", "rmdir", "dup", "fdatasync", "setns", "mprotect", "listen", "fork", "get_mempolicy", "shutdown", "get_robust_list", "futimesat", "mq_timedsend", "sched_yield", "sched_getscheduler", "fgetxattr", "ptrace", "vmsplice", "fcntl64", "swapon", "fallocate", "pkey_mprotect", "getpriority", "madvise", "epoll_wait", "timerfd_gettime", "getrusage", "timerfd_settime", "sched_setscheduler", "utimensat", "bind", "ftruncate", "vfork", "setuid", "llseek", "io_setup", "getdents64", "mmap_pgoff", "io_submit", "mremap", "io_destroy", "pread64", "preadv64v2", "readv", "prctl", "move_pages", "copy_file_range", "fstatfs", "modify_ldt", "getgroups", "fstatfs64", "dup2", "get_curr_temp", "write", "munlock", "setpriority", "inotify_init1", "mincore", "mq_notify", "sendfile", "get_trip_temp", "timer_getoverrun", "openat", "pwritev64", "mq_open", "ioctl", "setgroups", "unlink", "unlinkat", "sched_getparam", "getgroups16", "io_cancel", "open_by_handle_at", "setitimer", "finit_module", "sendfile64", "mlockall"], "removexattr": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "sendmsg": ["setsockopt", "sendmmsg", "shutdown", "recvmmsg", "bind", "accept4", "recvfrom", "recvmsg", "connect", "getsockname", "sendto", "getpeername", "listen", "getsockopt"], "epoll_ctl": ["lseek", "syncfs", "rt_sigtimedwait", "shmctl", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "readahead", "preadv", "getdents", "timer_delete", "sched_getaffinity", "writev", "preadv64", "sched_setparam", "fchmod", "setgid", "pivot_root", "signalfd4", "memfd_create", "ioprio_set", "setgroups16", "delete_module", "remap_file_pages", "dup3", "readlinkat", "read", "getppid", "fchown", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "ustat", "fsync", "bpf", "unshare", "signal", "setreuid", "semtimedop", "umount", "socketpair", "recvfrom", "getpgid", "old_readdir", "timer_create", "sendto", "mbind", "mkdirat", "linkat", "sched_rr_get_interval", "epoll_create1", "sched_getattr", "tee", "semctl", "fchownat", "sync_file_range", "connect", "getsockname", "flock", "pwritev", "eventfd2", "lookup_dcookie", "uselib", "rt_sigprocmask", "accept4", "msgctl", "reboot", "fremovexattr", "setsid", "timerfd_create", "set_trip_temp", "sigaltstack", "sched_setattr", "inotify_rm_watch", "renameat2", "keyctl", "setresuid", "fcntl", "migrate_pages", "getitimer", "fchmodat", "inotify_add_watch", "init_module", "setresgid", "getcwd", "preadv2", "timer_settime", "setregid", "fchdir", "ioprio_get", "timer_gettime", "getpeername", "sigaction", "setpgid", "mknodat", "shmat", "setsockopt", "munlockall", "socket", "pipe2", "prlimit64", "pwrite64", "perf_event_open", "clone", "flistxattr", "kexec_load", "quotactl", "pwritev64v2", "splice", "rt_sigaction", "request_key", "symlinkat", "brk", "fsetxattr", "acct", "open", "msgsnd", "getsockopt", "exit_group", "pwritev2", "shmdt", "mq_getsetattr", "faccessat", "getsid", "dup", "fdatasync", "setns", "mprotect", "rmdir", "fork", "get_mempolicy", "shutdown", "get_robust_list", "futimesat", "mq_timedsend", "sched_yield", "sched_getscheduler", "fgetxattr", "ptrace", "vmsplice", "fcntl64", "swapon", "fallocate", "pkey_mprotect", "getpriority", "madvise", "epoll_wait", "timerfd_gettime", "getrusage", "timerfd_settime", "sched_setscheduler", "utimensat", "bind", "ftruncate", "listen", "vfork", "setuid", "llseek", "io_setup", "getdents64", "mmap_pgoff", "io_submit", "mremap", "io_destroy", "pread64", "preadv64v2", "readv", "prctl", "move_pages", "copy_file_range", "fstatfs", "modify_ldt", "getgroups", "fstatfs64", "dup2", "get_curr_temp", "write", "munlock", "setpriority", "inotify_init1", "mincore", "mq_notify", "sendfile", "get_trip_temp", "timer_getoverrun", "openat", "pwritev64", "mq_open", "ioctl", "setgroups", "unlink", "unlinkat", "sched_getparam", "getgroups16", "io_cancel", "open_by_handle_at", "setitimer", "finit_module", "sendfile64", "mlockall"], "rt_tgsigqueueinfo": ["tgkill", "rt_sigtimedwait", "rt_sigreturn", "tkill", "rt_sigqueueinfo", "kill", "timer_create"], "pwritev64v2": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "splice": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "eventfd2", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "setxattr": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "symlinkat": ["quotactl", "swapon", "open", "uselib", "openat", "sysfs", "mq_open", "mq_unlink", "rmdir", "swapoff", "acct", "unlink", "renameat2", "unlinkat"], "brk": ["io_setup", "mprotect", "mremap", "io_destroy", "mbind", "io_getevents", "swapoff", "prctl", "modify_ldt", "shmdt", "munlock", "mincore", "get_mempolicy", "migrate_pages", "move_pages", "remap_file_pages", "io_cancel", "pkey_mprotect", "munlockall", "madvise", "getrusage", "mlockall"], "fsetxattr": ["lseek", "syncfs", "pwritev64v2", "splice", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "getsockname", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "mq_timedsend", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "llseek", "connect"], "acct": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "poll": ["ppoll"], "clock_settime": ["clock_gettime", "clock_adjtime", "timer_delete", "timer_settime", "timer_create", "timer_gettime", "clock_nanosleep", "clock_getres"], "select": ["rt_sigtimedwait", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "sched_getaffinity", "sched_setparam", "fchmod", "memfd_create", "fstat", "personality", "dup3", "readlinkat", "getppid", "fchown", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "unshare", "signal", "semtimedop", "umount", "linkat", "timerfd_gettime", "fchownat", "pselect6", "uselib", "rt_sigprocmask", "inotify_add_watch", "setsid", "sigaltstack", "sched_setattr", "settimeofday", "migrate_pages", "getitimer", "fchmodat", "setpgid", "keyctl", "timer_settime", "stime", "ftruncate", "timer_gettime", "sigaction", "getsid", "futimesat", "prlimit64", "perf_event_open", "rt_sigaction", "getpgid", "sched_rr_get_interval", "poll", "unlink", "getpriority", "nanosleep", "mq_getsetattr", "faccessat", "setns", "fork", "move_pages", "mq_timedsend", "sched_getscheduler", "ptrace", "swapon", "epoll_wait", "sched_getattr", "getrusage", "ioprio_set", "timerfd_settime", "sched_setscheduler", "ioprio_get", "vfork", "prctl", "get_robust_list", "sched_getparam", "ppoll", "dup2", "setpriority", "mq_notify", "sendfile", "newfstat", "clone", "ioctl", "clock_nanosleep", "unlinkat", "setitimer", "futex", "recvmmsg", "sendfile64"], "unlink": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "mq_unlink", "symlinkat", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "rmdir", "linkat", "pivot_root", "renameat2", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "memfd_create", "dup", "shmctl", "swapon", "unlinkat", "mknodat", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open", "ftruncate", "mkdirat"], "getsockopt": ["accept4"], "getpriority": ["setuid", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "clone", "sched_getparam", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "listxattr": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "sigaction": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "nanosleep": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "newfstat", "pselect6", "uselib", "ppoll", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "fstat", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "timerfd_settime", "sendfile64", "ftruncate"], "quotactl": ["syncfs", "swapon", "open", "uselib", "openat", "sysfs", "ustat", "umount", "mq_unlink", "symlinkat", "rmdir", "swapoff", "mq_open", "acct", "unlink", "renameat2", "unlinkat"], "mq_getsetattr": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "mq_timedreceive", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "mq_notify", "remap_file_pages", "dup3", "mq_timedsend", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "faccessat": ["setuid", "epoll_ctl", "pipe2", "quotactl", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "mmap_pgoff", "msgrcv", "setns", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "acct", "flock", "clone", "open", "getitimer", "lookup_dcookie", "sched_getparam", "getpriority", "uselib", "swapon", "rt_sigprocmask", "accept4", "sched_getaffinity", "sched_setparam", "setsid", "shmdt", "sigaltstack", "sched_setattr", "pivot_root", "setpriority", "memfd_create", "ioprio_set", "fork", "migrate_pages", "getcwd", "remap_file_pages", "dup3", "setpgid", "mq_timedsend", "openat", "keyctl", "getppid", "sched_getscheduler", "mq_open", "dup", "mq_timedreceive", "shmctl", "move_pages", "capget", "sigaction", "getsid", "shmat", "sched_setaffinity", "get_robust_list", "socket", "open_by_handle_at", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "socketpair", "eventfd2", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "rmdir": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "mq_unlink", "symlinkat", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "linkat", "pivot_root", "renameat2", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "memfd_create", "dup", "shmctl", "unlink", "swapon", "unlinkat", "mknodat", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open", "ftruncate", "mkdirat"], "fallocate": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "setgroups16": ["setgroups"], "getdents64": ["lseek", "syncfs", "flistxattr", "rt_sigtimedwait", "msgrcv", "kill", "readahead", "preadv", "getdents", "sched_getaffinity", "writev", "pwritev2", "fchmod", "signalfd4", "epoll_wait", "ioprio_set", "read", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "fsync", "bpf", "signal", "semtimedop", "umount", "recvfrom", "old_readdir", "sendto", "fsetxattr", "tee", "sync_file_range", "connect", "getsockname", "flock", "pwritev", "rt_sigprocmask", "accept4", "fremovexattr", "setsid", "sigaltstack", "ioperm", "inotify_rm_watch", "fstatfs64", "fcntl", "migrate_pages", "getitimer", "setpgid", "keyctl", "inotify_add_watch", "preadv2", "fchdir", "ioprio_get", "getpeername", "sigaction", "getsid", "setsockopt", "getpriority", "prlimit64", "pwrite64", "perf_event_open", "clone", "epoll_ctl", "pwritev64v2", "splice", "rt_sigaction", "getpgid", "sched_rr_get_interval", "getsockopt", "sched_setparam", "mq_getsetattr", "fdatasync", "setns", "listen", "fork", "shutdown", "get_robust_list", "futimesat", "mq_timedsend", "sched_getscheduler", "fgetxattr", "ptrace", "vmsplice", "fcntl64", "fallocate", "sched_getattr", "getrusage", "sched_setscheduler", "utimensat", "bind", "ftruncate", "vfork", "llseek", "pread64", "preadv64v2", "readv", "prctl", "move_pages", "copy_file_range", "fstatfs", "sched_getparam", "write", "setpriority", "mq_notify", "sendfile", "preadv64", "pwritev64", "ioctl", "setitimer", "sendfile64"], "io_cancel": ["get_mempolicy", "io_submit", "migrate_pages", "move_pages", "remap_file_pages", "io_setup", "shmdt", "getrusage", "modify_ldt", "io_destroy", "brk", "mremap", "io_getevents", "swapoff", "prctl", "mincore", "mbind"], "get_mempolicy": ["clone", "rt_sigaction", "rt_sigtimedwait", "mprotect", "msgrcv", "mlockall", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getitimer", "sched_getparam", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "fork", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "mbind", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "set_mempolicy", "perf_event_open", "brk", "vfork", "ptrace"], "io_submit": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "inotify_init1": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "inotify_add_watch", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "inotify_rm_watch", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "futimesat": ["linkat", "io_getevents", "rt_sigtimedwait", "adjtimex", "mq_timedreceive", "mq_unlink", "fchownat", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "newfstat", "pselect6", "uselib", "nanosleep", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "fstat", "settimeofday", "mq_notify", "sendfile", "getitimer", "fchmodat", "inotify_add_watch", "mq_timedsend", "waitid", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "wait4", "readlinkat", "clock_adjtime", "epoll_wait", "alarm", "timerfd_gettime", "semtimedop", "getrusage", "futex", "timerfd_settime", "sendfile64", "setitimer", "ftruncate", "ppoll"], "mq_timedsend": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "mq_timedreceive", "swapoff", "acct", "flock", "open", "uselib", "accept4", "mq_getsetattr", "dup", "memfd_create", "socketpair", "mq_notify", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "setns", "pipe2", "eventfd2", "perf_event_open"], "getresgid16": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "sched_getscheduler": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "fgetxattr": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "ptrace": ["setuid", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "pause", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "sigsuspend", "getppid", "rt_sigsuspend", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "epoll_wait", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "clone", "vfork"], "shmctl": ["clone", "epoll_ctl", "shmdt", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "mmap_pgoff", "msgrcv", "mq_unlink", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "acct", "flock", "open", "msgsnd", "getitimer", "shmget", "sched_getparam", "getpriority", "uselib", "swapon", "rt_sigprocmask", "accept4", "msgctl", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "getsid", "sigaltstack", "ioperm", "memfd_create", "ioprio_set", "semctl", "dup", "fork", "migrate_pages", "get_robust_list", "remap_file_pages", "dup3", "msgget", "mq_timedsend", "openat", "keyctl", "getppid", "sched_getscheduler", "mq_open", "sched_setattr", "mq_timedreceive", "move_pages", "capget", "sigaction", "setpgid", "shmat", "sched_setaffinity", "socket", "open_by_handle_at", "semget", "setns", "signal", "pipe2", "sched_getattr", "semtimedop", "umount", "socketpair", "eventfd2", "sched_setscheduler", "prlimit64", "setitimer", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "fcntl64": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "eventfd2", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "munlockall": ["get_mempolicy", "remap_file_pages", "madvise", "mprotect", "shmdt", "mremap", "munlock", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "swapon": ["linkat", "mq_timedreceive", "mq_unlink", "fchownat", "swapoff", "uselib", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "unlink", "unlinkat", "readlinkat", "sendfile64", "ftruncate"], "pkey_mprotect": ["clone", "rt_sigaction", "rt_sigtimedwait", "mprotect", "msgrcv", "mlockall", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getitimer", "sched_getparam", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "sched_setaffinity", "munlockall", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "signalfd4": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "madvise": ["get_mempolicy", "munlockall", "remap_file_pages", "mprotect", "shmdt", "mremap", "munlock", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "getresuid": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "statfs": ["ustat", "fstatfs64", "fstatfs", "statfs64"], "mount": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "personality", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "timerfd_gettime": ["timerfd_settime", "timerfd_create"], "fchownat": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "getrusage": ["exit_group", "timer_create"], "fstat": ["stat", "newfstat", "lstat"], "timerfd_settime": ["timerfd_gettime", "timerfd_create"], "setresuid": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "ioprio_get": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "vfork", "ptrace"], "setuid": ["clone", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "getgroups", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "io_setup": ["io_destroy", "io_submit", "io_cancel", "io_getevents"], "mprotect": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "mlockall", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getitimer", "sched_getparam", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "mmap_pgoff": ["epoll_ctl", "shmdt", "epoll_create1", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "mremap": ["clone", "io_getevents", "rt_sigaction", "rt_sigtimedwait", "mprotect", "msgrcv", "mlockall", "io_destroy", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "move_pages", "getitimer", "io_setup", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "modify_ldt", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "mbind", "sched_getparam", "mq_timedreceive", "ioprio_get", "io_cancel", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "geteuid": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "io_destroy": ["get_mempolicy", "io_submit", "migrate_pages", "move_pages", "remap_file_pages", "io_setup", "shmdt", "getrusage", "modify_ldt", "brk", "mremap", "io_getevents", "swapoff", "prctl", "io_cancel", "mincore", "mbind"], "pread64": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "preadv64v2": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "prctl": ["setuid", "io_getevents", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "io_destroy", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "move_pages", "clone", "getitimer", "io_setup", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "modify_ldt", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mbind", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "io_cancel", "setitimer", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "perf_event_open", "brk", "vfork", "ptrace"], "copy_file_range": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "flock": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "ustat", "fsync", "bpf", "umount", "recvfrom", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "pwritev", "eventfd2", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "quotactl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "epoll_wait", "utimensat", "ftruncate", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "fstatfs": ["statfs", "ustat", "fstatfs64", "statfs64"], "modify_ldt": ["get_mempolicy", "migrate_pages", "move_pages", "remap_file_pages", "io_setup", "mincore", "shmdt", "getrusage", "io_destroy", "set_thread_area", "brk", "mremap", "io_getevents", "swapoff", "prctl", "io_cancel", "get_thread_area", "mbind"], "sched_getattr": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "sched_getparam": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "fstatfs64": ["statfs", "ustat", "statfs64", "fstatfs"], "rt_sigreturn": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "write": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "tkill": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "munlock": ["clone", "rt_sigaction", "rt_sigtimedwait", "mprotect", "msgrcv", "mlockall", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getitimer", "sched_getparam", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "setpriority": ["setuid", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "clone", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "recvmsg": ["setsockopt", "sendmmsg", "shutdown", "recvmmsg", "bind", "accept4", "recvfrom", "connect", "getsockname", "sendto", "getpeername", "listen", "sendmsg", "getsockopt"], "shmdt": ["get_mempolicy", "munlockall", "remap_file_pages", "madvise", "mprotect", "mremap", "munlock", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "getrlimit": ["prlimit64", "old_getrlimit", "setrlimit"], "mincore": ["clone", "rt_sigaction", "rt_sigtimedwait", "mprotect", "msgrcv", "mlockall", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getitimer", "sched_getparam", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "sched_setattr", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "mq_notify": ["epoll_ctl", "shmdt", "epoll_create1", "rt_sigtimedwait", "mmap_pgoff", "mq_timedreceive", "rt_sigqueueinfo", "swapoff", "acct", "flock", "open", "tgkill", "uselib", "rt_sigreturn", "accept4", "mq_getsetattr", "tkill", "dup", "memfd_create", "socketpair", "remap_file_pages", "dup3", "mq_timedsend", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "setns", "pipe2", "eventfd2", "timer_create", "perf_event_open", "rt_tgsigqueueinfo"], "sendfile": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "sendmmsg": ["setsockopt", "shutdown", "recvmmsg", "bind", "accept4", "recvfrom", "recvmsg", "connect", "getsockname", "sendto", "getpeername", "listen", "sendmsg", "getsockopt"], "timer_getoverrun": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "timer_delete", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "timer_settime", "mq_timedreceive", "timer_gettime", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "timer_create", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "mlock2": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "newfstat": ["newstat", "newlstat", "fstat", "newfstatat"], "lremovexattr": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "preadv64": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "pwritev64": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "getxattr": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "mq_open": ["epoll_ctl", "accept4", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "mq_unlink", "symlinkat", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "sysfs", "shmdt", "rmdir", "dup", "pivot_root", "renameat2", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "memfd_create", "shmctl", "unlink", "swapon", "unlinkat", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open"], "statfs64": ["statfs", "ustat", "fstatfs64", "fstatfs"], "getgid16": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "set_thread_area": ["clone", "rt_sigaction", "rt_sigtimedwait", "mq_timedreceive", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "arch_prctl", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "msgrcv", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "getegid": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "clock_nanosleep": ["clock_gettime", "io_getevents", "linkat", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "sched_rr_get_interval", "swapoff", "poll", "clock_settime", "select", "clock_getres", "recvmmsg", "newfstat", "pselect6", "uselib", "nanosleep", "timer_delete", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "fstat", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "clock_adjtime", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "timerfd_settime", "sendfile64", "timer_create", "ftruncate", "ppoll"], "unlinkat": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "mq_unlink", "symlinkat", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "rmdir", "linkat", "pivot_root", "renameat2", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "memfd_create", "dup", "shmctl", "unlink", "swapon", "mknodat", "shmat", "socket", "open_by_handle_at", "unshare", "pipe2", "eventfd2", "perf_event_open", "ftruncate", "mkdirat"], "getgroups": ["setuid", "sched_rr_get_interval", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "setfsuid", "msgrcv", "getresuid", "getpgid", "kill", "getrusage", "getresuid16", "prctl", "move_pages", "clone", "sched_getparam", "getresgid", "rt_sigprocmask", "getpriority", "sched_getaffinity", "sched_setparam", "setsid", "vfork", "setgid", "sigaltstack", "sched_setattr", "ptrace", "setpriority", "setns", "ioprio_set", "capset", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getresgid16", "keyctl", "setresgid", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "getgroups16", "setfsgid", "unshare", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "faccessat", "setregid"], "clock_adjtime": ["clock_gettime", "timer_delete", "timer_settime", "timer_create", "timer_gettime", "clock_nanosleep", "clock_settime", "clock_getres"], "getuid": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "open_by_handle_at": ["epoll_ctl", "shmdt", "epoll_create1", "quotactl", "mmap_pgoff", "setns", "swapoff", "acct", "flock", "open", "lookup_dcookie", "uselib", "accept4", "dup", "pivot_root", "memfd_create", "socketpair", "remap_file_pages", "dup3", "openat", "getcwd", "mq_open", "shmctl", "swapon", "shmat", "socket", "unshare", "pipe2", "eventfd2", "perf_event_open"], "setitimer": ["wait4", "clock_adjtime", "getitimer", "exit_group", "waitid", "adjtimex", "getrusage", "settimeofday", "timer_create", "alarm", "select", "ppoll"], "alarm": ["wait4", "clock_adjtime", "getitimer", "setitimer", "waitid", "adjtimex", "getrusage", "select", "ppoll", "settimeofday"], "flistxattr": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "pread64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "futex": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "newfstat", "pselect6", "uselib", "nanosleep", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "fstat", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "timerfd_settime", "sendfile64", "ftruncate", "ppoll"], "recvmmsg": ["linkat", "getsockname", "bind", "rt_sigtimedwait", "setsockopt", "sendmmsg", "mq_timedreceive", "mq_unlink", "fchownat", "connect", "sched_rr_get_interval", "swapoff", "newfstat", "poll", "select", "timerfd_settime", "clock_nanosleep", "getsockopt", "pselect6", "uselib", "nanosleep", "accept4", "mq_getsetattr", "faccessat", "fchmod", "recvmsg", "memfd_create", "fstat", "settimeofday", "listen", "sendfile", "futimesat", "shutdown", "fchmodat", "inotify_add_watch", "mq_timedsend", "io_getevents", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "getpeername", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "recvfrom", "sendfile64", "sendto", "ftruncate", "mq_notify", "ppoll", "sendmsg"], "finit_module": ["delete_module", "init_module"], "sendfile64": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "mlockall": ["clone", "io_getevents", "rt_sigaction", "rt_sigtimedwait", "mprotect", "msgrcv", "io_destroy", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "move_pages", "getitimer", "io_setup", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "modify_ldt", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "mbind", "sched_getparam", "mq_timedreceive", "ioprio_get", "io_cancel", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "ppoll": ["rt_sigtimedwait", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "sched_getaffinity", "sched_setparam", "fchmod", "memfd_create", "fstat", "personality", "readlinkat", "getppid", "fchown", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "signal", "semtimedop", "umount", "linkat", "timerfd_gettime", "fchownat", "pselect6", "uselib", "rt_sigprocmask", "inotify_add_watch", "setsid", "sigaltstack", "sched_setattr", "settimeofday", "migrate_pages", "getitimer", "fchmodat", "setpgid", "keyctl", "timer_settime", "stime", "ftruncate", "timer_gettime", "sigaction", "getsid", "futimesat", "prlimit64", "perf_event_open", "rt_sigaction", "getpgid", "sched_rr_get_interval", "poll", "select", "unlink", "getpriority", "nanosleep", "mq_getsetattr", "faccessat", "setns", "fork", "move_pages", "mq_timedsend", "sched_getscheduler", "ptrace", "swapon", "epoll_wait", "sched_getattr", "getrusage", "ioprio_set", "timerfd_settime", "sched_setscheduler", "ioprio_get", "vfork", "prctl", "get_robust_list", "sched_getparam", "setpriority", "mq_notify", "sendfile", "newfstat", "clone", "ioctl", "clock_nanosleep", "unlinkat", "setitimer", "futex", "recvmmsg", "sendfile64"], "mlock": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"]}
\ No newline at end of file
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies.pretty b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies.pretty
new file mode 100644
index 0000000000..d0749965b9
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies.pretty
@@ -0,0 +1,9709 @@
+{'acct': set(['accept4',
+              'dup',
+              'dup3',
+              'epoll_create1',
+              'epoll_ctl',
+              'eventfd2',
+              'flock',
+              'memfd_create',
+              'mmap_pgoff',
+              'mq_open',
+              'open',
+              'open_by_handle_at',
+              'openat',
+              'perf_event_open',
+              'pipe2',
+              'remap_file_pages',
+              'setns',
+              'shmat',
+              'shmctl',
+              'shmdt',
+              'socket',
+              'socketpair',
+              'swapoff',
+              'swapon',
+              'uselib']),
+ 'alarm': set(['adjtimex',
+               'clock_adjtime',
+               'getitimer',
+               'getrusage',
+               'ppoll',
+               'select',
+               'setitimer',
+               'settimeofday',
+               'wait4',
+               'waitid']),
+ 'bpf': set(['accept4',
+             'acct',
+             'capget',
+             'clone',
+             'dup',
+             'dup3',
+             'epoll_create1',
+             'epoll_ctl',
+             'eventfd2',
+             'flock',
+             'fork',
+             'get_robust_list',
+             'getitimer',
+             'getpgid',
+             'getppid',
+             'getpriority',
+             'getrusage',
+             'getsid',
+             'ioperm',
+             'ioprio_get',
+             'ioprio_set',
+             'keyctl',
+             'kill',
+             'memfd_create',
+             'migrate_pages',
+             'mmap_pgoff',
+             'move_pages',
+             'mq_open',
+             'mq_timedreceive',
+             'mq_timedsend',
+             'msgrcv',
+             'open',
+             'open_by_handle_at',
+             'openat',
+             'perf_event_open',
+             'pipe2',
+             'prctl',
+             'prlimit64',
+             'ptrace',
+             'remap_file_pages',
+             'rt_sigaction',
+             'rt_sigprocmask',
+             'rt_sigtimedwait',
+             'sched_getaffinity',
+             'sched_getattr',
+             'sched_getparam',
+             'sched_getscheduler',
+             'sched_rr_get_interval',
+             'sched_setaffinity',
+             'sched_setattr',
+             'sched_setparam',
+             'sched_setscheduler',
+             'semtimedop',
+             'setitimer',
+             'setns',
+             'setpgid',
+             'setpriority',
+             'setsid',
+             'shmat',
+             'shmctl',
+             'shmdt',
+             'sigaction',
+             'sigaltstack',
+             'signal',
+             'socket',
+             'socketpair',
+             'swapoff',
+             'swapon',
+             'umount',
+             'uselib',
+             'vfork']),
+ 'brk': set(['get_mempolicy',
+             'getrusage',
+             'io_cancel',
+             'io_destroy',
+             'io_getevents',
+             'io_setup',
+             'madvise',
+             'mbind',
+             'migrate_pages',
+             'mincore',
+             'mlockall',
+             'modify_ldt',
+             'move_pages',
+             'mprotect',
+             'mremap',
+             'munlock',
+             'munlockall',
+             'pkey_mprotect',
+             'prctl',
+             'remap_file_pages',
+             'shmdt',
+             'swapoff']),
+ 'capset': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'clock_adjtime': set(['clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime',
+                       'timer_settime']),
+ 'clock_nanosleep': set(['clock_adjtime',
+                         'clock_getres',
+                         'clock_gettime',
+                         'clock_settime',
+                         'epoll_wait',
+                         'faccessat',
+                         'fchmod',
+                         'fchmodat',
+                         'fchown',
+                         'fchownat',
+                         'fstat',
+                         'ftruncate',
+                         'futex',
+                         'futimesat',
+                         'inotify_add_watch',
+                         'io_getevents',
+                         'ioctl',
+                         'linkat',
+                         'memfd_create',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'mq_unlink',
+                         'nanosleep',
+                         'newfstat',
+                         'poll',
+                         'ppoll',
+                         'pselect6',
+                         'readlinkat',
+                         'recvmmsg',
+                         'rt_sigtimedwait',
+                         'sched_rr_get_interval',
+                         'select',
+                         'semtimedop',
+                         'sendfile',
+                         'sendfile64',
+                         'settimeofday',
+                         'stime',
+                         'swapoff',
+                         'swapon',
+                         'timer_create',
+                         'timer_delete',
+                         'timer_gettime',
+                         'timer_settime',
+                         'timerfd_gettime',
+                         'timerfd_settime',
+                         'unlink',
+                         'unlinkat',
+                         'uselib',
+                         'utime']),
+ 'clock_settime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime',
+                       'timer_settime']),
+ 'copy_file_range': set(['accept4',
+                         'bind',
+                         'bpf',
+                         'connect',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchown',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'flistxattr',
+                         'flock',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'getdents',
+                         'getdents64',
+                         'getpeername',
+                         'getsockname',
+                         'getsockopt',
+                         'inotify_add_watch',
+                         'inotify_rm_watch',
+                         'ioctl',
+                         'listen',
+                         'llseek',
+                         'lseek',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'old_readdir',
+                         'perf_event_open',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'read',
+                         'readahead',
+                         'readv',
+                         'recvfrom',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'setsockopt',
+                         'shutdown',
+                         'signalfd4',
+                         'splice',
+                         'sync_file_range',
+                         'syncfs',
+                         'tee',
+                         'utime',
+                         'utimensat',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'delete_module': set(['finit_module', 'init_module']),
+ 'dup3': set(['dup2', 'select', 'unshare']),
+ 'epoll_create1': set(['capget',
+                       'capset',
+                       'clone',
+                       'epoll_ctl',
+                       'epoll_wait',
+                       'faccessat',
+                       'fork',
+                       'get_robust_list',
+                       'getgroups',
+                       'getgroups16',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getresgid',
+                       'getresgid16',
+                       'getresuid',
+                       'getresuid16',
+                       'getrusage',
+                       'getsid',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setfsgid',
+                       'setfsuid',
+                       'setgid',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setregid',
+                       'setresgid',
+                       'setresuid',
+                       'setreuid',
+                       'setsid',
+                       'setuid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'unshare',
+                       'vfork']),
+ 'epoll_ctl': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'brk',
+                   'capget',
+                   'clone',
+                   'connect',
+                   'copy_file_range',
+                   'delete_module',
+                   'dup',
+                   'dup2',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_wait',
+                   'eventfd2',
+                   'exit_group',
+                   'faccessat',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'finit_module',
+                   'flistxattr',
+                   'flock',
+                   'fork',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'get_curr_temp',
+                   'get_mempolicy',
+                   'get_robust_list',
+                   'get_trip_temp',
+                   'getcwd',
+                   'getdents',
+                   'getdents64',
+                   'getgroups',
+                   'getgroups16',
+                   'getitimer',
+                   'getpeername',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'getsockname',
+                   'getsockopt',
+                   'init_module',
+                   'inotify_add_watch',
+                   'inotify_init1',
+                   'inotify_rm_watch',
+                   'io_cancel',
+                   'io_destroy',
+                   'io_getevents',
+                   'io_setup',
+                   'io_submit',
+                   'ioctl',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'kexec_load',
+                   'keyctl',
+                   'kill',
+                   'linkat',
+                   'listen',
+                   'llseek',
+                   'lookup_dcookie',
+                   'lseek',
+                   'madvise',
+                   'mbind',
+                   'memfd_create',
+                   'migrate_pages',
+                   'mincore',
+                   'mkdirat',
+                   'mknodat',
+                   'mlockall',
+                   'mmap_pgoff',
+                   'modify_ldt',
+                   'move_pages',
+                   'mprotect',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'mremap',
+                   'msgctl',
+                   'msgrcv',
+                   'msgsnd',
+                   'munlock',
+                   'munlockall',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'pkey_mprotect',
+                   'prctl',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'prlimit64',
+                   'ptrace',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'quotactl',
+                   'read',
+                   'readahead',
+                   'readlinkat',
+                   'readv',
+                   'reboot',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'renameat2',
+                   'request_key',
+                   'rmdir',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'sched_yield',
+                   'semctl',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'set_trip_temp',
+                   'setgid',
+                   'setgroups',
+                   'setgroups16',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresgid',
+                   'setresuid',
+                   'setreuid',
+                   'setsid',
+                   'setsockopt',
+                   'setuid',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'signalfd4',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'symlinkat',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'timer_create',
+                   'timer_delete',
+                   'timer_getoverrun',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_create',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'umount',
+                   'unlink',
+                   'unlinkat',
+                   'unshare',
+                   'uselib',
+                   'ustat',
+                   'utime',
+                   'utimensat',
+                   'vfork',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'epoll_wait': set(['accept4',
+                    'acct',
+                    'bind',
+                    'bpf',
+                    'capget',
+                    'clone',
+                    'connect',
+                    'copy_file_range',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fork',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'get_robust_list',
+                    'getdents',
+                    'getdents64',
+                    'getitimer',
+                    'getpeername',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'ioperm',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'keyctl',
+                    'kill',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'memfd_create',
+                    'migrate_pages',
+                    'mmap_pgoff',
+                    'move_pages',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_open',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'old_readdir',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'prctl',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'prlimit64',
+                    'ptrace',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'remap_file_pages',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'setsockopt',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'shutdown',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'signalfd4',
+                    'socket',
+                    'socketpair',
+                    'splice',
+                    'swapoff',
+                    'swapon',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'umount',
+                    'uselib',
+                    'utime',
+                    'utimensat',
+                    'vfork',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'faccessat': set(['accept4',
+                   'acct',
+                   'capget',
+                   'clone',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'fork',
+                   'get_robust_list',
+                   'getcwd',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'migrate_pages',
+                   'mmap_pgoff',
+                   'move_pages',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'quotactl',
+                   'remap_file_pages',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setresuid',
+                   'setreuid',
+                   'setsid',
+                   'setuid',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'umount',
+                   'unshare',
+                   'uselib',
+                   'vfork']),
+ 'fallocate': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'fchdir': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getcwd',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lookup_dcookie',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'quotactl',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'splice',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'unshare',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'fchmod': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchdir',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getcwd',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lookup_dcookie',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'quotactl',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'splice',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'unshare',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'fchmodat': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'getcwd',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'unshare',
+                  'uselib']),
+ 'fchown': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getcwd',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lookup_dcookie',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'quotactl',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'splice',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'unshare',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'fchownat': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'getcwd',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'unshare',
+                  'uselib']),
+ 'fcntl': set(['accept4',
+               'acct',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'epoll_wait',
+               'eventfd2',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'memfd_create',
+               'mmap_pgoff',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_open',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'remap_file_pages',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setns',
+               'setsockopt',
+               'shmat',
+               'shmctl',
+               'shmdt',
+               'shutdown',
+               'signalfd4',
+               'socket',
+               'socketpair',
+               'splice',
+               'swapoff',
+               'swapon',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'uselib',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'fcntl64': set(['accept4',
+                 'acct',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'eventfd2',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'old_readdir',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'pread64',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'remap_file_pages',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setns',
+                 'setsockopt',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'shutdown',
+                 'signalfd4',
+                 'socket',
+                 'socketpair',
+                 'splice',
+                 'swapoff',
+                 'swapon',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'uselib',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'fgetxattr': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'finit_module': set(['delete_module', 'init_module']),
+ 'flistxattr': set(['accept4',
+                    'bind',
+                    'bpf',
+                    'connect',
+                    'copy_file_range',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flock',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'getdents',
+                    'getdents64',
+                    'getpeername',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'old_readdir',
+                    'perf_event_open',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setsockopt',
+                    'shutdown',
+                    'signalfd4',
+                    'splice',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'utime',
+                    'utimensat',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'flock': set(['accept4',
+               'acct',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'epoll_wait',
+               'eventfd2',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'memfd_create',
+               'mmap_pgoff',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_open',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'quotactl',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'remap_file_pages',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setns',
+               'setsockopt',
+               'shmat',
+               'shmctl',
+               'shmdt',
+               'shutdown',
+               'signalfd4',
+               'socket',
+               'socketpair',
+               'splice',
+               'swapoff',
+               'swapon',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'umount',
+               'uselib',
+               'ustat',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'fremovexattr': set(['accept4',
+                      'bind',
+                      'bpf',
+                      'connect',
+                      'copy_file_range',
+                      'epoll_ctl',
+                      'epoll_wait',
+                      'fallocate',
+                      'fchdir',
+                      'fchmod',
+                      'fchown',
+                      'fcntl',
+                      'fcntl64',
+                      'fdatasync',
+                      'fgetxattr',
+                      'flistxattr',
+                      'flock',
+                      'fsetxattr',
+                      'fstatfs',
+                      'fstatfs64',
+                      'fsync',
+                      'ftruncate',
+                      'futimesat',
+                      'getdents',
+                      'getdents64',
+                      'getpeername',
+                      'getsockname',
+                      'getsockopt',
+                      'inotify_add_watch',
+                      'inotify_rm_watch',
+                      'ioctl',
+                      'listen',
+                      'llseek',
+                      'lseek',
+                      'mq_getsetattr',
+                      'mq_notify',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'old_readdir',
+                      'perf_event_open',
+                      'pread64',
+                      'preadv',
+                      'preadv2',
+                      'preadv64',
+                      'preadv64v2',
+                      'pwrite64',
+                      'pwritev',
+                      'pwritev2',
+                      'pwritev64',
+                      'pwritev64v2',
+                      'read',
+                      'readahead',
+                      'readv',
+                      'recvfrom',
+                      'sendfile',
+                      'sendfile64',
+                      'sendto',
+                      'setsockopt',
+                      'shutdown',
+                      'signalfd4',
+                      'splice',
+                      'sync_file_range',
+                      'syncfs',
+                      'tee',
+                      'utime',
+                      'utimensat',
+                      'vmsplice',
+                      'write',
+                      'writev']),
+ 'fsetxattr': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'fstat': set(['lstat', 'newfstat', 'stat']),
+ 'fstatfs': set(['fstatfs64', 'statfs', 'statfs64', 'ustat']),
+ 'fstatfs64': set(['fstatfs', 'statfs', 'statfs64', 'ustat']),
+ 'ftruncate': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'faccessat',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'flock',
+                   'inotify_add_watch',
+                   'ioctl',
+                   'linkat',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'readlinkat',
+                   'remap_file_pages',
+                   'sendfile',
+                   'sendfile64',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'unlink',
+                   'unlinkat',
+                   'uselib']),
+ 'futex': set(['clock_nanosleep',
+               'epoll_wait',
+               'faccessat',
+               'fchmod',
+               'fchmodat',
+               'fchown',
+               'fchownat',
+               'fstat',
+               'ftruncate',
+               'futimesat',
+               'inotify_add_watch',
+               'io_getevents',
+               'ioctl',
+               'linkat',
+               'memfd_create',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mq_unlink',
+               'nanosleep',
+               'newfstat',
+               'poll',
+               'ppoll',
+               'pselect6',
+               'readlinkat',
+               'recvmmsg',
+               'rt_sigtimedwait',
+               'sched_rr_get_interval',
+               'select',
+               'semtimedop',
+               'sendfile',
+               'sendfile64',
+               'settimeofday',
+               'stime',
+               'swapoff',
+               'swapon',
+               'timer_gettime',
+               'timer_settime',
+               'timerfd_gettime',
+               'timerfd_settime',
+               'unlink',
+               'unlinkat',
+               'uselib',
+               'utime']),
+ 'futimesat': set(['adjtimex',
+                   'alarm',
+                   'clock_adjtime',
+                   'clock_nanosleep',
+                   'epoll_wait',
+                   'faccessat',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fstat',
+                   'ftruncate',
+                   'futex',
+                   'getitimer',
+                   'getrusage',
+                   'inotify_add_watch',
+                   'io_getevents',
+                   'ioctl',
+                   'linkat',
+                   'memfd_create',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'nanosleep',
+                   'newfstat',
+                   'poll',
+                   'ppoll',
+                   'pselect6',
+                   'readlinkat',
+                   'recvmmsg',
+                   'rt_sigtimedwait',
+                   'sched_rr_get_interval',
+                   'select',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'setitimer',
+                   'settimeofday',
+                   'stime',
+                   'swapoff',
+                   'swapon',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime',
+                   'wait4',
+                   'waitid']),
+ 'get_mempolicy': set(['brk',
+                       'capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'madvise',
+                       'mbind',
+                       'migrate_pages',
+                       'mincore',
+                       'mlockall',
+                       'move_pages',
+                       'mprotect',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'mremap',
+                       'msgrcv',
+                       'munlock',
+                       'munlockall',
+                       'perf_event_open',
+                       'pkey_mprotect',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'remap_file_pages',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'set_mempolicy',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'shmdt',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'getcwd': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'ftruncate',
+                'linkat',
+                'lookup_dcookie',
+                'memfd_create',
+                'mkdirat',
+                'mknodat',
+                'mmap_pgoff',
+                'mq_open',
+                'mq_unlink',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'quotactl',
+                'remap_file_pages',
+                'renameat2',
+                'rmdir',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'symlinkat',
+                'umount',
+                'unlink',
+                'unlinkat',
+                'unshare',
+                'uselib']),
+ 'getdents': set(['accept4',
+                  'bind',
+                  'bpf',
+                  'capget',
+                  'clone',
+                  'connect',
+                  'copy_file_range',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fork',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'get_robust_list',
+                  'getdents64',
+                  'getitimer',
+                  'getpeername',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'ioperm',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'old_readdir',
+                  'perf_event_open',
+                  'prctl',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'prlimit64',
+                  'ptrace',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'setsockopt',
+                  'shutdown',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'signalfd4',
+                  'splice',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'umount',
+                  'utime',
+                  'utimensat',
+                  'vfork',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'getdents64': set(['accept4',
+                    'bind',
+                    'bpf',
+                    'capget',
+                    'clone',
+                    'connect',
+                    'copy_file_range',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fork',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'get_robust_list',
+                    'getdents',
+                    'getitimer',
+                    'getpeername',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'ioperm',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'keyctl',
+                    'kill',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'migrate_pages',
+                    'move_pages',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'old_readdir',
+                    'perf_event_open',
+                    'prctl',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'prlimit64',
+                    'ptrace',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'setsockopt',
+                    'shutdown',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'signalfd4',
+                    'splice',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'umount',
+                    'utime',
+                    'utimensat',
+                    'vfork',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'getegid': set(['capget',
+                 'clone',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'perf_event_open',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'getegid16': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'geteuid': set(['capget',
+                 'clone',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'perf_event_open',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'geteuid16': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'getgid': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'getgid16': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'getgroups': set(['capget',
+                   'capset',
+                   'clone',
+                   'epoll_create1',
+                   'faccessat',
+                   'fork',
+                   'get_robust_list',
+                   'getgroups16',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getresgid',
+                   'getresgid16',
+                   'getresuid',
+                   'getresuid16',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setfsgid',
+                   'setfsuid',
+                   'setgid',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresgid',
+                   'setresuid',
+                   'setreuid',
+                   'setsid',
+                   'setuid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'unshare',
+                   'vfork']),
+ 'getgroups16': set(['capget',
+                     'capset',
+                     'clone',
+                     'epoll_create1',
+                     'faccessat',
+                     'fork',
+                     'get_robust_list',
+                     'getgroups',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getpriority',
+                     'getresgid',
+                     'getresgid16',
+                     'getresuid',
+                     'getresuid16',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setfsgid',
+                     'setfsuid',
+                     'setgid',
+                     'setgroups',
+                     'setgroups16',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setpriority',
+                     'setregid',
+                     'setresgid',
+                     'setresuid',
+                     'setreuid',
+                     'setsid',
+                     'setuid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'unshare',
+                     'vfork']),
+ 'getitimer': set(['exit_group', 'setitimer', 'timer_create']),
+ 'getppid': set(['capget',
+                 'clone',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'perf_event_open',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'getpriority': set(['capget',
+                     'clone',
+                     'fork',
+                     'get_robust_list',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setpriority',
+                     'setresuid',
+                     'setreuid',
+                     'setsid',
+                     'setuid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'vfork']),
+ 'getresgid': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'getresgid16': set(['capget',
+                     'clone',
+                     'fork',
+                     'get_robust_list',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getpriority',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setpriority',
+                     'setsid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'vfork']),
+ 'getresuid': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'getresuid16': set(['capget',
+                     'clone',
+                     'fork',
+                     'get_robust_list',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getpriority',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setpriority',
+                     'setsid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'vfork']),
+ 'getrlimit': set(['old_getrlimit', 'prlimit64', 'setrlimit']),
+ 'getrusage': set(['exit_group', 'timer_create']),
+ 'getsockopt': set(['accept4']),
+ 'getuid': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'getuid16': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'getxattr': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'getcwd',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'unshare',
+                  'uselib']),
+ 'init_module': set(['delete_module', 'finit_module']),
+ 'inotify_add_watch': set(['accept4',
+                           'acct',
+                           'bind',
+                           'bpf',
+                           'connect',
+                           'copy_file_range',
+                           'dup',
+                           'dup3',
+                           'epoll_create1',
+                           'epoll_ctl',
+                           'epoll_wait',
+                           'eventfd2',
+                           'fallocate',
+                           'fchdir',
+                           'fchmod',
+                           'fchown',
+                           'fcntl',
+                           'fcntl64',
+                           'fdatasync',
+                           'fgetxattr',
+                           'flistxattr',
+                           'flock',
+                           'fremovexattr',
+                           'fsetxattr',
+                           'fstatfs',
+                           'fstatfs64',
+                           'fsync',
+                           'ftruncate',
+                           'futimesat',
+                           'getcwd',
+                           'getdents',
+                           'getdents64',
+                           'getpeername',
+                           'getsockname',
+                           'getsockopt',
+                           'inotify_rm_watch',
+                           'ioctl',
+                           'linkat',
+                           'listen',
+                           'llseek',
+                           'lseek',
+                           'memfd_create',
+                           'mkdirat',
+                           'mknodat',
+                           'mmap_pgoff',
+                           'mq_getsetattr',
+                           'mq_notify',
+                           'mq_open',
+                           'mq_timedreceive',
+                           'mq_timedsend',
+                           'mq_unlink',
+                           'old_readdir',
+                           'open',
+                           'open_by_handle_at',
+                           'openat',
+                           'perf_event_open',
+                           'pipe2',
+                           'pivot_root',
+                           'pread64',
+                           'preadv',
+                           'preadv2',
+                           'preadv64',
+                           'preadv64v2',
+                           'pwrite64',
+                           'pwritev',
+                           'pwritev2',
+                           'pwritev64',
+                           'pwritev64v2',
+                           'read',
+                           'readahead',
+                           'readv',
+                           'recvfrom',
+                           'remap_file_pages',
+                           'renameat2',
+                           'rmdir',
+                           'sendfile',
+                           'sendfile64',
+                           'sendto',
+                           'setns',
+                           'setsockopt',
+                           'shmat',
+                           'shmctl',
+                           'shmdt',
+                           'shutdown',
+                           'signalfd4',
+                           'socket',
+                           'socketpair',
+                           'splice',
+                           'swapoff',
+                           'swapon',
+                           'symlinkat',
+                           'sync_file_range',
+                           'syncfs',
+                           'tee',
+                           'unlink',
+                           'unlinkat',
+                           'uselib',
+                           'utime',
+                           'utimensat',
+                           'vmsplice',
+                           'write',
+                           'writev']),
+ 'inotify_init1': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'inotify_add_watch',
+                       'inotify_rm_watch',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'inotify_rm_watch': set(['accept4',
+                          'acct',
+                          'bind',
+                          'bpf',
+                          'connect',
+                          'copy_file_range',
+                          'dup',
+                          'dup3',
+                          'epoll_create1',
+                          'epoll_ctl',
+                          'epoll_wait',
+                          'eventfd2',
+                          'fallocate',
+                          'fchdir',
+                          'fchmod',
+                          'fchown',
+                          'fcntl',
+                          'fcntl64',
+                          'fdatasync',
+                          'fgetxattr',
+                          'flistxattr',
+                          'flock',
+                          'fremovexattr',
+                          'fsetxattr',
+                          'fstatfs',
+                          'fstatfs64',
+                          'fsync',
+                          'ftruncate',
+                          'futimesat',
+                          'getdents',
+                          'getdents64',
+                          'getpeername',
+                          'getsockname',
+                          'getsockopt',
+                          'inotify_add_watch',
+                          'ioctl',
+                          'listen',
+                          'llseek',
+                          'lseek',
+                          'memfd_create',
+                          'mmap_pgoff',
+                          'mq_getsetattr',
+                          'mq_notify',
+                          'mq_open',
+                          'mq_timedreceive',
+                          'mq_timedsend',
+                          'old_readdir',
+                          'open',
+                          'open_by_handle_at',
+                          'openat',
+                          'perf_event_open',
+                          'pipe2',
+                          'pread64',
+                          'preadv',
+                          'preadv2',
+                          'preadv64',
+                          'preadv64v2',
+                          'pwrite64',
+                          'pwritev',
+                          'pwritev2',
+                          'pwritev64',
+                          'pwritev64v2',
+                          'read',
+                          'readahead',
+                          'readv',
+                          'recvfrom',
+                          'remap_file_pages',
+                          'sendfile',
+                          'sendfile64',
+                          'sendto',
+                          'setns',
+                          'setsockopt',
+                          'shmat',
+                          'shmctl',
+                          'shmdt',
+                          'shutdown',
+                          'signalfd4',
+                          'socket',
+                          'socketpair',
+                          'splice',
+                          'swapoff',
+                          'swapon',
+                          'sync_file_range',
+                          'syncfs',
+                          'tee',
+                          'uselib',
+                          'utime',
+                          'utimensat',
+                          'vmsplice',
+                          'write',
+                          'writev']),
+ 'io_cancel': set(['brk',
+                   'get_mempolicy',
+                   'getrusage',
+                   'io_destroy',
+                   'io_getevents',
+                   'io_setup',
+                   'io_submit',
+                   'mbind',
+                   'migrate_pages',
+                   'mincore',
+                   'modify_ldt',
+                   'move_pages',
+                   'mremap',
+                   'prctl',
+                   'remap_file_pages',
+                   'shmdt',
+                   'swapoff']),
+ 'io_destroy': set(['brk',
+                    'get_mempolicy',
+                    'getrusage',
+                    'io_cancel',
+                    'io_getevents',
+                    'io_setup',
+                    'io_submit',
+                    'mbind',
+                    'migrate_pages',
+                    'mincore',
+                    'modify_ldt',
+                    'move_pages',
+                    'mremap',
+                    'prctl',
+                    'remap_file_pages',
+                    'shmdt',
+                    'swapoff']),
+ 'io_getevents': set(['brk',
+                      'capget',
+                      'clone',
+                      'fork',
+                      'get_mempolicy',
+                      'get_robust_list',
+                      'getitimer',
+                      'getpgid',
+                      'getppid',
+                      'getpriority',
+                      'getrusage',
+                      'getsid',
+                      'io_cancel',
+                      'io_destroy',
+                      'io_setup',
+                      'io_submit',
+                      'ioprio_get',
+                      'ioprio_set',
+                      'keyctl',
+                      'kill',
+                      'mbind',
+                      'migrate_pages',
+                      'mincore',
+                      'modify_ldt',
+                      'move_pages',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'mremap',
+                      'msgrcv',
+                      'perf_event_open',
+                      'prctl',
+                      'prlimit64',
+                      'ptrace',
+                      'remap_file_pages',
+                      'rt_sigaction',
+                      'rt_sigprocmask',
+                      'rt_sigtimedwait',
+                      'sched_getaffinity',
+                      'sched_getattr',
+                      'sched_getparam',
+                      'sched_getscheduler',
+                      'sched_rr_get_interval',
+                      'sched_setaffinity',
+                      'sched_setattr',
+                      'sched_setparam',
+                      'sched_setscheduler',
+                      'semtimedop',
+                      'setitimer',
+                      'setns',
+                      'setpgid',
+                      'setpriority',
+                      'setsid',
+                      'shmdt',
+                      'sigaction',
+                      'sigaltstack',
+                      'signal',
+                      'swapoff',
+                      'umount',
+                      'vfork']),
+ 'io_setup': set(['io_cancel', 'io_destroy', 'io_getevents', 'io_submit']),
+ 'io_submit': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioperm',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'ioctl': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'listen',
+               'llseek',
+               'lseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'ioperm': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'ioprio_get': set(['capget',
+                    'clone',
+                    'fork',
+                    'get_robust_list',
+                    'getitimer',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'ioprio_set',
+                    'keyctl',
+                    'kill',
+                    'migrate_pages',
+                    'move_pages',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'perf_event_open',
+                    'prctl',
+                    'prlimit64',
+                    'ptrace',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'umount',
+                    'vfork']),
+ 'ioprio_set': set(['capget',
+                    'clone',
+                    'fork',
+                    'get_robust_list',
+                    'getitimer',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'ioprio_get',
+                    'keyctl',
+                    'kill',
+                    'migrate_pages',
+                    'move_pages',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'perf_event_open',
+                    'prctl',
+                    'prlimit64',
+                    'ptrace',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'umount',
+                    'vfork']),
+ 'keyctl': set(['capget',
+                'capset',
+                'clone',
+                'epoll_create1',
+                'faccessat',
+                'fork',
+                'get_robust_list',
+                'getgroups',
+                'getgroups16',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getresgid',
+                'getresgid16',
+                'getresuid',
+                'getresuid16',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'request_key',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setfsgid',
+                'setfsuid',
+                'setgid',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setregid',
+                'setresgid',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'unshare',
+                'vfork']),
+ 'kill': set(['capget',
+              'clone',
+              'fork',
+              'get_robust_list',
+              'getitimer',
+              'getpgid',
+              'getppid',
+              'getpriority',
+              'getrusage',
+              'getsid',
+              'ioprio_get',
+              'ioprio_set',
+              'keyctl',
+              'migrate_pages',
+              'move_pages',
+              'mq_timedreceive',
+              'mq_timedsend',
+              'msgrcv',
+              'perf_event_open',
+              'prctl',
+              'prlimit64',
+              'ptrace',
+              'rt_sigaction',
+              'rt_sigprocmask',
+              'rt_sigtimedwait',
+              'sched_getaffinity',
+              'sched_getattr',
+              'sched_getparam',
+              'sched_getscheduler',
+              'sched_rr_get_interval',
+              'sched_setaffinity',
+              'sched_setattr',
+              'sched_setparam',
+              'sched_setscheduler',
+              'semtimedop',
+              'setitimer',
+              'setns',
+              'setpgid',
+              'setpriority',
+              'setsid',
+              'sigaction',
+              'sigaltstack',
+              'signal',
+              'umount',
+              'vfork']),
+ 'lgetxattr': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'getcwd',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'quotactl',
+                   'remap_file_pages',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'unshare',
+                   'uselib']),
+ 'linkat': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'getcwd',
+                'lookup_dcookie',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_open',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'quotactl',
+                'remap_file_pages',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'unshare',
+                'uselib']),
+ 'listxattr': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'getcwd',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'quotactl',
+                   'remap_file_pages',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'unshare',
+                   'uselib']),
+ 'llistxattr': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'getcwd',
+                    'lookup_dcookie',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'pivot_root',
+                    'quotactl',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'unshare',
+                    'uselib']),
+ 'llseek': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'lremovexattr': set(['accept4',
+                      'acct',
+                      'dup',
+                      'dup3',
+                      'epoll_create1',
+                      'epoll_ctl',
+                      'eventfd2',
+                      'flock',
+                      'getcwd',
+                      'lookup_dcookie',
+                      'memfd_create',
+                      'mmap_pgoff',
+                      'mq_open',
+                      'open',
+                      'open_by_handle_at',
+                      'openat',
+                      'perf_event_open',
+                      'pipe2',
+                      'pivot_root',
+                      'quotactl',
+                      'remap_file_pages',
+                      'setns',
+                      'shmat',
+                      'shmctl',
+                      'shmdt',
+                      'socket',
+                      'socketpair',
+                      'swapoff',
+                      'swapon',
+                      'unshare',
+                      'uselib']),
+ 'lseek': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'lsetxattr': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'getcwd',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'quotactl',
+                   'remap_file_pages',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'unshare',
+                   'uselib']),
+ 'lstat': set(['fstat', 'newfstat', 'stat']),
+ 'madvise': set(['brk',
+                 'get_mempolicy',
+                 'mincore',
+                 'mlockall',
+                 'mprotect',
+                 'mremap',
+                 'munlock',
+                 'munlockall',
+                 'pkey_mprotect',
+                 'prctl',
+                 'remap_file_pages',
+                 'shmdt']),
+ 'migrate_pages': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioperm',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setresuid',
+                       'setreuid',
+                       'setsid',
+                       'setuid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'mincore': set(['brk',
+                 'capget',
+                 'clone',
+                 'fork',
+                 'get_mempolicy',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioperm',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'madvise',
+                 'migrate_pages',
+                 'mlockall',
+                 'move_pages',
+                 'mprotect',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'mremap',
+                 'msgrcv',
+                 'munlock',
+                 'munlockall',
+                 'perf_event_open',
+                 'pkey_mprotect',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'remap_file_pages',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'shmdt',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'mkdirat': set(['quotactl', 'swapon', 'syncfs', 'umount', 'ustat']),
+ 'mknodat': set(['quotactl', 'swapon', 'syncfs', 'umount', 'ustat']),
+ 'mlock': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'mlock2': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'mlockall': set(['brk',
+                  'capget',
+                  'clone',
+                  'fork',
+                  'get_mempolicy',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'io_cancel',
+                  'io_destroy',
+                  'io_getevents',
+                  'io_setup',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'madvise',
+                  'mbind',
+                  'migrate_pages',
+                  'mincore',
+                  'modify_ldt',
+                  'move_pages',
+                  'mprotect',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mremap',
+                  'msgrcv',
+                  'munlock',
+                  'munlockall',
+                  'perf_event_open',
+                  'personality',
+                  'pkey_mprotect',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'remap_file_pages',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'shmdt',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'swapoff',
+                  'umount',
+                  'vfork']),
+ 'mmap_pgoff': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'memfd_create',
+                    'mq_open',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'uselib']),
+ 'modify_ldt': set(['brk',
+                    'get_mempolicy',
+                    'get_thread_area',
+                    'getrusage',
+                    'io_cancel',
+                    'io_destroy',
+                    'io_getevents',
+                    'io_setup',
+                    'mbind',
+                    'migrate_pages',
+                    'mincore',
+                    'move_pages',
+                    'mremap',
+                    'prctl',
+                    'remap_file_pages',
+                    'set_thread_area',
+                    'shmdt',
+                    'swapoff']),
+ 'mount': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'personality',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'mprotect': set(['brk',
+                  'capget',
+                  'clone',
+                  'fork',
+                  'get_mempolicy',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'madvise',
+                  'migrate_pages',
+                  'mincore',
+                  'mlockall',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mremap',
+                  'msgrcv',
+                  'munlock',
+                  'munlockall',
+                  'perf_event_open',
+                  'personality',
+                  'pkey_mprotect',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'remap_file_pages',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'shmdt',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'mq_getsetattr': set(['accept4',
+                       'acct',
+                       'dup',
+                       'dup3',
+                       'epoll_create1',
+                       'epoll_ctl',
+                       'eventfd2',
+                       'flock',
+                       'memfd_create',
+                       'mmap_pgoff',
+                       'mq_notify',
+                       'mq_open',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'open',
+                       'open_by_handle_at',
+                       'openat',
+                       'perf_event_open',
+                       'pipe2',
+                       'remap_file_pages',
+                       'setns',
+                       'shmat',
+                       'shmctl',
+                       'shmdt',
+                       'socket',
+                       'socketpair',
+                       'swapoff',
+                       'swapon',
+                       'uselib']),
+ 'mq_notify': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'remap_file_pages',
+                   'rt_sigqueueinfo',
+                   'rt_sigreturn',
+                   'rt_sigtimedwait',
+                   'rt_tgsigqueueinfo',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'tgkill',
+                   'timer_create',
+                   'tkill',
+                   'uselib']),
+ 'mq_open': set(['accept4',
+                 'acct',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'eventfd2',
+                 'flock',
+                 'getcwd',
+                 'lookup_dcookie',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_unlink',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'pivot_root',
+                 'quotactl',
+                 'remap_file_pages',
+                 'renameat2',
+                 'rmdir',
+                 'setns',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'socket',
+                 'socketpair',
+                 'swapoff',
+                 'swapon',
+                 'symlinkat',
+                 'sysfs',
+                 'unlink',
+                 'unlinkat',
+                 'unshare',
+                 'uselib']),
+ 'mq_timedreceive': set(['accept4',
+                         'acct',
+                         'dup',
+                         'dup3',
+                         'epoll_create1',
+                         'epoll_ctl',
+                         'eventfd2',
+                         'flock',
+                         'memfd_create',
+                         'mmap_pgoff',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_open',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'msgsnd',
+                         'open',
+                         'open_by_handle_at',
+                         'openat',
+                         'perf_event_open',
+                         'pipe2',
+                         'remap_file_pages',
+                         'setns',
+                         'shmat',
+                         'shmctl',
+                         'shmdt',
+                         'socket',
+                         'socketpair',
+                         'swapoff',
+                         'swapon',
+                         'uselib']),
+ 'mq_timedsend': set(['accept4',
+                      'acct',
+                      'dup',
+                      'dup3',
+                      'epoll_create1',
+                      'epoll_ctl',
+                      'eventfd2',
+                      'flock',
+                      'memfd_create',
+                      'mmap_pgoff',
+                      'mq_getsetattr',
+                      'mq_notify',
+                      'mq_open',
+                      'mq_timedreceive',
+                      'open',
+                      'open_by_handle_at',
+                      'openat',
+                      'perf_event_open',
+                      'pipe2',
+                      'remap_file_pages',
+                      'setns',
+                      'shmat',
+                      'shmctl',
+                      'shmdt',
+                      'socket',
+                      'socketpair',
+                      'swapoff',
+                      'swapon',
+                      'uselib']),
+ 'mremap': set(['brk',
+                'capget',
+                'clone',
+                'fork',
+                'get_mempolicy',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'io_cancel',
+                'io_destroy',
+                'io_getevents',
+                'io_setup',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'madvise',
+                'mbind',
+                'migrate_pages',
+                'mincore',
+                'mlockall',
+                'modify_ldt',
+                'move_pages',
+                'mprotect',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'munlock',
+                'munlockall',
+                'perf_event_open',
+                'personality',
+                'pkey_mprotect',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'remap_file_pages',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'shmdt',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'swapoff',
+                'umount',
+                'vfork']),
+ 'msgctl': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgget',
+                'msgrcv',
+                'msgsnd',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semctl',
+                'semget',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'shmat',
+                'shmctl',
+                'shmget',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'msgrcv': set(['mq_timedreceive', 'mq_timedsend', 'msgsnd']),
+ 'msgsnd': set(['mq_open',
+                'mq_unlink',
+                'msgctl',
+                'msgget',
+                'msgrcv',
+                'semctl',
+                'semget',
+                'semtimedop',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmget']),
+ 'msync': set(['brk',
+               'get_mempolicy',
+               'madvise',
+               'mincore',
+               'mlockall',
+               'mprotect',
+               'mremap',
+               'munlock',
+               'munlockall',
+               'pkey_mprotect',
+               'prctl',
+               'remap_file_pages',
+               'shmdt']),
+ 'munlock': set(['brk',
+                 'capget',
+                 'clone',
+                 'fork',
+                 'get_mempolicy',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'madvise',
+                 'migrate_pages',
+                 'mincore',
+                 'mlockall',
+                 'move_pages',
+                 'mprotect',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'mremap',
+                 'msgrcv',
+                 'munlockall',
+                 'perf_event_open',
+                 'pkey_mprotect',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'remap_file_pages',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'shmdt',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'munlockall': set(['brk',
+                    'get_mempolicy',
+                    'madvise',
+                    'mincore',
+                    'mlockall',
+                    'mprotect',
+                    'mremap',
+                    'munlock',
+                    'pkey_mprotect',
+                    'prctl',
+                    'remap_file_pages',
+                    'shmdt']),
+ 'name_to_handle_at': set(['accept4',
+                           'acct',
+                           'dup',
+                           'dup3',
+                           'epoll_create1',
+                           'epoll_ctl',
+                           'eventfd2',
+                           'flock',
+                           'getcwd',
+                           'lookup_dcookie',
+                           'memfd_create',
+                           'mmap_pgoff',
+                           'mq_open',
+                           'open',
+                           'open_by_handle_at',
+                           'openat',
+                           'perf_event_open',
+                           'pipe2',
+                           'pivot_root',
+                           'quotactl',
+                           'remap_file_pages',
+                           'setns',
+                           'shmat',
+                           'shmctl',
+                           'shmdt',
+                           'socket',
+                           'socketpair',
+                           'swapoff',
+                           'swapon',
+                           'syncfs',
+                           'umount',
+                           'unshare',
+                           'uselib',
+                           'ustat']),
+ 'nanosleep': set(['clock_nanosleep',
+                   'epoll_wait',
+                   'faccessat',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fstat',
+                   'ftruncate',
+                   'futex',
+                   'futimesat',
+                   'inotify_add_watch',
+                   'io_getevents',
+                   'ioctl',
+                   'linkat',
+                   'memfd_create',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'newfstat',
+                   'poll',
+                   'ppoll',
+                   'pselect6',
+                   'readlinkat',
+                   'recvmmsg',
+                   'rt_sigtimedwait',
+                   'sched_rr_get_interval',
+                   'select',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'settimeofday',
+                   'stime',
+                   'swapoff',
+                   'swapon',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime']),
+ 'newfstat': set(['fstat', 'newfstatat', 'newlstat', 'newstat']),
+ 'newfstatat': set(['fstat', 'newfstat', 'newlstat', 'newstat']),
+ 'newlstat': set(['fstat', 'newfstat', 'newfstatat', 'newstat']),
+ 'newstat': set(['fstat', 'newfstat', 'newfstatat', 'newlstat']),
+ 'newuname': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'personality',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'old_getrlimit': set(['prlimit64', 'setrlimit']),
+ 'old_readdir': set(['accept4',
+                     'bind',
+                     'bpf',
+                     'connect',
+                     'copy_file_range',
+                     'epoll_ctl',
+                     'epoll_wait',
+                     'fallocate',
+                     'fchdir',
+                     'fchmod',
+                     'fchown',
+                     'fcntl',
+                     'fcntl64',
+                     'fdatasync',
+                     'fgetxattr',
+                     'flistxattr',
+                     'flock',
+                     'fremovexattr',
+                     'fsetxattr',
+                     'fstatfs',
+                     'fstatfs64',
+                     'fsync',
+                     'ftruncate',
+                     'futimesat',
+                     'getdents',
+                     'getdents64',
+                     'getpeername',
+                     'getsockname',
+                     'getsockopt',
+                     'inotify_add_watch',
+                     'inotify_rm_watch',
+                     'ioctl',
+                     'listen',
+                     'llseek',
+                     'lseek',
+                     'mq_getsetattr',
+                     'mq_notify',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'perf_event_open',
+                     'pread64',
+                     'preadv',
+                     'preadv2',
+                     'preadv64',
+                     'preadv64v2',
+                     'pwrite64',
+                     'pwritev',
+                     'pwritev2',
+                     'pwritev64',
+                     'pwritev64v2',
+                     'read',
+                     'readahead',
+                     'readv',
+                     'recvfrom',
+                     'sendfile',
+                     'sendfile64',
+                     'sendto',
+                     'setsockopt',
+                     'shutdown',
+                     'signalfd4',
+                     'splice',
+                     'sync_file_range',
+                     'syncfs',
+                     'tee',
+                     'utime',
+                     'utimensat',
+                     'vmsplice',
+                     'write',
+                     'writev']),
+ 'olduname': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioperm',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'personality',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'open_by_handle_at': set(['accept4',
+                           'acct',
+                           'dup',
+                           'dup3',
+                           'epoll_create1',
+                           'epoll_ctl',
+                           'eventfd2',
+                           'flock',
+                           'getcwd',
+                           'lookup_dcookie',
+                           'memfd_create',
+                           'mmap_pgoff',
+                           'mq_open',
+                           'open',
+                           'openat',
+                           'perf_event_open',
+                           'pipe2',
+                           'pivot_root',
+                           'quotactl',
+                           'remap_file_pages',
+                           'setns',
+                           'shmat',
+                           'shmctl',
+                           'shmdt',
+                           'socket',
+                           'socketpair',
+                           'swapoff',
+                           'swapon',
+                           'unshare',
+                           'uselib']),
+ 'perf_event_open': set(['accept4',
+                         'acct',
+                         'bind',
+                         'bpf',
+                         'brk',
+                         'capget',
+                         'clone',
+                         'connect',
+                         'copy_file_range',
+                         'delete_module',
+                         'dup',
+                         'dup2',
+                         'dup3',
+                         'epoll_create1',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'eventfd2',
+                         'exit_group',
+                         'faccessat',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchmodat',
+                         'fchown',
+                         'fchownat',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'finit_module',
+                         'flistxattr',
+                         'flock',
+                         'fork',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'get_curr_temp',
+                         'get_mempolicy',
+                         'get_robust_list',
+                         'get_trip_temp',
+                         'getcwd',
+                         'getdents',
+                         'getdents64',
+                         'getgroups',
+                         'getgroups16',
+                         'getitimer',
+                         'getpeername',
+                         'getpgid',
+                         'getppid',
+                         'getpriority',
+                         'getrusage',
+                         'getsid',
+                         'getsockname',
+                         'getsockopt',
+                         'init_module',
+                         'inotify_add_watch',
+                         'inotify_init1',
+                         'inotify_rm_watch',
+                         'io_cancel',
+                         'io_destroy',
+                         'io_getevents',
+                         'io_setup',
+                         'io_submit',
+                         'ioctl',
+                         'ioperm',
+                         'ioprio_get',
+                         'ioprio_set',
+                         'kexec_load',
+                         'keyctl',
+                         'kill',
+                         'linkat',
+                         'listen',
+                         'llseek',
+                         'lookup_dcookie',
+                         'lseek',
+                         'madvise',
+                         'mbind',
+                         'memfd_create',
+                         'migrate_pages',
+                         'mincore',
+                         'mkdirat',
+                         'mknodat',
+                         'mlockall',
+                         'mmap_pgoff',
+                         'modify_ldt',
+                         'move_pages',
+                         'mprotect',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_open',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'mq_unlink',
+                         'mremap',
+                         'msgctl',
+                         'msgrcv',
+                         'msgsnd',
+                         'munlock',
+                         'munlockall',
+                         'old_readdir',
+                         'open',
+                         'open_by_handle_at',
+                         'openat',
+                         'pipe2',
+                         'pivot_root',
+                         'pkey_mprotect',
+                         'prctl',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'prlimit64',
+                         'ptrace',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'quotactl',
+                         'read',
+                         'readahead',
+                         'readlinkat',
+                         'readv',
+                         'reboot',
+                         'recvfrom',
+                         'remap_file_pages',
+                         'renameat2',
+                         'request_key',
+                         'rmdir',
+                         'rt_sigaction',
+                         'rt_sigprocmask',
+                         'rt_sigtimedwait',
+                         'sched_getaffinity',
+                         'sched_getattr',
+                         'sched_getparam',
+                         'sched_getscheduler',
+                         'sched_rr_get_interval',
+                         'sched_setaffinity',
+                         'sched_setattr',
+                         'sched_setparam',
+                         'sched_setscheduler',
+                         'sched_yield',
+                         'semctl',
+                         'semtimedop',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'set_trip_temp',
+                         'setgid',
+                         'setgroups',
+                         'setgroups16',
+                         'setitimer',
+                         'setns',
+                         'setpgid',
+                         'setpriority',
+                         'setregid',
+                         'setresgid',
+                         'setresuid',
+                         'setreuid',
+                         'setsid',
+                         'setsockopt',
+                         'setuid',
+                         'shmat',
+                         'shmctl',
+                         'shmdt',
+                         'shutdown',
+                         'sigaction',
+                         'sigaltstack',
+                         'signal',
+                         'signalfd4',
+                         'socket',
+                         'socketpair',
+                         'splice',
+                         'swapoff',
+                         'swapon',
+                         'symlinkat',
+                         'sync_file_range',
+                         'syncfs',
+                         'tee',
+                         'timer_create',
+                         'timer_delete',
+                         'timer_getoverrun',
+                         'timer_gettime',
+                         'timer_settime',
+                         'timerfd_create',
+                         'timerfd_gettime',
+                         'timerfd_settime',
+                         'umount',
+                         'unlink',
+                         'unlinkat',
+                         'unshare',
+                         'uselib',
+                         'ustat',
+                         'utime',
+                         'utimensat',
+                         'vfork',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'pivot_root': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'ftruncate',
+                    'getcwd',
+                    'linkat',
+                    'lookup_dcookie',
+                    'memfd_create',
+                    'mkdirat',
+                    'mknodat',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'mq_unlink',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'quotactl',
+                    'remap_file_pages',
+                    'renameat2',
+                    'rmdir',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'symlinkat',
+                    'umount',
+                    'unlink',
+                    'unlinkat',
+                    'unshare',
+                    'uselib']),
+ 'pkey_alloc': set(['brk',
+                    'get_mempolicy',
+                    'getrusage',
+                    'io_cancel',
+                    'io_destroy',
+                    'io_getevents',
+                    'io_setup',
+                    'mbind',
+                    'migrate_pages',
+                    'mincore',
+                    'modify_ldt',
+                    'move_pages',
+                    'mremap',
+                    'pkey_free',
+                    'prctl',
+                    'remap_file_pages',
+                    'shmdt',
+                    'swapoff']),
+ 'pkey_mprotect': set(['brk',
+                       'capget',
+                       'clone',
+                       'fork',
+                       'get_mempolicy',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'madvise',
+                       'migrate_pages',
+                       'mincore',
+                       'mlockall',
+                       'move_pages',
+                       'mprotect',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'mremap',
+                       'msgrcv',
+                       'munlock',
+                       'munlockall',
+                       'perf_event_open',
+                       'personality',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'remap_file_pages',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'shmdt',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'poll': set(['ppoll']),
+ 'ppoll': set(['capget',
+               'clock_nanosleep',
+               'clone',
+               'epoll_wait',
+               'faccessat',
+               'fchmod',
+               'fchmodat',
+               'fchown',
+               'fchownat',
+               'fork',
+               'fstat',
+               'ftruncate',
+               'futex',
+               'futimesat',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'inotify_add_watch',
+               'io_getevents',
+               'ioctl',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'linkat',
+               'memfd_create',
+               'migrate_pages',
+               'move_pages',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mq_unlink',
+               'msgrcv',
+               'nanosleep',
+               'newfstat',
+               'perf_event_open',
+               'personality',
+               'poll',
+               'prctl',
+               'prlimit64',
+               'pselect6',
+               'ptrace',
+               'readlinkat',
+               'recvmmsg',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'select',
+               'semtimedop',
+               'sendfile',
+               'sendfile64',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'settimeofday',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'stime',
+               'swapoff',
+               'swapon',
+               'timer_gettime',
+               'timer_settime',
+               'timerfd_gettime',
+               'timerfd_settime',
+               'umount',
+               'unlink',
+               'unlinkat',
+               'uselib',
+               'utime',
+               'vfork']),
+ 'prctl': set(['brk',
+               'capget',
+               'clone',
+               'fork',
+               'get_mempolicy',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'io_cancel',
+               'io_destroy',
+               'io_getevents',
+               'io_setup',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'mbind',
+               'migrate_pages',
+               'mincore',
+               'modify_ldt',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mremap',
+               'msgrcv',
+               'perf_event_open',
+               'personality',
+               'prlimit64',
+               'ptrace',
+               'remap_file_pages',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setresuid',
+               'setreuid',
+               'setsid',
+               'setuid',
+               'shmdt',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'swapoff',
+               'umount',
+               'vfork']),
+ 'pread64': set(['accept4',
+                 'acct',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'eventfd2',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fcntl64',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'old_readdir',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'remap_file_pages',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setns',
+                 'setsockopt',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'shutdown',
+                 'signalfd4',
+                 'socket',
+                 'socketpair',
+                 'splice',
+                 'swapoff',
+                 'swapon',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'uselib',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'preadv': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_open',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'remap_file_pages',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'uselib']),
+ 'preadv2': set(['accept4',
+                 'acct',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'eventfd2',
+                 'flock',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_open',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'remap_file_pages',
+                 'setns',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'socket',
+                 'socketpair',
+                 'swapoff',
+                 'swapon',
+                 'uselib']),
+ 'preadv64': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'uselib']),
+ 'preadv64v2': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'uselib']),
+ 'prlimit64': set(['capget',
+                   'capset',
+                   'clone',
+                   'epoll_create1',
+                   'faccessat',
+                   'fork',
+                   'get_robust_list',
+                   'getgroups',
+                   'getgroups16',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getresgid',
+                   'getresgid16',
+                   'getresuid',
+                   'getresuid16',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'old_getrlimit',
+                   'perf_event_open',
+                   'prctl',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setfsgid',
+                   'setfsuid',
+                   'setgid',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresgid',
+                   'setresuid',
+                   'setreuid',
+                   'setrlimit',
+                   'setsid',
+                   'setuid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'unshare',
+                   'vfork']),
+ 'pselect6': set(['capget',
+                  'clock_nanosleep',
+                  'clone',
+                  'epoll_wait',
+                  'faccessat',
+                  'fchmod',
+                  'fchmodat',
+                  'fchown',
+                  'fchownat',
+                  'fork',
+                  'fstat',
+                  'ftruncate',
+                  'futex',
+                  'futimesat',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'inotify_add_watch',
+                  'io_getevents',
+                  'ioctl',
+                  'ioperm',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'linkat',
+                  'memfd_create',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mq_unlink',
+                  'msgrcv',
+                  'nanosleep',
+                  'newfstat',
+                  'perf_event_open',
+                  'poll',
+                  'ppoll',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'readlinkat',
+                  'recvmmsg',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'select',
+                  'semtimedop',
+                  'sendfile',
+                  'sendfile64',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'settimeofday',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'stime',
+                  'swapoff',
+                  'swapon',
+                  'timer_gettime',
+                  'timer_settime',
+                  'timerfd_gettime',
+                  'timerfd_settime',
+                  'umount',
+                  'unlink',
+                  'unlinkat',
+                  'uselib',
+                  'utime',
+                  'vfork']),
+ 'ptrace': set(['capget',
+                'clone',
+                'epoll_wait',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'pause',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigsuspend',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'sigsuspend',
+                'umount',
+                'vfork']),
+ 'pwrite64': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'pwritev': set(['accept4',
+                 'acct',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'eventfd2',
+                 'flock',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_open',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'remap_file_pages',
+                 'setns',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'socket',
+                 'socketpair',
+                 'swapoff',
+                 'swapon',
+                 'uselib']),
+ 'pwritev2': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'uselib']),
+ 'pwritev64': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'remap_file_pages',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'uselib']),
+ 'pwritev64v2': set(['accept4',
+                     'acct',
+                     'dup',
+                     'dup3',
+                     'epoll_create1',
+                     'epoll_ctl',
+                     'eventfd2',
+                     'flock',
+                     'memfd_create',
+                     'mmap_pgoff',
+                     'mq_open',
+                     'open',
+                     'open_by_handle_at',
+                     'openat',
+                     'perf_event_open',
+                     'pipe2',
+                     'remap_file_pages',
+                     'setns',
+                     'shmat',
+                     'shmctl',
+                     'shmdt',
+                     'socket',
+                     'socketpair',
+                     'swapoff',
+                     'swapon',
+                     'uselib']),
+ 'quotactl': set(['acct',
+                  'mq_open',
+                  'mq_unlink',
+                  'open',
+                  'openat',
+                  'renameat2',
+                  'rmdir',
+                  'swapoff',
+                  'swapon',
+                  'symlinkat',
+                  'syncfs',
+                  'sysfs',
+                  'umount',
+                  'unlink',
+                  'unlinkat',
+                  'uselib',
+                  'ustat']),
+ 'read': set(['accept4',
+              'bind',
+              'bpf',
+              'connect',
+              'copy_file_range',
+              'epoll_ctl',
+              'epoll_wait',
+              'fallocate',
+              'fchdir',
+              'fchmod',
+              'fchown',
+              'fcntl',
+              'fcntl64',
+              'fdatasync',
+              'fgetxattr',
+              'flistxattr',
+              'flock',
+              'fremovexattr',
+              'fsetxattr',
+              'fstatfs',
+              'fstatfs64',
+              'fsync',
+              'ftruncate',
+              'futimesat',
+              'getdents',
+              'getdents64',
+              'getpeername',
+              'getsockname',
+              'getsockopt',
+              'inotify_add_watch',
+              'inotify_rm_watch',
+              'ioctl',
+              'listen',
+              'llseek',
+              'lseek',
+              'mq_getsetattr',
+              'mq_notify',
+              'mq_timedreceive',
+              'mq_timedsend',
+              'old_readdir',
+              'perf_event_open',
+              'pread64',
+              'preadv',
+              'preadv2',
+              'preadv64',
+              'preadv64v2',
+              'pwrite64',
+              'pwritev',
+              'pwritev2',
+              'pwritev64',
+              'pwritev64v2',
+              'readahead',
+              'readv',
+              'recvfrom',
+              'sendfile',
+              'sendfile64',
+              'sendto',
+              'setsockopt',
+              'shutdown',
+              'signalfd4',
+              'splice',
+              'sync_file_range',
+              'syncfs',
+              'tee',
+              'utime',
+              'utimensat',
+              'vmsplice',
+              'write',
+              'writev']),
+ 'readahead': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'eventfd2',
+                   'faccessat',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'linkat',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readlinkat',
+                   'readv',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setns',
+                   'setsockopt',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'signalfd4',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'readlinkat': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'getcwd',
+                    'lookup_dcookie',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'pivot_root',
+                    'quotactl',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'unshare',
+                    'uselib']),
+ 'reboot': set(['acct', 'perf_event_open', 'setns']),
+ 'recvfrom': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'uselib']),
+ 'recvmmsg': set(['accept4',
+                  'bind',
+                  'clock_nanosleep',
+                  'connect',
+                  'epoll_wait',
+                  'faccessat',
+                  'fchmod',
+                  'fchmodat',
+                  'fchown',
+                  'fchownat',
+                  'fstat',
+                  'ftruncate',
+                  'futex',
+                  'futimesat',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'io_getevents',
+                  'ioctl',
+                  'linkat',
+                  'listen',
+                  'memfd_create',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mq_unlink',
+                  'nanosleep',
+                  'newfstat',
+                  'poll',
+                  'ppoll',
+                  'pselect6',
+                  'readlinkat',
+                  'recvfrom',
+                  'recvmsg',
+                  'rt_sigtimedwait',
+                  'sched_rr_get_interval',
+                  'select',
+                  'semtimedop',
+                  'sendfile',
+                  'sendfile64',
+                  'sendmmsg',
+                  'sendmsg',
+                  'sendto',
+                  'setsockopt',
+                  'settimeofday',
+                  'shutdown',
+                  'stime',
+                  'swapoff',
+                  'swapon',
+                  'timer_gettime',
+                  'timer_settime',
+                  'timerfd_gettime',
+                  'timerfd_settime',
+                  'unlink',
+                  'unlinkat',
+                  'uselib',
+                  'utime']),
+ 'recvmsg': set(['accept4',
+                 'bind',
+                 'connect',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'listen',
+                 'recvfrom',
+                 'recvmmsg',
+                 'sendmmsg',
+                 'sendmsg',
+                 'sendto',
+                 'setsockopt',
+                 'shutdown']),
+ 'remap_file_pages': set(['brk',
+                          'get_mempolicy',
+                          'madvise',
+                          'mincore',
+                          'mlockall',
+                          'mprotect',
+                          'mremap',
+                          'munlock',
+                          'munlockall',
+                          'pkey_mprotect',
+                          'prctl',
+                          'shmdt']),
+ 'removexattr': set(['accept4',
+                     'acct',
+                     'dup',
+                     'dup3',
+                     'epoll_create1',
+                     'epoll_ctl',
+                     'eventfd2',
+                     'flock',
+                     'getcwd',
+                     'lookup_dcookie',
+                     'memfd_create',
+                     'mmap_pgoff',
+                     'mq_open',
+                     'open',
+                     'open_by_handle_at',
+                     'openat',
+                     'perf_event_open',
+                     'pipe2',
+                     'pivot_root',
+                     'quotactl',
+                     'remap_file_pages',
+                     'setns',
+                     'shmat',
+                     'shmctl',
+                     'shmdt',
+                     'socket',
+                     'socketpair',
+                     'swapoff',
+                     'swapon',
+                     'unshare',
+                     'uselib']),
+ 'renameat2': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'flock',
+                   'ftruncate',
+                   'getcwd',
+                   'linkat',
+                   'lookup_dcookie',
+                   'memfd_create',
+                   'mkdirat',
+                   'mknodat',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'mq_unlink',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pivot_root',
+                   'quotactl',
+                   'remap_file_pages',
+                   'rmdir',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'symlinkat',
+                   'sysfs',
+                   'unlink',
+                   'unlinkat',
+                   'unshare',
+                   'uselib']),
+ 'rmdir': set(['accept4',
+               'acct',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'eventfd2',
+               'flock',
+               'ftruncate',
+               'getcwd',
+               'linkat',
+               'lookup_dcookie',
+               'memfd_create',
+               'mkdirat',
+               'mknodat',
+               'mmap_pgoff',
+               'mq_open',
+               'mq_unlink',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pivot_root',
+               'quotactl',
+               'remap_file_pages',
+               'renameat2',
+               'setns',
+               'shmat',
+               'shmctl',
+               'shmdt',
+               'socket',
+               'socketpair',
+               'swapoff',
+               'swapon',
+               'symlinkat',
+               'unlink',
+               'unlinkat',
+               'unshare',
+               'uselib']),
+ 'rt_sigqueueinfo': set(['kill',
+                         'rt_sigreturn',
+                         'rt_sigtimedwait',
+                         'rt_tgsigqueueinfo',
+                         'tgkill',
+                         'timer_create',
+                         'tkill']),
+ 'rt_sigreturn': set(['capget',
+                      'clone',
+                      'fork',
+                      'get_robust_list',
+                      'getitimer',
+                      'getpgid',
+                      'getppid',
+                      'getpriority',
+                      'getrusage',
+                      'getsid',
+                      'ioperm',
+                      'ioprio_get',
+                      'ioprio_set',
+                      'keyctl',
+                      'kill',
+                      'migrate_pages',
+                      'move_pages',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'msgrcv',
+                      'perf_event_open',
+                      'prctl',
+                      'prlimit64',
+                      'ptrace',
+                      'rt_sigaction',
+                      'rt_sigprocmask',
+                      'rt_sigtimedwait',
+                      'sched_getaffinity',
+                      'sched_getattr',
+                      'sched_getparam',
+                      'sched_getscheduler',
+                      'sched_rr_get_interval',
+                      'sched_setaffinity',
+                      'sched_setattr',
+                      'sched_setparam',
+                      'sched_setscheduler',
+                      'semtimedop',
+                      'setitimer',
+                      'setns',
+                      'setpgid',
+                      'setpriority',
+                      'setsid',
+                      'sigaction',
+                      'sigaltstack',
+                      'signal',
+                      'umount',
+                      'vfork']),
+ 'rt_sigtimedwait': set(['capget',
+                         'clone',
+                         'fork',
+                         'get_robust_list',
+                         'getitimer',
+                         'getpgid',
+                         'getppid',
+                         'getpriority',
+                         'getrusage',
+                         'getsid',
+                         'ioperm',
+                         'ioprio_get',
+                         'ioprio_set',
+                         'keyctl',
+                         'kill',
+                         'migrate_pages',
+                         'move_pages',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'perf_event_open',
+                         'prctl',
+                         'prlimit64',
+                         'ptrace',
+                         'rt_sigaction',
+                         'rt_sigprocmask',
+                         'rt_sigqueueinfo',
+                         'rt_sigreturn',
+                         'rt_tgsigqueueinfo',
+                         'sched_getaffinity',
+                         'sched_getattr',
+                         'sched_getparam',
+                         'sched_getscheduler',
+                         'sched_rr_get_interval',
+                         'sched_setaffinity',
+                         'sched_setattr',
+                         'sched_setparam',
+                         'sched_setscheduler',
+                         'semtimedop',
+                         'setitimer',
+                         'setns',
+                         'setpgid',
+                         'setpriority',
+                         'setsid',
+                         'sigaction',
+                         'sigaltstack',
+                         'signal',
+                         'tgkill',
+                         'timer_create',
+                         'tkill',
+                         'umount',
+                         'vfork']),
+ 'rt_tgsigqueueinfo': set(['kill',
+                           'rt_sigqueueinfo',
+                           'rt_sigreturn',
+                           'rt_sigtimedwait',
+                           'tgkill',
+                           'timer_create',
+                           'tkill']),
+ 'sched_getattr': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioperm',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'sched_getparam': set(['capget',
+                        'clone',
+                        'fork',
+                        'get_robust_list',
+                        'getitimer',
+                        'getpgid',
+                        'getppid',
+                        'getpriority',
+                        'getrusage',
+                        'getsid',
+                        'ioprio_get',
+                        'ioprio_set',
+                        'keyctl',
+                        'kill',
+                        'migrate_pages',
+                        'move_pages',
+                        'mq_timedreceive',
+                        'mq_timedsend',
+                        'msgrcv',
+                        'perf_event_open',
+                        'prctl',
+                        'prlimit64',
+                        'ptrace',
+                        'rt_sigaction',
+                        'rt_sigprocmask',
+                        'rt_sigtimedwait',
+                        'sched_getaffinity',
+                        'sched_getattr',
+                        'sched_getscheduler',
+                        'sched_rr_get_interval',
+                        'sched_setaffinity',
+                        'sched_setattr',
+                        'sched_setparam',
+                        'sched_setscheduler',
+                        'semtimedop',
+                        'setitimer',
+                        'setns',
+                        'setpgid',
+                        'setpriority',
+                        'setsid',
+                        'sigaction',
+                        'sigaltstack',
+                        'signal',
+                        'umount',
+                        'vfork']),
+ 'sched_getscheduler': set(['capget',
+                            'clone',
+                            'fork',
+                            'get_robust_list',
+                            'getitimer',
+                            'getpgid',
+                            'getppid',
+                            'getpriority',
+                            'getrusage',
+                            'getsid',
+                            'ioprio_get',
+                            'ioprio_set',
+                            'keyctl',
+                            'kill',
+                            'migrate_pages',
+                            'move_pages',
+                            'mq_timedreceive',
+                            'mq_timedsend',
+                            'msgrcv',
+                            'perf_event_open',
+                            'prctl',
+                            'prlimit64',
+                            'ptrace',
+                            'rt_sigaction',
+                            'rt_sigprocmask',
+                            'rt_sigtimedwait',
+                            'sched_getaffinity',
+                            'sched_getattr',
+                            'sched_getparam',
+                            'sched_rr_get_interval',
+                            'sched_setaffinity',
+                            'sched_setattr',
+                            'sched_setparam',
+                            'sched_setscheduler',
+                            'semtimedop',
+                            'setitimer',
+                            'setns',
+                            'setpgid',
+                            'setpriority',
+                            'setsid',
+                            'sigaction',
+                            'sigaltstack',
+                            'signal',
+                            'umount',
+                            'vfork']),
+ 'sched_setaffinity': set(['capget',
+                           'capset',
+                           'clone',
+                           'epoll_create1',
+                           'faccessat',
+                           'fork',
+                           'get_robust_list',
+                           'getgroups',
+                           'getgroups16',
+                           'getitimer',
+                           'getpgid',
+                           'getppid',
+                           'getpriority',
+                           'getresgid',
+                           'getresgid16',
+                           'getresuid',
+                           'getresuid16',
+                           'getrusage',
+                           'getsid',
+                           'ioprio_get',
+                           'ioprio_set',
+                           'keyctl',
+                           'kill',
+                           'migrate_pages',
+                           'move_pages',
+                           'mq_timedreceive',
+                           'mq_timedsend',
+                           'msgrcv',
+                           'perf_event_open',
+                           'prctl',
+                           'prlimit64',
+                           'ptrace',
+                           'rt_sigaction',
+                           'rt_sigprocmask',
+                           'rt_sigtimedwait',
+                           'sched_getaffinity',
+                           'sched_getattr',
+                           'sched_getparam',
+                           'sched_getscheduler',
+                           'sched_rr_get_interval',
+                           'sched_setattr',
+                           'sched_setparam',
+                           'sched_setscheduler',
+                           'semtimedop',
+                           'setfsgid',
+                           'setfsuid',
+                           'setgid',
+                           'setitimer',
+                           'setns',
+                           'setpgid',
+                           'setpriority',
+                           'setregid',
+                           'setresgid',
+                           'setresuid',
+                           'setreuid',
+                           'setsid',
+                           'setuid',
+                           'sigaction',
+                           'sigaltstack',
+                           'signal',
+                           'umount',
+                           'unshare',
+                           'vfork']),
+ 'sched_setattr': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioperm',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'select': set(['capget',
+                'clock_nanosleep',
+                'clone',
+                'dup2',
+                'dup3',
+                'epoll_wait',
+                'faccessat',
+                'fchmod',
+                'fchmodat',
+                'fchown',
+                'fchownat',
+                'fork',
+                'fstat',
+                'ftruncate',
+                'futex',
+                'futimesat',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'inotify_add_watch',
+                'io_getevents',
+                'ioctl',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'linkat',
+                'memfd_create',
+                'migrate_pages',
+                'move_pages',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgrcv',
+                'nanosleep',
+                'newfstat',
+                'perf_event_open',
+                'personality',
+                'poll',
+                'ppoll',
+                'prctl',
+                'prlimit64',
+                'pselect6',
+                'ptrace',
+                'readlinkat',
+                'recvmmsg',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'sendfile',
+                'sendfile64',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'settimeofday',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'stime',
+                'swapoff',
+                'swapon',
+                'timer_gettime',
+                'timer_settime',
+                'timerfd_gettime',
+                'timerfd_settime',
+                'umount',
+                'unlink',
+                'unlinkat',
+                'unshare',
+                'uselib',
+                'utime',
+                'vfork']),
+ 'semctl': set(['semtimedop']),
+ 'semtimedop': set(['accept4',
+                    'acct',
+                    'bpf',
+                    'brk',
+                    'capget',
+                    'clock_nanosleep',
+                    'clone',
+                    'delete_module',
+                    'dup',
+                    'dup2',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'eventfd2',
+                    'exit_group',
+                    'faccessat',
+                    'fchmod',
+                    'fchmodat',
+                    'fchown',
+                    'fchownat',
+                    'finit_module',
+                    'flock',
+                    'fork',
+                    'fstat',
+                    'ftruncate',
+                    'futex',
+                    'futimesat',
+                    'get_curr_temp',
+                    'get_mempolicy',
+                    'get_robust_list',
+                    'get_trip_temp',
+                    'getcwd',
+                    'getgroups',
+                    'getgroups16',
+                    'getitimer',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'init_module',
+                    'inotify_add_watch',
+                    'inotify_init1',
+                    'inotify_rm_watch',
+                    'io_cancel',
+                    'io_destroy',
+                    'io_getevents',
+                    'io_setup',
+                    'io_submit',
+                    'ioctl',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'kexec_load',
+                    'keyctl',
+                    'kill',
+                    'linkat',
+                    'lookup_dcookie',
+                    'madvise',
+                    'mbind',
+                    'memfd_create',
+                    'migrate_pages',
+                    'mincore',
+                    'mkdirat',
+                    'mknodat',
+                    'mlockall',
+                    'mmap_pgoff',
+                    'modify_ldt',
+                    'move_pages',
+                    'mprotect',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_open',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'mq_unlink',
+                    'mremap',
+                    'msgctl',
+                    'msgrcv',
+                    'msgsnd',
+                    'munlock',
+                    'munlockall',
+                    'nanosleep',
+                    'newfstat',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'pivot_root',
+                    'pkey_mprotect',
+                    'poll',
+                    'ppoll',
+                    'prctl',
+                    'prlimit64',
+                    'pselect6',
+                    'ptrace',
+                    'quotactl',
+                    'readahead',
+                    'readlinkat',
+                    'reboot',
+                    'recvmmsg',
+                    'remap_file_pages',
+                    'renameat2',
+                    'request_key',
+                    'rmdir',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'sched_yield',
+                    'select',
+                    'semctl',
+                    'sendfile',
+                    'sendfile64',
+                    'set_trip_temp',
+                    'setgid',
+                    'setgroups',
+                    'setgroups16',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setregid',
+                    'setresgid',
+                    'setresuid',
+                    'setreuid',
+                    'setsid',
+                    'settimeofday',
+                    'setuid',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'socket',
+                    'socketpair',
+                    'splice',
+                    'stime',
+                    'swapoff',
+                    'swapon',
+                    'symlinkat',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'timer_create',
+                    'timer_delete',
+                    'timer_getoverrun',
+                    'timer_gettime',
+                    'timer_settime',
+                    'timerfd_create',
+                    'timerfd_gettime',
+                    'timerfd_settime',
+                    'umount',
+                    'unlink',
+                    'unlinkat',
+                    'unshare',
+                    'uselib',
+                    'ustat',
+                    'utime',
+                    'vfork',
+                    'vmsplice']),
+ 'sendfile': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'uselib']),
+ 'sendfile64': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'flock',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'uselib']),
+ 'sendmmsg': set(['accept4',
+                  'bind',
+                  'connect',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'listen',
+                  'recvfrom',
+                  'recvmmsg',
+                  'recvmsg',
+                  'sendmsg',
+                  'sendto',
+                  'setsockopt',
+                  'shutdown']),
+ 'sendmsg': set(['accept4',
+                 'bind',
+                 'connect',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'listen',
+                 'recvfrom',
+                 'recvmmsg',
+                 'recvmsg',
+                 'sendmmsg',
+                 'sendto',
+                 'setsockopt',
+                 'shutdown']),
+ 'sendto': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_open',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'remap_file_pages',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'uselib']),
+ 'set_mempolicy': set(['get_mempolicy', 'mbind']),
+ 'set_thread_area': set(['arch_prctl',
+                         'capget',
+                         'clone',
+                         'fork',
+                         'get_robust_list',
+                         'getitimer',
+                         'getpgid',
+                         'getppid',
+                         'getpriority',
+                         'getrusage',
+                         'getsid',
+                         'ioperm',
+                         'ioprio_get',
+                         'ioprio_set',
+                         'keyctl',
+                         'kill',
+                         'migrate_pages',
+                         'move_pages',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'perf_event_open',
+                         'prctl',
+                         'prlimit64',
+                         'ptrace',
+                         'rt_sigaction',
+                         'rt_sigprocmask',
+                         'rt_sigtimedwait',
+                         'sched_getaffinity',
+                         'sched_getattr',
+                         'sched_getparam',
+                         'sched_getscheduler',
+                         'sched_rr_get_interval',
+                         'sched_setaffinity',
+                         'sched_setattr',
+                         'sched_setparam',
+                         'sched_setscheduler',
+                         'semtimedop',
+                         'setitimer',
+                         'setns',
+                         'setpgid',
+                         'setpriority',
+                         'setsid',
+                         'sigaction',
+                         'sigaltstack',
+                         'signal',
+                         'umount',
+                         'vfork']),
+ 'set_trip_temp': set(['get_curr_temp', 'get_trip_temp']),
+ 'setdomainname': set(['setns']),
+ 'setfsgid': set(['capget',
+                  'capset',
+                  'clone',
+                  'epoll_create1',
+                  'faccessat',
+                  'fork',
+                  'get_robust_list',
+                  'getgroups',
+                  'getgroups16',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getresgid',
+                  'getresgid16',
+                  'getresuid',
+                  'getresuid16',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setfsuid',
+                  'setgid',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setregid',
+                  'setresgid',
+                  'setresuid',
+                  'setreuid',
+                  'setsid',
+                  'setuid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'unshare',
+                  'vfork']),
+ 'setfsuid': set(['capget',
+                  'capset',
+                  'clone',
+                  'epoll_create1',
+                  'faccessat',
+                  'fork',
+                  'get_robust_list',
+                  'getgroups',
+                  'getgroups16',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getresgid',
+                  'getresgid16',
+                  'getresuid',
+                  'getresuid16',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setfsgid',
+                  'setgid',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setregid',
+                  'setresgid',
+                  'setresuid',
+                  'setreuid',
+                  'setsid',
+                  'setuid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'unshare',
+                  'vfork']),
+ 'setgid': set(['capget',
+                'capset',
+                'clone',
+                'epoll_create1',
+                'faccessat',
+                'fork',
+                'get_robust_list',
+                'getgroups',
+                'getgroups16',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getresgid',
+                'getresgid16',
+                'getresuid',
+                'getresuid16',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setfsgid',
+                'setfsuid',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setregid',
+                'setresgid',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'unshare',
+                'vfork']),
+ 'setgroups16': set(['setgroups']),
+ 'sethostname': set(['setns']),
+ 'setitimer': set(['adjtimex',
+                   'alarm',
+                   'clock_adjtime',
+                   'exit_group',
+                   'getitimer',
+                   'getrusage',
+                   'ppoll',
+                   'select',
+                   'settimeofday',
+                   'timer_create',
+                   'wait4',
+                   'waitid']),
+ 'setpgid': set(['capget',
+                 'clone',
+                 'exit_group',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'perf_event_open',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpriority',
+                 'setresuid',
+                 'setreuid',
+                 'setsid',
+                 'setuid',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'timer_create',
+                 'umount',
+                 'vfork']),
+ 'setpriority': set(['capget',
+                     'clone',
+                     'fork',
+                     'get_robust_list',
+                     'getitimer',
+                     'getpgid',
+                     'getppid',
+                     'getpriority',
+                     'getrusage',
+                     'getsid',
+                     'ioprio_get',
+                     'ioprio_set',
+                     'keyctl',
+                     'kill',
+                     'migrate_pages',
+                     'move_pages',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'msgrcv',
+                     'perf_event_open',
+                     'prctl',
+                     'prlimit64',
+                     'ptrace',
+                     'rt_sigaction',
+                     'rt_sigprocmask',
+                     'rt_sigtimedwait',
+                     'sched_getaffinity',
+                     'sched_getattr',
+                     'sched_getparam',
+                     'sched_getscheduler',
+                     'sched_rr_get_interval',
+                     'sched_setaffinity',
+                     'sched_setattr',
+                     'sched_setparam',
+                     'sched_setscheduler',
+                     'semtimedop',
+                     'setitimer',
+                     'setns',
+                     'setpgid',
+                     'setresuid',
+                     'setreuid',
+                     'setsid',
+                     'setuid',
+                     'sigaction',
+                     'sigaltstack',
+                     'signal',
+                     'umount',
+                     'vfork']),
+ 'setregid': set(['capget',
+                  'capset',
+                  'clone',
+                  'epoll_create1',
+                  'faccessat',
+                  'fork',
+                  'get_robust_list',
+                  'getgroups',
+                  'getgroups16',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getresgid',
+                  'getresgid16',
+                  'getresuid',
+                  'getresuid16',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setfsgid',
+                  'setfsuid',
+                  'setgid',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setresgid',
+                  'setresuid',
+                  'setreuid',
+                  'setsid',
+                  'setuid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'unshare',
+                  'vfork']),
+ 'setresgid': set(['capget',
+                   'capset',
+                   'clone',
+                   'epoll_create1',
+                   'faccessat',
+                   'fork',
+                   'get_robust_list',
+                   'getgroups',
+                   'getgroups16',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getresgid',
+                   'getresgid16',
+                   'getresuid',
+                   'getresuid16',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setfsgid',
+                   'setfsuid',
+                   'setgid',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresuid',
+                   'setreuid',
+                   'setsid',
+                   'setuid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'unshare',
+                   'vfork']),
+ 'setresuid': set(['capget',
+                   'capset',
+                   'clone',
+                   'epoll_create1',
+                   'faccessat',
+                   'fork',
+                   'get_robust_list',
+                   'getgroups',
+                   'getgroups16',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getresgid',
+                   'getresgid16',
+                   'getresuid',
+                   'getresuid16',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setfsgid',
+                   'setfsuid',
+                   'setgid',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setregid',
+                   'setresgid',
+                   'setreuid',
+                   'setsid',
+                   'setuid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'unshare',
+                   'vfork']),
+ 'setreuid': set(['capget',
+                  'capset',
+                  'clone',
+                  'epoll_create1',
+                  'faccessat',
+                  'fork',
+                  'get_robust_list',
+                  'getgroups',
+                  'getgroups16',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getresgid',
+                  'getresgid16',
+                  'getresuid',
+                  'getresuid16',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setfsgid',
+                  'setfsuid',
+                  'setgid',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setregid',
+                  'setresgid',
+                  'setresuid',
+                  'setsid',
+                  'setuid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'unshare',
+                  'vfork']),
+ 'setrlimit': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrlimit',
+                   'getrusage',
+                   'getsid',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'old_getrlimit',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'setsid': set(['exit_group', 'timer_create']),
+ 'setsockopt': set(['accept4']),
+ 'settimeofday': set(['adjtimex',
+                      'alarm',
+                      'clock_adjtime',
+                      'getitimer',
+                      'getrusage',
+                      'ppoll',
+                      'select',
+                      'setitimer',
+                      'wait4',
+                      'waitid']),
+ 'setuid': set(['capget',
+                'capset',
+                'clone',
+                'epoll_create1',
+                'faccessat',
+                'fork',
+                'get_robust_list',
+                'getgroups',
+                'getgroups16',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getresgid',
+                'getresgid16',
+                'getresuid',
+                'getresuid16',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setfsgid',
+                'setfsuid',
+                'setgid',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setregid',
+                'setresgid',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'unshare',
+                'vfork']),
+ 'setxattr': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'getcwd',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'unshare',
+                  'uselib']),
+ 'shmat': set(['accept4',
+               'acct',
+               'capget',
+               'clone',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'eventfd2',
+               'flock',
+               'fork',
+               'get_robust_list',
+               'getcwd',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'lookup_dcookie',
+               'memfd_create',
+               'migrate_pages',
+               'mmap_pgoff',
+               'move_pages',
+               'mq_open',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pivot_root',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'quotactl',
+               'remap_file_pages',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'shmctl',
+               'shmdt',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'socket',
+               'socketpair',
+               'swapoff',
+               'swapon',
+               'umount',
+               'unshare',
+               'uselib',
+               'vfork']),
+ 'shmctl': set(['accept4',
+                'acct',
+                'capget',
+                'clone',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'memfd_create',
+                'migrate_pages',
+                'mmap_pgoff',
+                'move_pages',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgctl',
+                'msgget',
+                'msgrcv',
+                'msgsnd',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'remap_file_pages',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semctl',
+                'semget',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'shmat',
+                'shmdt',
+                'shmget',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'umount',
+                'uselib',
+                'vfork']),
+ 'shmdt': set(['brk',
+               'get_mempolicy',
+               'madvise',
+               'mincore',
+               'mlockall',
+               'mprotect',
+               'mremap',
+               'munlock',
+               'munlockall',
+               'pkey_mprotect',
+               'prctl',
+               'remap_file_pages']),
+ 'sigaction': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioperm',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'signalfd4': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'eventfd2',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setns',
+                   'setsockopt',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'splice': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'stat': set(['fstat', 'lstat', 'newfstat']),
+ 'statfs': set(['fstatfs', 'fstatfs64', 'statfs64', 'ustat']),
+ 'statfs64': set(['fstatfs', 'fstatfs64', 'statfs', 'ustat']),
+ 'swapoff': set(['accept4',
+                 'acct',
+                 'capget',
+                 'clone',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'eventfd2',
+                 'flock',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'memfd_create',
+                 'migrate_pages',
+                 'mmap_pgoff',
+                 'move_pages',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'remap_file_pages',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'socket',
+                 'socketpair',
+                 'swapon',
+                 'umount',
+                 'uselib',
+                 'vfork']),
+ 'swapon': set(['faccessat',
+                'fchmod',
+                'fchmodat',
+                'fchown',
+                'fchownat',
+                'ftruncate',
+                'inotify_add_watch',
+                'ioctl',
+                'linkat',
+                'memfd_create',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'readlinkat',
+                'sendfile',
+                'sendfile64',
+                'swapoff',
+                'unlink',
+                'unlinkat',
+                'uselib']),
+ 'symlinkat': set(['acct',
+                   'mq_open',
+                   'mq_unlink',
+                   'open',
+                   'openat',
+                   'quotactl',
+                   'renameat2',
+                   'rmdir',
+                   'swapoff',
+                   'swapon',
+                   'sysfs',
+                   'unlink',
+                   'unlinkat',
+                   'uselib']),
+ 'sync_file_range': set(['accept4',
+                         'bind',
+                         'bpf',
+                         'connect',
+                         'copy_file_range',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchown',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'flistxattr',
+                         'flock',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'getdents',
+                         'getdents64',
+                         'getpeername',
+                         'getsockname',
+                         'getsockopt',
+                         'inotify_add_watch',
+                         'inotify_rm_watch',
+                         'ioctl',
+                         'listen',
+                         'llseek',
+                         'lseek',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'old_readdir',
+                         'perf_event_open',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'read',
+                         'readahead',
+                         'readv',
+                         'recvfrom',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'setsockopt',
+                         'shutdown',
+                         'signalfd4',
+                         'splice',
+                         'syncfs',
+                         'tee',
+                         'utime',
+                         'utimensat',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'syncfs': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'sysfs': set(['acct',
+               'mq_open',
+               'mq_unlink',
+               'open',
+               'openat',
+               'quotactl',
+               'renameat2',
+               'rmdir',
+               'swapoff',
+               'swapon',
+               'symlinkat',
+               'unlink',
+               'unlinkat',
+               'uselib']),
+ 'sysinfo': set(['capget',
+                 'clock_nanosleep',
+                 'clone',
+                 'epoll_wait',
+                 'faccessat',
+                 'fchmod',
+                 'fchmodat',
+                 'fchown',
+                 'fchownat',
+                 'fork',
+                 'fstat',
+                 'ftruncate',
+                 'futex',
+                 'futimesat',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'inotify_add_watch',
+                 'io_getevents',
+                 'ioctl',
+                 'ioperm',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'linkat',
+                 'memfd_create',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'mq_unlink',
+                 'msgrcv',
+                 'nanosleep',
+                 'newfstat',
+                 'perf_event_open',
+                 'poll',
+                 'ppoll',
+                 'prctl',
+                 'prlimit64',
+                 'pselect6',
+                 'ptrace',
+                 'readlinkat',
+                 'recvmmsg',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'select',
+                 'semtimedop',
+                 'sendfile',
+                 'sendfile64',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'settimeofday',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'stime',
+                 'swapoff',
+                 'swapon',
+                 'timer_gettime',
+                 'timer_settime',
+                 'timerfd_gettime',
+                 'timerfd_settime',
+                 'umount',
+                 'unlink',
+                 'unlinkat',
+                 'uselib',
+                 'utime',
+                 'vfork']),
+ 'syslog': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'tee': set(['accept4',
+             'acct',
+             'bind',
+             'bpf',
+             'connect',
+             'copy_file_range',
+             'dup',
+             'dup3',
+             'epoll_create1',
+             'epoll_ctl',
+             'epoll_wait',
+             'eventfd2',
+             'fallocate',
+             'fchdir',
+             'fchmod',
+             'fchown',
+             'fcntl',
+             'fcntl64',
+             'fdatasync',
+             'fgetxattr',
+             'flistxattr',
+             'flock',
+             'fremovexattr',
+             'fsetxattr',
+             'fstatfs',
+             'fstatfs64',
+             'fsync',
+             'ftruncate',
+             'futimesat',
+             'getdents',
+             'getdents64',
+             'getpeername',
+             'getsockname',
+             'getsockopt',
+             'inotify_add_watch',
+             'inotify_rm_watch',
+             'ioctl',
+             'listen',
+             'llseek',
+             'lseek',
+             'memfd_create',
+             'mmap_pgoff',
+             'mq_getsetattr',
+             'mq_notify',
+             'mq_open',
+             'mq_timedreceive',
+             'mq_timedsend',
+             'old_readdir',
+             'open',
+             'open_by_handle_at',
+             'openat',
+             'perf_event_open',
+             'pipe2',
+             'pread64',
+             'preadv',
+             'preadv2',
+             'preadv64',
+             'preadv64v2',
+             'pwrite64',
+             'pwritev',
+             'pwritev2',
+             'pwritev64',
+             'pwritev64v2',
+             'read',
+             'readahead',
+             'readv',
+             'recvfrom',
+             'remap_file_pages',
+             'sendfile',
+             'sendfile64',
+             'sendto',
+             'setns',
+             'setsockopt',
+             'shmat',
+             'shmctl',
+             'shmdt',
+             'shutdown',
+             'signalfd4',
+             'socket',
+             'socketpair',
+             'splice',
+             'swapoff',
+             'swapon',
+             'sync_file_range',
+             'syncfs',
+             'uselib',
+             'utime',
+             'utimensat',
+             'vmsplice',
+             'write',
+             'writev']),
+ 'tgkill': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'timer_create': set(['clock_adjtime',
+                      'clock_getres',
+                      'clock_gettime',
+                      'clock_nanosleep',
+                      'clock_settime',
+                      'timer_delete',
+                      'timer_getoverrun',
+                      'timer_gettime',
+                      'timer_settime']),
+ 'timer_delete': set(['capget',
+                      'clock_adjtime',
+                      'clock_getres',
+                      'clock_gettime',
+                      'clock_nanosleep',
+                      'clock_settime',
+                      'clone',
+                      'fork',
+                      'get_robust_list',
+                      'getitimer',
+                      'getpgid',
+                      'getppid',
+                      'getpriority',
+                      'getrusage',
+                      'getsid',
+                      'ioprio_get',
+                      'ioprio_set',
+                      'keyctl',
+                      'kill',
+                      'migrate_pages',
+                      'move_pages',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'msgrcv',
+                      'perf_event_open',
+                      'prctl',
+                      'prlimit64',
+                      'ptrace',
+                      'rt_sigaction',
+                      'rt_sigprocmask',
+                      'rt_sigtimedwait',
+                      'sched_getaffinity',
+                      'sched_getattr',
+                      'sched_getparam',
+                      'sched_getscheduler',
+                      'sched_rr_get_interval',
+                      'sched_setaffinity',
+                      'sched_setattr',
+                      'sched_setparam',
+                      'sched_setscheduler',
+                      'semtimedop',
+                      'setitimer',
+                      'setns',
+                      'setpgid',
+                      'setpriority',
+                      'setsid',
+                      'sigaction',
+                      'sigaltstack',
+                      'signal',
+                      'timer_create',
+                      'timer_getoverrun',
+                      'timer_gettime',
+                      'timer_settime',
+                      'umount',
+                      'vfork']),
+ 'timer_getoverrun': set(['capget',
+                          'clone',
+                          'fork',
+                          'get_robust_list',
+                          'getitimer',
+                          'getpgid',
+                          'getppid',
+                          'getpriority',
+                          'getrusage',
+                          'getsid',
+                          'ioprio_get',
+                          'ioprio_set',
+                          'keyctl',
+                          'kill',
+                          'migrate_pages',
+                          'move_pages',
+                          'mq_timedreceive',
+                          'mq_timedsend',
+                          'msgrcv',
+                          'perf_event_open',
+                          'prctl',
+                          'prlimit64',
+                          'ptrace',
+                          'rt_sigaction',
+                          'rt_sigprocmask',
+                          'rt_sigtimedwait',
+                          'sched_getaffinity',
+                          'sched_getattr',
+                          'sched_getparam',
+                          'sched_getscheduler',
+                          'sched_rr_get_interval',
+                          'sched_setaffinity',
+                          'sched_setattr',
+                          'sched_setparam',
+                          'sched_setscheduler',
+                          'semtimedop',
+                          'setitimer',
+                          'setns',
+                          'setpgid',
+                          'setpriority',
+                          'setsid',
+                          'sigaction',
+                          'sigaltstack',
+                          'signal',
+                          'timer_create',
+                          'timer_delete',
+                          'timer_gettime',
+                          'timer_settime',
+                          'umount',
+                          'vfork']),
+ 'timer_gettime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_settime']),
+ 'timer_settime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime']),
+ 'timerfd_create': set(['timerfd_gettime', 'timerfd_settime']),
+ 'timerfd_gettime': set(['timerfd_create', 'timerfd_settime']),
+ 'timerfd_settime': set(['timerfd_create', 'timerfd_gettime']),
+ 'tkill': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'umount': set(['accept4',
+                'acct',
+                'capget',
+                'clone',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'fork',
+                'get_robust_list',
+                'getcwd',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'lookup_dcookie',
+                'memfd_create',
+                'migrate_pages',
+                'mmap_pgoff',
+                'move_pages',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgrcv',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'quotactl',
+                'remap_file_pages',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'syncfs',
+                'unshare',
+                'uselib',
+                'ustat',
+                'vfork']),
+ 'uname': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'personality',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'unlink': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'ftruncate',
+                'getcwd',
+                'linkat',
+                'lookup_dcookie',
+                'memfd_create',
+                'mkdirat',
+                'mknodat',
+                'mmap_pgoff',
+                'mq_open',
+                'mq_unlink',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pivot_root',
+                'quotactl',
+                'remap_file_pages',
+                'renameat2',
+                'rmdir',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'symlinkat',
+                'unlinkat',
+                'unshare',
+                'uselib']),
+ 'unlinkat': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'ftruncate',
+                  'getcwd',
+                  'linkat',
+                  'lookup_dcookie',
+                  'memfd_create',
+                  'mkdirat',
+                  'mknodat',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'mq_unlink',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pivot_root',
+                  'quotactl',
+                  'remap_file_pages',
+                  'renameat2',
+                  'rmdir',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'symlinkat',
+                  'unlink',
+                  'unshare',
+                  'uselib']),
+ 'uselib': set(['acct',
+                'getcwd',
+                'mq_open',
+                'mq_unlink',
+                'pivot_root',
+                'quotactl',
+                'swapon',
+                'syncfs',
+                'umount',
+                'ustat']),
+ 'ustat': set(['quotactl', 'swapon', 'syncfs', 'umount']),
+ 'utime': set(['clock_nanosleep',
+               'epoll_wait',
+               'faccessat',
+               'fchmod',
+               'fchmodat',
+               'fchown',
+               'fchownat',
+               'fstat',
+               'ftruncate',
+               'futex',
+               'futimesat',
+               'inotify_add_watch',
+               'io_getevents',
+               'ioctl',
+               'linkat',
+               'memfd_create',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mq_unlink',
+               'nanosleep',
+               'newfstat',
+               'poll',
+               'ppoll',
+               'pselect6',
+               'readlinkat',
+               'recvmmsg',
+               'rt_sigtimedwait',
+               'sched_rr_get_interval',
+               'select',
+               'semtimedop',
+               'sendfile',
+               'sendfile64',
+               'settimeofday',
+               'stime',
+               'swapoff',
+               'swapon',
+               'timer_gettime',
+               'timer_settime',
+               'timerfd_gettime',
+               'timerfd_settime',
+               'unlink',
+               'unlinkat',
+               'uselib']),
+ 'utimensat': set(['clock_nanosleep',
+                   'epoll_wait',
+                   'faccessat',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'fstat',
+                   'ftruncate',
+                   'futex',
+                   'futimesat',
+                   'inotify_add_watch',
+                   'io_getevents',
+                   'ioctl',
+                   'linkat',
+                   'memfd_create',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'nanosleep',
+                   'newfstat',
+                   'poll',
+                   'ppoll',
+                   'pselect6',
+                   'readlinkat',
+                   'recvmmsg',
+                   'rt_sigtimedwait',
+                   'sched_rr_get_interval',
+                   'select',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'settimeofday',
+                   'stime',
+                   'swapoff',
+                   'swapon',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime']),
+ 'vmsplice': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'write',
+                  'writev']),
+ 'write': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'writev'])}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies_verbose b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies_verbose
new file mode 100644
index 0000000000..21af2bfe3b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies_verbose
@@ -0,0 +1,23692 @@
+{'accept4': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+             {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+             {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+             {'call': 'readahead', 'reason': set([('fd', 'file')])},
+             {'call': 'getdents', 'reason': set([('fd', 'file')])},
+             {'call': 'writev', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+             {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+             {'call': 'pread64', 'reason': set([('fd', 'file')])},
+             {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+             {'call': 'read', 'reason': set([('fd', 'file')])},
+             {'call': 'fchown', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+             {'call': 'utime', 'reason': set([('fd', 'file')])},
+             {'call': 'fsync', 'reason': set([('fd', 'file')])},
+             {'call': 'bpf', 'reason': set([('fd', 'file')])},
+             {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+             {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendto', 'reason': set([('fd', 'file')])},
+             {'call': 'tee', 'reason': set([('fd', 'file')])},
+             {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'lseek', 'reason': set([('fd', 'file')])},
+             {'call': 'connect', 'reason': set([('fd', 'file')])},
+             {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+             {'call': 'flock', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+             {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+             {'call': 'accept4', 'reason': set([('fd', 'file')])},
+             {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+             {'call': 'splice', 'reason': set([('fd', 'file')])},
+             {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv', 'reason': set([('fd', 'file')])},
+             {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+             {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+             {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+             {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+             {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+             {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+             {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+             {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+             {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+             {'call': 'listen', 'reason': set([('fd', 'file')])},
+             {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+             {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+             {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+             {'call': 'llseek', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'readv', 'reason': set([('fd', 'file')])},
+             {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+             {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+             {'call': 'write', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+             {'call': 'bind', 'reason': set([('fd', 'file')])},
+             {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'acct': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+          {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+          {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+          {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+          {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+          {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+          {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+          {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+          {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+          {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+          {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+          {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+          {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+          {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+          {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+          {'call': 'perf_event_open', 'reason': set([('file', 'f_mode')])},
+          {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+          {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+          {'call': 'open', 'reason': set([('file', 'f_mode')])},
+          {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+          {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+          {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+          {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+          {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+          {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+          {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])}],
+ 'alarm': [{'call': 'waitid',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'settimeofday',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'adjtimex',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'getitimer',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'select',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'wait4',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'getrusage',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'setitimer',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'clock_adjtime',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'alarm',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'ppoll',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])}],
+ 'bind': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+          {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+          {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+          {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+          {'call': 'readahead', 'reason': set([('fd', 'file')])},
+          {'call': 'getdents', 'reason': set([('fd', 'file')])},
+          {'call': 'writev', 'reason': set([('fd', 'file')])},
+          {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+          {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+          {'call': 'pread64', 'reason': set([('fd', 'file')])},
+          {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+          {'call': 'read', 'reason': set([('fd', 'file')])},
+          {'call': 'fchown', 'reason': set([('fd', 'file')])},
+          {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+          {'call': 'utime', 'reason': set([('fd', 'file')])},
+          {'call': 'fsync', 'reason': set([('fd', 'file')])},
+          {'call': 'bpf', 'reason': set([('fd', 'file')])},
+          {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+          {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+          {'call': 'sendto', 'reason': set([('fd', 'file')])},
+          {'call': 'tee', 'reason': set([('fd', 'file')])},
+          {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+          {'call': 'lseek', 'reason': set([('fd', 'file')])},
+          {'call': 'connect', 'reason': set([('fd', 'file')])},
+          {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+          {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+          {'call': 'flock', 'reason': set([('fd', 'file')])},
+          {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+          {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+          {'call': 'accept4', 'reason': set([('fd', 'file')])},
+          {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+          {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+          {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+          {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+          {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+          {'call': 'splice', 'reason': set([('fd', 'file')])},
+          {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+          {'call': 'preadv', 'reason': set([('fd', 'file')])},
+          {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+          {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+          {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+          {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+          {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+          {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+          {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+          {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+          {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+          {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+          {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+          {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+          {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+          {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+          {'call': 'listen', 'reason': set([('fd', 'file')])},
+          {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+          {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+          {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+          {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+          {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+          {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+          {'call': 'llseek', 'reason': set([('fd', 'file')])},
+          {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+          {'call': 'readv', 'reason': set([('fd', 'file')])},
+          {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+          {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+          {'call': 'write', 'reason': set([('fd', 'file')])},
+          {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+          {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+          {'call': 'bind', 'reason': set([('fd', 'file')])},
+          {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+          {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'bpf': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+         {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'rt_sigtimedwait',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+         {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'eventfd2',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+         {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'swapoff',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+         {'call': 'readahead', 'reason': set([('fd', 'file')])},
+         {'call': 'getdents', 'reason': set([('fd', 'file')])},
+         {'call': 'sched_getaffinity',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'writev', 'reason': set([('fd', 'file')])},
+         {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+         {'call': 'sched_setparam', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+         {'call': 'pread64', 'reason': set([('fd', 'file')])},
+         {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+         {'call': 'memfd_create',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'remap_file_pages',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'dup3',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'read', 'reason': set([('fd', 'file')])},
+         {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'fchown', 'reason': set([('fd', 'file')])},
+         {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_timedreceive',
+          'reason': set([('fd', 'file'), ('mm_segment_t', 'seg')])},
+         {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'utime', 'reason': set([('fd', 'file')])},
+         {'call': 'sched_setaffinity',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'fsync', 'reason': set([('fd', 'file')])},
+         {'call': 'bpf',
+          'reason': set([('bpf_attr', 'bpf_fd'),
+                         ('bpf_attr', 'flags'),
+                         ('bpf_attr', 'insn_cnt'),
+                         ('bpf_attr', 'kern_version'),
+                         ('bpf_attr', 'prog_flags'),
+                         ('bpf_map', 'key_size'),
+                         ('bpf_map', 'map_type'),
+                         ('bpf_prog', 'aux'),
+                         ('fd', 'file')])},
+         {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'semtimedop', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+         {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+         {'call': 'sendto', 'reason': set([('fd', 'file')])},
+         {'call': 'sched_rr_get_interval',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'epoll_create1',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'tee', 'reason': set([('fd', 'file')])},
+         {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+         {'call': 'lseek', 'reason': set([('fd', 'file')])},
+         {'call': 'connect', 'reason': set([('fd', 'file')])},
+         {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+         {'call': 'epoll_ctl',
+          'reason': set([('fd', 'file'),
+                         ('file', 'f_op'),
+                         ('file', 'private_data')])},
+         {'call': 'flock',
+          'reason': set([('fd', 'file'),
+                         ('file', 'f_op'),
+                         ('file', 'private_data')])},
+         {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+         {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+         {'call': 'openat',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'uselib',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'rt_sigprocmask', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'accept4',
+          'reason': set([('fd', 'file'),
+                         ('file', 'f_op'),
+                         ('file', 'private_data')])},
+         {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setattr', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+         {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+         {'call': 'socketpair',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+         {'call': 'migrate_pages', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+         {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+         {'call': 'splice', 'reason': set([('fd', 'file')])},
+         {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+         {'call': 'preadv', 'reason': set([('fd', 'file')])},
+         {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+         {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'shmat',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+         {'call': 'socket',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'pipe2',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+         {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+         {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+         {'call': 'perf_event_open',
+          'reason': set([('bpf_prog', 'aux'),
+                         ('fd', 'file'),
+                         ('file', 'f_op'),
+                         ('file', 'private_data'),
+                         ('mm_segment_t', 'seg')])},
+         {'call': 'shmdt',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+         {'call': 'rt_sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+         {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+         {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+         {'call': 'acct',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'open',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+         {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+         {'call': 'dup',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+         {'call': 'setns',
+          'reason': set([('file', 'f_op'),
+                         ('file', 'private_data'),
+                         ('mm_segment_t', 'seg')])},
+         {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+         {'call': 'listen', 'reason': set([('fd', 'file')])},
+         {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'get_robust_list',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+         {'call': 'mq_timedsend',
+          'reason': set([('fd', 'file'), ('mm_segment_t', 'seg')])},
+         {'call': 'sched_getscheduler',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+         {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'shmctl',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+         {'call': 'swapon',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+         {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+         {'call': 'sched_getattr', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setscheduler',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'llseek', 'reason': set([('fd', 'file')])},
+         {'call': 'mmap_pgoff',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+         {'call': 'readv', 'reason': set([('fd', 'file')])},
+         {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+         {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+         {'call': 'write', 'reason': set([('fd', 'file')])},
+         {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+         {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+         {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_open',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'sched_getparam', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'open_by_handle_at',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'bind', 'reason': set([('fd', 'file')])},
+         {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+         {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'brk': [{'call': 'swapoff',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'remap_file_pages',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'io_getevents',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'migrate_pages',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'shmdt',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'brk',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'get_mempolicy',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'munlockall',
+          'reason': set([('mm_struct', 'def_flags'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'pkey_mprotect',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'madvise',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'getrusage',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'io_setup',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'mprotect',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'mremap',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'io_destroy',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'mbind',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'prctl',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'move_pages',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'modify_ldt',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'munlock',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'mincore',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'io_cancel',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'mlockall',
+          'reason': set([('mm_struct', 'def_flags'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])}],
+ 'capset': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'clock_adjtime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'clock_adj')])}],
+ 'clock_nanosleep': [{'call': 'rt_sigtimedwait',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_unlink',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'swapoff',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_getres',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'timer_delete',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'fchmod',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'memfd_create',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'readlinkat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'io_getevents',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fchown',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'utime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'settimeofday',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timer_create',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'clock_gettime',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timerfd_gettime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'pselect6',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'uselib',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fchmodat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timer_settime',
+                      'reason': set([('k_clock', 'nsleep'),
+                                     ('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'ftruncate',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timer_gettime',
+                      'reason': set([('k_clock', 'nsleep'),
+                                     ('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'ioctl',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'linkat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'stime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'futimesat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'poll',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_settime',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'select',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'unlink',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'nanosleep',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'faccessat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'swapon',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'epoll_wait',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fchownat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fstat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timerfd_settime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'sendfile',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'newfstat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_nanosleep',
+                      'reason': set([('k_clock', 'nsleep'),
+                                     ('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'unlinkat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_adjtime',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'futex',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'recvmmsg',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'sendfile64',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'ppoll',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])}],
+ 'clock_settime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'clock_set')])}],
+ 'connect': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+             {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+             {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+             {'call': 'readahead', 'reason': set([('fd', 'file')])},
+             {'call': 'getdents', 'reason': set([('fd', 'file')])},
+             {'call': 'writev', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+             {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+             {'call': 'pread64', 'reason': set([('fd', 'file')])},
+             {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+             {'call': 'read', 'reason': set([('fd', 'file')])},
+             {'call': 'fchown', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+             {'call': 'utime', 'reason': set([('fd', 'file')])},
+             {'call': 'fsync', 'reason': set([('fd', 'file')])},
+             {'call': 'bpf', 'reason': set([('fd', 'file')])},
+             {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+             {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendto', 'reason': set([('fd', 'file')])},
+             {'call': 'tee', 'reason': set([('fd', 'file')])},
+             {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'lseek', 'reason': set([('fd', 'file')])},
+             {'call': 'connect', 'reason': set([('fd', 'file')])},
+             {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+             {'call': 'flock', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+             {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+             {'call': 'accept4', 'reason': set([('fd', 'file')])},
+             {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+             {'call': 'splice', 'reason': set([('fd', 'file')])},
+             {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv', 'reason': set([('fd', 'file')])},
+             {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+             {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+             {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+             {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+             {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+             {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+             {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+             {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+             {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+             {'call': 'listen', 'reason': set([('fd', 'file')])},
+             {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+             {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+             {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+             {'call': 'llseek', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'readv', 'reason': set([('fd', 'file')])},
+             {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+             {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+             {'call': 'write', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+             {'call': 'bind', 'reason': set([('fd', 'file')])},
+             {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'copy_file_range': [{'call': 'syncfs',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'vmsplice',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwritev64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'readahead',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getdents',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'writev',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'preadv64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fchmod',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pread64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'signalfd4',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'read',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fchown',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'utime',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fsync',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'bpf',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'recvfrom',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fsetxattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sendto',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'tee',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sync_file_range',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'lseek',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'connect',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getsockname',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'epoll_ctl',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'flock',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwritev',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fchdir',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'accept4',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'old_readdir',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'utimensat',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'preadv2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'splice',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'ftruncate',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'preadv',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getpeername',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'setsockopt',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fcntl',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'ioctl',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwrite64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwritev64v2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'futimesat',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwritev2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'shutdown',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getsockopt',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fdatasync',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getdents64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'listen',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'copy_file_range',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fgetxattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fcntl64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fallocate',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'epoll_wait',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'llseek',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'preadv64v2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'readv',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fstatfs',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fstatfs64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'write',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sendfile',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'bind',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'flistxattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sendfile64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'delete_module': [{'call': 'delete_module',
+                    'reason': set([('module', 'exit'),
+                                   ('module', 'init'),
+                                   ('module', 'state')])},
+                   {'call': 'init_module',
+                    'reason': set([('module', 'exit'),
+                                   ('module', 'init'),
+                                   ('module', 'state')])},
+                   {'call': 'finit_module',
+                    'reason': set([('module', 'exit'),
+                                   ('module', 'init'),
+                                   ('module', 'state')])}],
+ 'dmi_modalias_show': [{'call': 'dmi_modalias_show',
+                        'reason': set([('mafield', 'field'),
+                                       ('mafield', 'prefix')])}],
+ 'dup3': [{'call': 'dup3',
+           'reason': set([('fdtable', 'max_fds'),
+                          ('files_struct', 'fdt'),
+                          ('files_struct', 'resize_in_progress')])},
+          {'call': 'unshare',
+           'reason': set([('fdtable', 'max_fds'),
+                          ('files_struct', 'fdt'),
+                          ('files_struct', 'resize_in_progress')])},
+          {'call': 'select', 'reason': set([('fdtable', 'max_fds')])},
+          {'call': 'dup2',
+           'reason': set([('fdtable', 'max_fds'),
+                          ('files_struct', 'fdt'),
+                          ('files_struct', 'resize_in_progress')])}],
+ 'epoll_create1': [{'call': 'keyctl',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setfsuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getresuid16', 'reason': set([('cred', 'user')])},
+                   {'call': 'getresgid', 'reason': set([('cred', 'user')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setgid', 'reason': set([('cred', 'user')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'capset', 'reason': set([('cred', 'user')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getresgid16', 'reason': set([('cred', 'user')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'setfsgid', 'reason': set([('cred', 'user')])},
+                   {'call': 'unshare', 'reason': set([('cred', 'user')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setreuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'epoll_create1',
+                    'reason': set([('cred', 'user'),
+                                   ('eventpoll', 'user'),
+                                   ('eventpoll', 'ws')])},
+                   {'call': 'getresuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'epoll_ctl',
+                    'reason': set([('eventpoll', 'user'),
+                                   ('eventpoll', 'ws')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setresgid', 'reason': set([('cred', 'user')])},
+                   {'call': 'setregid', 'reason': set([('cred', 'user')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getgroups16', 'reason': set([('cred', 'user')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getpriority',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'faccessat', 'reason': set([('cred', 'user')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'epoll_wait',
+                    'reason': set([('eventpoll', 'user'),
+                                   ('eventpoll', 'ws')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setresuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getgroups', 'reason': set([('cred', 'user')])},
+                   {'call': 'setpriority',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'cred')])}],
+ 'epoll_ctl': [{'call': 'syncfs',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'keyctl', 'reason': set([('list_head', 'next')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'vmsplice',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'msgrcv', 'reason': set([('list_head', 'next')])},
+               {'call': 'eventfd2',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'mq_unlink', 'reason': set([('list_head', 'next')])},
+               {'call': 'pwritev64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'kill', 'reason': set([('list_head', 'next')])},
+               {'call': 'swapoff',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fremovexattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readahead',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'getdents',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'timer_delete',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'writev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sched_setparam',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'fchmod',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'setgid', 'reason': set([('list_head', 'next')])},
+               {'call': 'pread64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pivot_root', 'reason': set([('list_head', 'next')])},
+               {'call': 'signalfd4',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'memfd_create',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'ioprio_set', 'reason': set([('list_head', 'next')])},
+               {'call': 'delete_module',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'dup3',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'readlinkat', 'reason': set([('list_head', 'next')])},
+               {'call': 'read',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'io_getevents',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'getppid', 'reason': set([('list_head', 'next')])},
+               {'call': 'fchown',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'capget', 'reason': set([('list_head', 'next')])},
+               {'call': 'utime',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'ustat', 'reason': set([('list_head', 'next')])},
+               {'call': 'fsync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'bpf',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'unshare', 'reason': set([('list_head', 'next')])},
+               {'call': 'signal', 'reason': set([('list_head', 'next')])},
+               {'call': 'setreuid', 'reason': set([('list_head', 'next')])},
+               {'call': 'semtimedop', 'reason': set([('list_head', 'next')])},
+               {'call': 'umount', 'reason': set([('list_head', 'next')])},
+               {'call': 'recvfrom',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'timer_create',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sendto',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mkdirat', 'reason': set([('list_head', 'next')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'epoll_create1',
+                'reason': set([('epitem', 'nwait'),
+                               ('epitem', 'ws'),
+                               ('epoll_event', 'events'),
+                               ('file', 'f_op'),
+                               ('list_head', 'next')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'tee',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'semctl', 'reason': set([('list_head', 'next')])},
+               {'call': 'sync_file_range',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'lseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'connect',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsockname',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('epitem', 'nwait'),
+                               ('epitem', 'ws'),
+                               ('epoll_event', 'events'),
+                               ('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_op'),
+                               ('list_head', 'next')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_op'),
+                               ('list_head', 'next')])},
+               {'call': 'pwritev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'openat',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'uselib',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'renameat2', 'reason': set([('list_head', 'next')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_op'),
+                               ('list_head', 'next')])},
+               {'call': 'msgctl', 'reason': set([('list_head', 'next')])},
+               {'call': 'reboot', 'reason': set([('list_head', 'next')])},
+               {'call': 'setsid', 'reason': set([('list_head', 'next')])},
+               {'call': 'set_trip_temp',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sigaltstack',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sched_setattr',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'old_readdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_rm_watch',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'socketpair',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'utimensat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'migrate_pages',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'getitimer', 'reason': set([('list_head', 'next')])},
+               {'call': 'fchmodat', 'reason': set([('list_head', 'next')])},
+               {'call': 'setpgid', 'reason': set([('list_head', 'next')])},
+               {'call': 'init_module',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'setresgid', 'reason': set([('list_head', 'next')])},
+               {'call': 'getcwd', 'reason': set([('list_head', 'next')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'get_trip_temp',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'preadv2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'timer_settime',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'setregid', 'reason': set([('list_head', 'next')])},
+               {'call': 'splice',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'ftruncate',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'timer_gettime',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'preadv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getpeername',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsid', 'reason': set([('list_head', 'next')])},
+               {'call': 'shmat',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'setsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mknodat', 'reason': set([('list_head', 'next')])},
+               {'call': 'socket',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'symlinkat', 'reason': set([('list_head', 'next')])},
+               {'call': 'pipe2',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fcntl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ioctl',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'prlimit64', 'reason': set([('list_head', 'next')])},
+               {'call': 'pwrite64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_op'),
+                               ('list_head', 'next')])},
+               {'call': 'linkat', 'reason': set([('list_head', 'next')])},
+               {'call': 'getgroups16',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'shmdt',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'pwritev64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'quotactl', 'reason': set([('list_head', 'next')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'futimesat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'request_key',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'getpgid', 'reason': set([('list_head', 'next')])},
+               {'call': 'brk', 'reason': set([('list_head', 'next')])},
+               {'call': 'pwritev2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shutdown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'acct',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'open',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'unlink', 'reason': set([('list_head', 'next')])},
+               {'call': 'getsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'exit_group', 'reason': set([('list_head', 'next')])},
+               {'call': 'getpriority',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sigaction', 'reason': set([('list_head', 'next')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'faccessat', 'reason': set([('list_head', 'next')])},
+               {'call': 'rmdir', 'reason': set([('list_head', 'next')])},
+               {'call': 'dup',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fdatasync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'setgroups16',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'setns',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'getdents64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'listen',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fork', 'reason': set([('list_head', 'next')])},
+               {'call': 'get_mempolicy',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'io_submit', 'reason': set([('list_head', 'next')])},
+               {'call': 'get_robust_list',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'copy_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'sched_yield',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'fgetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ptrace', 'reason': set([('list_head', 'next')])},
+               {'call': 'shmctl',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fcntl64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'munlockall', 'reason': set([('list_head', 'next')])},
+               {'call': 'swapon',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fallocate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pkey_mprotect',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'madvise', 'reason': set([('list_head', 'next')])},
+               {'call': 'epoll_wait',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'sched_getattr',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'fchownat', 'reason': set([('list_head', 'next')])},
+               {'call': 'getrusage', 'reason': set([('list_head', 'next')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'setresuid', 'reason': set([('list_head', 'next')])},
+               {'call': 'setitimer', 'reason': set([('list_head', 'next')])},
+               {'call': 'ioprio_get', 'reason': set([('list_head', 'next')])},
+               {'call': 'vfork', 'reason': set([('list_head', 'next')])},
+               {'call': 'setuid', 'reason': set([('list_head', 'next')])},
+               {'call': 'llseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'io_setup', 'reason': set([('list_head', 'next')])},
+               {'call': 'mprotect', 'reason': set([('list_head', 'next')])},
+               {'call': 'mmap_pgoff',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'mremap', 'reason': set([('list_head', 'next')])},
+               {'call': 'io_destroy', 'reason': set([('list_head', 'next')])},
+               {'call': 'mbind', 'reason': set([('list_head', 'next')])},
+               {'call': 'preadv64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'prctl', 'reason': set([('list_head', 'next')])},
+               {'call': 'move_pages', 'reason': set([('list_head', 'next')])},
+               {'call': 'timerfd_create',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'fstatfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'modify_ldt', 'reason': set([('list_head', 'next')])},
+               {'call': 'getgroups', 'reason': set([('list_head', 'next')])},
+               {'call': 'fstatfs64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'dup2', 'reason': set([('list_head', 'next')])},
+               {'call': 'get_curr_temp',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'msgsnd', 'reason': set([('list_head', 'next')])},
+               {'call': 'write',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'munlock', 'reason': set([('list_head', 'next')])},
+               {'call': 'setpriority',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'inotify_init1',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'mincore', 'reason': set([('list_head', 'next')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'sendfile',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'timer_getoverrun',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'kexec_load', 'reason': set([('list_head', 'next')])},
+               {'call': 'clone', 'reason': set([('list_head', 'next')])},
+               {'call': 'mq_open',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'setgroups', 'reason': set([('list_head', 'next')])},
+               {'call': 'unlinkat', 'reason': set([('list_head', 'next')])},
+               {'call': 'sched_getparam',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'io_cancel', 'reason': set([('list_head', 'next')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'bind',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'flistxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'finit_module',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sendfile64',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('list_head', 'next')])},
+               {'call': 'mlockall', 'reason': set([('list_head', 'next')])}],
+ 'epoll_wait': [{'call': 'syncfs',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vmsplice',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+                {'call': 'pwritev64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                {'call': 'fremovexattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'readahead',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getdents',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'writev',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchmod',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'pread64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'signalfd4',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_op')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                {'call': 'read',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchown',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('fd', 'file'),
+                                ('fd', 'flags'),
+                                ('mm_segment_t', 'seg')])},
+                {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'utime',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fsync',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'bpf',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'semtimedop',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'recvfrom',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fsetxattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sendto',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+                {'call': 'tee',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sync_file_range',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'lseek',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'connect',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getsockname',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'epoll_ctl',
+                 'reason': set([('fd', 'file'),
+                                ('fd', 'flags'),
+                                ('file', 'f_op')])},
+                {'call': 'flock',
+                 'reason': set([('fd', 'file'),
+                                ('fd', 'flags'),
+                                ('file', 'f_op')])},
+                {'call': 'pwritev',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fchdir',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'accept4',
+                 'reason': set([('fd', 'file'),
+                                ('fd', 'flags'),
+                                ('file', 'f_op')])},
+                {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'old_readdir',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+                {'call': 'utimensat',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'splice',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ftruncate',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getpeername',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                {'call': 'setsockopt',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                {'call': 'fcntl',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ioctl',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'prlimit64',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwrite64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('fd', 'file'),
+                                ('fd', 'flags'),
+                                ('file', 'f_op'),
+                                ('mm_segment_t', 'seg')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                {'call': 'pwritev64v2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'futimesat',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwritev2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'shutdown',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                {'call': 'open', 'reason': set([('file', 'f_op')])},
+                {'call': 'getsockopt',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_getsetattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                {'call': 'fdatasync',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'setns',
+                 'reason': set([('file', 'f_op'), ('mm_segment_t', 'seg')])},
+                {'call': 'getdents64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'listen',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'copy_file_range',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('fd', 'file'),
+                                ('fd', 'flags'),
+                                ('mm_segment_t', 'seg')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fgetxattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                {'call': 'fcntl64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                {'call': 'fallocate',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'epoll_wait',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'llseek',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+                {'call': 'preadv64v2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'readv',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fstatfs',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fstatfs64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'write',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'setpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_notify',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sendfile',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_op')])},
+                {'call': 'bind',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'flistxattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sendfile64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'faccessat': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'eventfd2', 'reason': set([('path', 'mnt')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'swapoff', 'reason': set([('path', 'mnt')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'pivot_root', 'reason': set([('path', 'mnt')])},
+               {'call': 'memfd_create', 'reason': set([('path', 'mnt')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'remap_file_pages', 'reason': set([('path', 'mnt')])},
+               {'call': 'dup3', 'reason': set([('path', 'mnt')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'unshare', 'reason': set([('path', 'mnt')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setreuid', 'reason': set([('cred', 'uid')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'epoll_create1', 'reason': set([('path', 'mnt')])},
+               {'call': 'epoll_ctl', 'reason': set([('path', 'mnt')])},
+               {'call': 'flock', 'reason': set([('path', 'mnt')])},
+               {'call': 'openat', 'reason': set([('path', 'mnt')])},
+               {'call': 'lookup_dcookie', 'reason': set([('path', 'mnt')])},
+               {'call': 'uselib', 'reason': set([('path', 'mnt')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'accept4', 'reason': set([('path', 'mnt')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'socketpair', 'reason': set([('path', 'mnt')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getcwd', 'reason': set([('path', 'mnt')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'shmat', 'reason': set([('path', 'mnt')])},
+               {'call': 'socket', 'reason': set([('path', 'mnt')])},
+               {'call': 'pipe2', 'reason': set([('path', 'mnt')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'mnt'), ('task_struct', 'cred')])},
+               {'call': 'shmdt', 'reason': set([('path', 'mnt')])},
+               {'call': 'quotactl', 'reason': set([('path', 'mnt')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'acct', 'reason': set([('path', 'mnt')])},
+               {'call': 'open', 'reason': set([('path', 'mnt')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'dup', 'reason': set([('path', 'mnt')])},
+               {'call': 'setns',
+                'reason': set([('path', 'mnt'), ('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'shmctl', 'reason': set([('path', 'mnt')])},
+               {'call': 'swapon', 'reason': set([('path', 'mnt')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresuid', 'reason': set([('cred', 'uid')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setuid', 'reason': set([('cred', 'uid')])},
+               {'call': 'mmap_pgoff', 'reason': set([('path', 'mnt')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_open', 'reason': set([('path', 'mnt')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'mnt')])}],
+ 'fallocate': [{'call': 'syncfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'vmsplice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fremovexattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readahead',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getdents',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'writev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchmod',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pread64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'signalfd4',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'read',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'utime',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'bpf',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'recvfrom',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendto',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'tee',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sync_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'lseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'connect',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsockname',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'old_readdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_rm_watch',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'utimensat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'splice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ftruncate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getpeername',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'setsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fcntl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ioctl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwrite64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'futimesat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shutdown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fdatasync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getdents64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'listen',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'copy_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fgetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fcntl64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fallocate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_wait',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'llseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'write',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendfile',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'bind',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'flistxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendfile64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'fchdir': [{'call': 'syncfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'vmsplice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+            {'call': 'pwritev64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+            {'call': 'fremovexattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readahead',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getdents',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'writev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchmod',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pread64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+            {'call': 'signalfd4',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+            {'call': 'remap_file_pages', 'reason': set([('path', 'dentry')])},
+            {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+            {'call': 'read',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'utime',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+            {'call': 'recvfrom',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendto',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+            {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sync_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'lseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'connect',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getsockname',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry')])},
+            {'call': 'pwritev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'openat', 'reason': set([('path', 'dentry')])},
+            {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+            {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry')])},
+            {'call': 'old_readdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'inotify_rm_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+            {'call': 'utimensat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'splice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ftruncate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getpeername',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+            {'call': 'setsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'socket', 'reason': set([('path', 'dentry')])},
+            {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+            {'call': 'fcntl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ioctl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwrite64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry')])},
+            {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+            {'call': 'pwritev64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+            {'call': 'futimesat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shutdown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'acct', 'reason': set([('path', 'dentry')])},
+            {'call': 'open', 'reason': set([('path', 'dentry')])},
+            {'call': 'getsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'dup', 'reason': set([('path', 'dentry')])},
+            {'call': 'fdatasync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'setns', 'reason': set([('path', 'dentry')])},
+            {'call': 'getdents64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'listen',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'copy_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fgetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+            {'call': 'fcntl64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+            {'call': 'fallocate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_wait',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'llseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+            {'call': 'preadv64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'write',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_notify',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry')])},
+            {'call': 'bind',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'flistxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'fchmod': [{'call': 'syncfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'vmsplice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'eventfd2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pwritev64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'swapoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fremovexattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readahead',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getdents',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'writev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchmod',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pread64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pivot_root',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'signalfd4',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'memfd_create',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'dup3',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'read',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'utime',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'unshare',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'recvfrom',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendto',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_create1',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sync_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'lseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'connect',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getsockname',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'pwritev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'openat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'lookup_dcookie',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'uselib',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'old_readdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'inotify_rm_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'socketpair',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'utimensat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getcwd',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'splice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ftruncate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getpeername',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shmat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'socket',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pipe2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fcntl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ioctl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwrite64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'shmdt',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pwritev64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'quotactl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'futimesat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shutdown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'acct',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'dup',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fdatasync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'setns',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getdents64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'listen',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'copy_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fgetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shmctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fcntl64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'swapon',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fallocate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_wait',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'llseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'preadv64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'write',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_notify',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'bind',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'flistxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'fchmodat': [{'call': 'eventfd2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pivot_root',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'memfd_create',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup3',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'unshare',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_create1',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'flock',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'openat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'lookup_dcookie',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'uselib',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'accept4',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socketpair',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'getcwd',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socket',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pipe2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmdt',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'quotactl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'acct',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'setns',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapon',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mmap_pgoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mq_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'fchown': [{'call': 'syncfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'vmsplice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+            {'call': 'pwritev64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+            {'call': 'fremovexattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readahead',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getdents',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'writev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchmod',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pread64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+            {'call': 'signalfd4',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+            {'call': 'remap_file_pages', 'reason': set([('path', 'dentry')])},
+            {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+            {'call': 'read',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'utime',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+            {'call': 'recvfrom',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendto',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+            {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sync_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'lseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'connect',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getsockname',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry')])},
+            {'call': 'pwritev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'openat', 'reason': set([('path', 'dentry')])},
+            {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+            {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry')])},
+            {'call': 'old_readdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'inotify_rm_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+            {'call': 'utimensat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'splice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ftruncate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getpeername',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+            {'call': 'setsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'socket', 'reason': set([('path', 'dentry')])},
+            {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+            {'call': 'fcntl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ioctl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwrite64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('path', 'dentry')])},
+            {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+            {'call': 'pwritev64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+            {'call': 'futimesat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shutdown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'acct', 'reason': set([('path', 'dentry')])},
+            {'call': 'open', 'reason': set([('path', 'dentry')])},
+            {'call': 'getsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'dup', 'reason': set([('path', 'dentry')])},
+            {'call': 'fdatasync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'setns', 'reason': set([('path', 'dentry')])},
+            {'call': 'getdents64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'listen',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'copy_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fgetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+            {'call': 'fcntl64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+            {'call': 'fallocate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_wait',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'llseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+            {'call': 'preadv64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'write',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_notify',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry')])},
+            {'call': 'bind',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'flistxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'fchownat': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+              {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+              {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+              {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry')])},
+              {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+              {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+              {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+              {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+              {'call': 'flock', 'reason': set([('path', 'dentry')])},
+              {'call': 'openat', 'reason': set([('path', 'dentry')])},
+              {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+              {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+              {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+              {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+              {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+              {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+              {'call': 'socket', 'reason': set([('path', 'dentry')])},
+              {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry')])},
+              {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+              {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+              {'call': 'acct', 'reason': set([('path', 'dentry')])},
+              {'call': 'open', 'reason': set([('path', 'dentry')])},
+              {'call': 'dup', 'reason': set([('path', 'dentry')])},
+              {'call': 'setns', 'reason': set([('path', 'dentry')])},
+              {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+              {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+              {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+              {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry')])}],
+ 'fcntl': [{'call': 'syncfs',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'vmsplice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fremovexattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readahead',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getdents',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'writev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchmod',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pread64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'signalfd4',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+           {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+           {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+           {'call': 'read', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'utime',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fsync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'recvfrom',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fsetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendto',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+           {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sync_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'lseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'connect',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getsockname',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('fd', 'file'),
+                           ('fd', 'flags'),
+                           ('file', 'f_mode')])},
+           {'call': 'flock',
+            'reason': set([('fd', 'file'),
+                           ('fd', 'flags'),
+                           ('file', 'f_mode')])},
+           {'call': 'pwritev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+           {'call': 'accept4',
+            'reason': set([('fd', 'file'),
+                           ('fd', 'flags'),
+                           ('file', 'f_mode')])},
+           {'call': 'old_readdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_rm_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+           {'call': 'utimensat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'splice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ftruncate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getpeername',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'setsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ioctl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwrite64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'perf_event_open',
+            'reason': set([('fd', 'file'),
+                           ('fd', 'flags'),
+                           ('file', 'f_mode')])},
+           {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'futimesat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'shutdown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fdatasync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getdents64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'listen',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'copy_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fgetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fallocate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_wait',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'llseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'preadv64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'write',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_notify',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])},
+           {'call': 'bind', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'flistxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'fcntl64': [{'call': 'syncfs',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'vmsplice',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fremovexattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'readahead',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'getdents',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'writev',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'preadv64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fchmod',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'pread64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'signalfd4',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'read',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fchown',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'utime',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fsync',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'bpf',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'recvfrom',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fsetxattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'sendto',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'tee',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'sync_file_range',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'lseek',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'connect',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'getsockname',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'epoll_ctl',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('file', 'f_mode')])},
+             {'call': 'flock',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('file', 'f_mode')])},
+             {'call': 'pwritev',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fchdir',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('file', 'f_mode')])},
+             {'call': 'old_readdir',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'inotify_rm_watch',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'utimensat',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'inotify_add_watch',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'preadv2',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'splice',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'ftruncate',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'preadv',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'getpeername',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setsockopt',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('flock', 'l_len'),
+                             ('flock', 'l_start')])},
+             {'call': 'ioctl',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'pwrite64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'perf_event_open',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64v2',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'futimesat',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'pwritev2',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'shutdown',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getsockopt',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_getsetattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fdatasync',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getdents64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'listen',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'copy_file_range',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fgetxattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl64',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('flock', 'l_len'),
+                             ('flock', 'l_start')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fallocate',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'epoll_wait',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'llseek',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'preadv64v2',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'readv',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fstatfs',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fstatfs64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'write',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_notify',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'sendfile',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'bind',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'flistxattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'sendfile64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'fdatasync': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+               {'call': 'readahead', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents', 'reason': set([('fd', 'file')])},
+               {'call': 'writev', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+               {'call': 'pread64', 'reason': set([('fd', 'file')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+               {'call': 'read', 'reason': set([('fd', 'file')])},
+               {'call': 'fchown', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+               {'call': 'utime', 'reason': set([('fd', 'file')])},
+               {'call': 'fsync', 'reason': set([('fd', 'file')])},
+               {'call': 'bpf', 'reason': set([('fd', 'file')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'sendto', 'reason': set([('fd', 'file')])},
+               {'call': 'tee', 'reason': set([('fd', 'file')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'lseek', 'reason': set([('fd', 'file')])},
+               {'call': 'connect', 'reason': set([('fd', 'file')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+               {'call': 'flock', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+               {'call': 'accept4', 'reason': set([('fd', 'file')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+               {'call': 'splice', 'reason': set([('fd', 'file')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv', 'reason': set([('fd', 'file')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+               {'call': 'listen', 'reason': set([('fd', 'file')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+               {'call': 'llseek', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'readv', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+               {'call': 'write', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+               {'call': 'bind', 'reason': set([('fd', 'file')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'fgetxattr': [{'call': 'syncfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'vmsplice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fremovexattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readahead',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getdents',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'writev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchmod',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pread64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'signalfd4',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'read',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'utime',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'bpf',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'recvfrom',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendto',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'tee',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sync_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'lseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'connect',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsockname',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'old_readdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_rm_watch',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'utimensat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'splice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ftruncate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getpeername',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'setsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fcntl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ioctl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwrite64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'futimesat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shutdown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fdatasync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getdents64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'listen',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'copy_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fgetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fcntl64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fallocate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_wait',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'llseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'write',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendfile',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'bind',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'flistxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendfile64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'finit_module': [{'call': 'delete_module',
+                   'reason': set([('module', 'args'),
+                                  ('module', 'kp'),
+                                  ('module', 'num_kp'),
+                                  ('module_layout', 'base'),
+                                  ('module_layout', 'size')])},
+                  {'call': 'init_module',
+                   'reason': set([('load_info', 'debug'),
+                                  ('load_info', 'num_debug'),
+                                  ('module', 'args'),
+                                  ('module', 'kp'),
+                                  ('module', 'num_kp'),
+                                  ('module_layout', 'base'),
+                                  ('module_layout', 'size')])},
+                  {'call': 'finit_module',
+                   'reason': set([('load_info', 'debug'),
+                                  ('load_info', 'num_debug'),
+                                  ('module', 'args'),
+                                  ('module', 'kp'),
+                                  ('module', 'num_kp'),
+                                  ('module_layout', 'base'),
+                                  ('module_layout', 'size')])}],
+ 'flistxattr': [{'call': 'syncfs',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'vmsplice',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'pwritev64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fremovexattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'readahead',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getdents',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'writev',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fchmod',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'pread64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'signalfd4',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'read',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fchown',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'utime',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fsync',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'bpf',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'recvfrom',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fsetxattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sendto',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'tee',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sync_file_range',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'lseek',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'connect',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getsockname',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'epoll_ctl',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'flock',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'pwritev',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fchdir',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'accept4',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'old_readdir',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'utimensat',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'splice',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ftruncate',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getpeername',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'setsockopt',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fcntl',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ioctl',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'pwrite64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'pwritev64v2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'futimesat',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'pwritev2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'shutdown',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getsockopt',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'mq_getsetattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fdatasync',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getdents64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'listen',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'copy_file_range',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fgetxattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fcntl64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fallocate',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'epoll_wait',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'llseek',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv64v2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'readv',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fstatfs',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fstatfs64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'write',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'mq_notify',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sendfile',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'bind',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'flistxattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sendfile64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'flock': [{'call': 'syncfs',
+            'reason': set([('fd', 'file'),
+                           ('fd', 'flags'),
+                           ('super_block', 's_flags')])},
+           {'call': 'vmsplice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fremovexattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readahead',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getdents',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'writev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchmod',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pread64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'signalfd4',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+           {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+           {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+           {'call': 'read', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'utime',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+           {'call': 'fsync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'umount', 'reason': set([('super_block', 's_flags')])},
+           {'call': 'recvfrom',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fsetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendto',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+           {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sync_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'lseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'connect',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getsockname',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('fd', 'file'),
+                           ('fd', 'flags'),
+                           ('file', 'f_mode')])},
+           {'call': 'flock',
+            'reason': set([('fd', 'file'),
+                           ('fd', 'flags'),
+                           ('file', 'f_mode')])},
+           {'call': 'pwritev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+           {'call': 'accept4',
+            'reason': set([('fd', 'file'),
+                           ('fd', 'flags'),
+                           ('file', 'f_mode')])},
+           {'call': 'old_readdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_rm_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+           {'call': 'utimensat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'splice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ftruncate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getpeername',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'setsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ioctl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwrite64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'perf_event_open',
+            'reason': set([('fd', 'file'),
+                           ('fd', 'flags'),
+                           ('file', 'f_mode')])},
+           {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'quotactl', 'reason': set([('super_block', 's_flags')])},
+           {'call': 'futimesat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'shutdown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fdatasync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getdents64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'listen',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'copy_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fgetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'swapon',
+            'reason': set([('file', 'f_mode'), ('super_block', 's_flags')])},
+           {'call': 'fallocate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_wait',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'llseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'preadv64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'write',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_notify',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])},
+           {'call': 'bind', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'flistxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'fremovexattr': [{'call': 'syncfs',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'vmsplice',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'pwritev64',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fremovexattr',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'readahead',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'getdents',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'writev',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'preadv64',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fchmod',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'pread64',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'signalfd4',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'read',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fchown',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'utime',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fsync',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'bpf',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'recvfrom',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fsetxattr',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'sendto',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'tee',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'sync_file_range',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'lseek',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'connect',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'getsockname',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'epoll_ctl',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'flock',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'pwritev',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fchdir',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'accept4',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'old_readdir',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'inotify_rm_watch',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'utimensat',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'inotify_add_watch',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'preadv2',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'splice',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'ftruncate',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'preadv',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'getpeername',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'setsockopt',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fcntl',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'ioctl',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'pwrite64',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'pwritev64v2',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'futimesat',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'pwritev2',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'shutdown',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'getsockopt',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'mq_getsetattr',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fdatasync',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'getdents64',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'listen',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'copy_file_range',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fgetxattr',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fcntl64',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fallocate',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'epoll_wait',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'llseek',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'preadv64v2',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'readv',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fstatfs',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'fstatfs64',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'write',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'mq_notify',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'sendfile',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'bind',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'flistxattr',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                  {'call': 'sendfile64',
+                   'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'fsetxattr': [{'call': 'syncfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'vmsplice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fremovexattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readahead',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getdents',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'writev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchmod',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pread64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'signalfd4',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'read',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'utime',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'bpf',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'recvfrom',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendto',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'tee',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sync_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'lseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'connect',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsockname',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'old_readdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_rm_watch',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'utimensat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'splice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ftruncate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getpeername',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'setsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fcntl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ioctl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwrite64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'futimesat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shutdown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fdatasync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getdents64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'listen',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'copy_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fgetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fcntl64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fallocate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_wait',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'llseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'write',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendfile',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'bind',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'flistxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendfile64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'fstat': [{'call': 'lstat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])},
+           {'call': 'stat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])},
+           {'call': 'fstat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink'),
+                           ('kstat', 'dev'),
+                           ('kstat', 'ino'),
+                           ('kstat', 'nlink'),
+                           ('kstat', 'rdev')])},
+           {'call': 'newfstat',
+            'reason': set([('kstat', 'dev'),
+                           ('kstat', 'ino'),
+                           ('kstat', 'nlink'),
+                           ('kstat', 'rdev')])}],
+ 'fstatfs': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+             {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+             {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+             {'call': 'readahead', 'reason': set([('fd', 'file')])},
+             {'call': 'getdents', 'reason': set([('fd', 'file')])},
+             {'call': 'writev', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+             {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+             {'call': 'pread64', 'reason': set([('fd', 'file')])},
+             {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+             {'call': 'read', 'reason': set([('fd', 'file')])},
+             {'call': 'fchown', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+             {'call': 'utime', 'reason': set([('fd', 'file')])},
+             {'call': 'ustat',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'fsync', 'reason': set([('fd', 'file')])},
+             {'call': 'bpf', 'reason': set([('fd', 'file')])},
+             {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+             {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendto', 'reason': set([('fd', 'file')])},
+             {'call': 'tee', 'reason': set([('fd', 'file')])},
+             {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'lseek', 'reason': set([('fd', 'file')])},
+             {'call': 'connect', 'reason': set([('fd', 'file')])},
+             {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+             {'call': 'flock', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+             {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+             {'call': 'accept4', 'reason': set([('fd', 'file')])},
+             {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+             {'call': 'splice', 'reason': set([('fd', 'file')])},
+             {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv', 'reason': set([('fd', 'file')])},
+             {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+             {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+             {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+             {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+             {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+             {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+             {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+             {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+             {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+             {'call': 'listen', 'reason': set([('fd', 'file')])},
+             {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+             {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+             {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+             {'call': 'llseek', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'readv', 'reason': set([('fd', 'file')])},
+             {'call': 'fstatfs',
+              'reason': set([('fd', 'file'),
+                             ('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'statfs',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'fstatfs64',
+              'reason': set([('fd', 'file'),
+                             ('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'write', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+             {'call': 'statfs64',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'bind', 'reason': set([('fd', 'file')])},
+             {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'fstatfs64': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+               {'call': 'readahead', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents', 'reason': set([('fd', 'file')])},
+               {'call': 'writev', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+               {'call': 'pread64', 'reason': set([('fd', 'file')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+               {'call': 'read', 'reason': set([('fd', 'file')])},
+               {'call': 'fchown', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+               {'call': 'utime', 'reason': set([('fd', 'file')])},
+               {'call': 'ustat',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'fsync', 'reason': set([('fd', 'file')])},
+               {'call': 'bpf', 'reason': set([('fd', 'file')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'sendto', 'reason': set([('fd', 'file')])},
+               {'call': 'tee', 'reason': set([('fd', 'file')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'lseek', 'reason': set([('fd', 'file')])},
+               {'call': 'connect', 'reason': set([('fd', 'file')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+               {'call': 'flock', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+               {'call': 'accept4', 'reason': set([('fd', 'file')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+               {'call': 'splice', 'reason': set([('fd', 'file')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv', 'reason': set([('fd', 'file')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+               {'call': 'listen', 'reason': set([('fd', 'file')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+               {'call': 'llseek', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'readv', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs',
+                'reason': set([('fd', 'file'),
+                               ('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'statfs',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'fstatfs64',
+                'reason': set([('fd', 'file'),
+                               ('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'write', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+               {'call': 'statfs64',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'bind', 'reason': set([('fd', 'file')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'fsync': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+           {'call': 'readahead', 'reason': set([('fd', 'file')])},
+           {'call': 'getdents', 'reason': set([('fd', 'file')])},
+           {'call': 'writev', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+           {'call': 'pread64', 'reason': set([('fd', 'file')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+           {'call': 'read', 'reason': set([('fd', 'file')])},
+           {'call': 'fchown', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+           {'call': 'utime', 'reason': set([('fd', 'file')])},
+           {'call': 'fsync', 'reason': set([('fd', 'file')])},
+           {'call': 'bpf', 'reason': set([('fd', 'file')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+           {'call': 'sendto', 'reason': set([('fd', 'file')])},
+           {'call': 'tee', 'reason': set([('fd', 'file')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+           {'call': 'lseek', 'reason': set([('fd', 'file')])},
+           {'call': 'connect', 'reason': set([('fd', 'file')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+           {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+           {'call': 'flock', 'reason': set([('fd', 'file')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+           {'call': 'accept4', 'reason': set([('fd', 'file')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+           {'call': 'splice', 'reason': set([('fd', 'file')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv', 'reason': set([('fd', 'file')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+           {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+           {'call': 'listen', 'reason': set([('fd', 'file')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+           {'call': 'llseek', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+           {'call': 'readv', 'reason': set([('fd', 'file')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+           {'call': 'write', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+           {'call': 'bind', 'reason': set([('fd', 'file')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'ftruncate': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+               {'call': 'eventfd2',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'mq_unlink',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapoff',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+               {'call': 'readahead', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents', 'reason': set([('fd', 'file')])},
+               {'call': 'writev', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+               {'call': 'fchmod',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'pread64', 'reason': set([('fd', 'file')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+               {'call': 'memfd_create',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'dup3',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'readlinkat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'read', 'reason': set([('fd', 'file')])},
+               {'call': 'fchown',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'utime', 'reason': set([('fd', 'file')])},
+               {'call': 'fsync', 'reason': set([('fd', 'file')])},
+               {'call': 'bpf', 'reason': set([('fd', 'file')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'sendto', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_create1',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'tee', 'reason': set([('fd', 'file')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'lseek', 'reason': set([('fd', 'file')])},
+               {'call': 'connect', 'reason': set([('fd', 'file')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'file'),
+                               ('file', 'f_flags'),
+                               ('file', 'f_mode')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'file'),
+                               ('file', 'f_flags'),
+                               ('file', 'f_mode')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+               {'call': 'openat',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'uselib',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'file'),
+                               ('file', 'f_flags'),
+                               ('file', 'f_mode')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'socketpair',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+               {'call': 'fchmodat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+               {'call': 'splice', 'reason': set([('fd', 'file')])},
+               {'call': 'ftruncate',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'preadv', 'reason': set([('fd', 'file')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+               {'call': 'shmat',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'socket',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'pipe2',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+               {'call': 'ioctl',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'file'),
+                               ('file', 'f_flags'),
+                               ('file', 'f_mode')])},
+               {'call': 'linkat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'shmdt',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+               {'call': 'acct',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'open',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'unlink',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'file'),
+                               ('file', 'f_flags'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'faccessat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'dup',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+               {'call': 'setns',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+               {'call': 'listen', 'reason': set([('fd', 'file')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'shmctl',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapon',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+               {'call': 'fchownat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'llseek', 'reason': set([('fd', 'file')])},
+               {'call': 'mmap_pgoff',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'readv', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+               {'call': 'write', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'sendfile',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'mq_open',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'unlinkat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'bind', 'reason': set([('fd', 'file')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'sendfile64',
+                'reason': set([('fd', 'file'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])}],
+ 'futex': [{'call': 'rt_sigtimedwait',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'swapoff',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchmod',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'memfd_create',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'readlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'io_getevents',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchown',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'utime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'semtimedop',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'settimeofday',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'pselect6',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'uselib',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchmodat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ftruncate',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ioctl',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'linkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'stime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'futimesat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'poll',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'select',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'nanosleep',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'faccessat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'swapon',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'epoll_wait',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchownat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fstat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_notify',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'newfstat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'clock_nanosleep',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'unlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'futex',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'recvmmsg',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile64',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ppoll',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])}],
+ 'futimesat': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_unlink',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+               {'call': 'readahead', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents', 'reason': set([('fd', 'file')])},
+               {'call': 'writev', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+               {'call': 'fchmod',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'pread64', 'reason': set([('fd', 'file')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+               {'call': 'memfd_create',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'readlinkat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'read', 'reason': set([('fd', 'file')])},
+               {'call': 'io_getevents',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchown',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'waitid', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'utime',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'fsync', 'reason': set([('fd', 'file')])},
+               {'call': 'bpf', 'reason': set([('fd', 'file')])},
+               {'call': 'semtimedop',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'settimeofday',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'sendto', 'reason': set([('fd', 'file')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'adjtimex', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'tee', 'reason': set([('fd', 'file')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'lseek', 'reason': set([('fd', 'file')])},
+               {'call': 'connect', 'reason': set([('fd', 'file')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+               {'call': 'flock', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+               {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'accept4', 'reason': set([('fd', 'file')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+               {'call': 'getitimer', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+               {'call': 'timer_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'splice', 'reason': set([('fd', 'file')])},
+               {'call': 'ftruncate',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'timer_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'preadv', 'reason': set([('fd', 'file')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+               {'call': 'ioctl',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+               {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'futimesat',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+               {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'select',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'faccessat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+               {'call': 'listen', 'reason': set([('fd', 'file')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+               {'call': 'wait4', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'epoll_wait',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'getrusage', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'fstat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'setitimer', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'llseek', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'readv', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+               {'call': 'write', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'sendfile',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'newfstat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'clock_nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'clock_adjtime',
+                'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'bind', 'reason': set([('fd', 'file')])},
+               {'call': 'alarm', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile64',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'ppoll',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timeval', 'tv_usec')])}],
+ 'get_mempolicy': [{'call': 'keyctl',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'kill',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'remap_file_pages',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'set_mempolicy',
+                    'reason': set([('mempolicy', 'mode'),
+                                   ('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'shmdt',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'brk',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'getpriority',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'fork',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'get_mempolicy',
+                    'reason': set([('mempolicy', 'mode'),
+                                   ('vm_area_struct', 'vm_ops')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'munlockall',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'pkey_mprotect',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'madvise',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mprotect',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'mremap',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'mbind', 'reason': set([('mempolicy', 'mode')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy'),
+                                   ('vm_area_struct', 'vm_ops')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'munlock',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'setpriority',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mincore',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mlockall',
+                    'reason': set([('vm_area_struct', 'vm_ops')])}],
+ 'getcwd': [{'call': 'eventfd2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_unlink',
+             'reason': set([('dentry', 'd_parent'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'swapoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pivot_root',
+             'reason': set([('dentry', 'd_parent'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'memfd_create',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'dup3',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'unshare',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'umount', 'reason': set([('vfsmount', 'mnt_root')])},
+            {'call': 'mkdirat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'epoll_create1',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'flock',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'openat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'lookup_dcookie',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'uselib',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'renameat2', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'accept4',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'socketpair',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getcwd',
+             'reason': set([('dentry', 'd_parent'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'ftruncate', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'shmat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mknodat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'socket',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'symlinkat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'pipe2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'perf_event_open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'linkat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'shmdt',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'quotactl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'acct',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'unlink', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'rmdir', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'dup',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setns',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'shmctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'swapon',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_open',
+             'reason': set([('dentry', 'd_parent'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'unlinkat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'getdents': [{'call': 'syncfs',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'vmsplice',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'pwritev64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fremovexattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'readahead',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getdents',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'writev',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sched_setparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchmod',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'pread64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'signalfd4',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'ioprio_set',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'read',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchown',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('mm_segment_t', 'seg')])},
+              {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'utime',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fsync',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'bpf',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'semtimedop',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'recvfrom',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fsetxattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sendto',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'tee',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sync_file_range',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'lseek',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'connect',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getsockname',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'pwritev',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fchdir',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaltstack',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'old_readdir',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'inotify_rm_watch',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'utimensat',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'inotify_add_watch',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'splice',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'ftruncate',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getpeername',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setsockopt',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fcntl',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'ioctl',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'pwrite64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('mm_segment_t', 'seg')])},
+              {'call': 'pwritev64v2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'futimesat',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'pwritev2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'shutdown',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getsockopt',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fdatasync',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getdents64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'listen',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'get_robust_list',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'copy_file_range',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('mm_segment_t', 'seg')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fgetxattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fcntl64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fallocate',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'epoll_wait',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sched_getattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ioprio_get',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'llseek',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv64v2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'readv',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fstatfs',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fstatfs64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'write',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'setpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_notify',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sendfile',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_getparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'bind',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'flistxattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sendfile64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'getdents64': [{'call': 'syncfs',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vmsplice',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwritev64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fremovexattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'readahead',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getdents',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'writev',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchmod',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'pread64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'signalfd4',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'read',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchown',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('fd', 'file'),
+                                ('fd', 'flags'),
+                                ('mm_segment_t', 'seg')])},
+                {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'utime',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fsync',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'bpf',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'semtimedop',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'recvfrom',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fsetxattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sendto',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'tee',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sync_file_range',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'lseek',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'connect',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getsockname',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'epoll_ctl',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'flock',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'pwritev',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fchdir',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'accept4',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'old_readdir',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'utimensat',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'splice',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ftruncate',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getpeername',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setsockopt',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fcntl',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ioctl',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'prlimit64',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwrite64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('fd', 'file'),
+                                ('fd', 'flags'),
+                                ('mm_segment_t', 'seg')])},
+                {'call': 'pwritev64v2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'futimesat',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwritev2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'shutdown',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getsockopt',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'getpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_getsetattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fdatasync',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getdents64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'listen',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'copy_file_range',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('fd', 'file'),
+                                ('fd', 'flags'),
+                                ('mm_segment_t', 'seg')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fgetxattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fcntl64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fallocate',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'epoll_wait',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'llseek',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'preadv64v2',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'readv',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fstatfs',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'fstatfs64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'write',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'setpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_notify',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sendfile',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'bind',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'flistxattr',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                {'call': 'sendfile64',
+                 'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'getegid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sigaltstack',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getpriority',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setpriority',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'cred')])}],
+ 'getegid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'geteuid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sigaltstack',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getpriority',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setpriority',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'cred')])}],
+ 'geteuid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'getgid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'getgid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'getgroups': [{'call': 'keyctl',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setfsuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresuid16',
+                'reason': set([('cred', 'group_info')])},
+               {'call': 'getresgid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setgid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'ioprio_set',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'capset', 'reason': set([('cred', 'group_info')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresgid16',
+                'reason': set([('cred', 'group_info')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'setfsgid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'unshare', 'reason': set([('cred', 'group_info')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setreuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'epoll_create1',
+                'reason': set([('cred', 'group_info')])},
+               {'call': 'getresuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresgid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'setregid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups16',
+                'reason': set([('cred', 'group_info')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'faccessat', 'reason': set([('cred', 'group_info')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups', 'reason': set([('cred', 'group_info')])},
+               {'call': 'setpriority',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'getgroups16': [{'call': 'keyctl',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setfsuid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getresuid16',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'getresgid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setgid', 'reason': set([('cred', 'group_info')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'capset', 'reason': set([('cred', 'group_info')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getresgid16',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'setfsgid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'unshare', 'reason': set([('cred', 'group_info')])},
+                 {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setreuid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'epoll_create1',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'getresuid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setresgid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'setregid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getgroups16',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpriority',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'faccessat',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'setgroups16',
+                  'reason': set([('group_info', 'ngroups')])},
+                 {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setresuid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setuid', 'reason': set([('cred', 'group_info')])},
+                 {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getgroups',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'setpriority',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setgroups',
+                  'reason': set([('group_info', 'ngroups')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred')])}],
+ 'getitimer': [{'call': 'timer_create',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'exit_group',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'setitimer',
+                'reason': set([('signal_struct', 'it_real_incr')])}],
+ 'getpeername': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                 {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                 {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                 {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                 {'call': 'writev', 'reason': set([('fd', 'file')])},
+                 {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                 {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                 {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                 {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                 {'call': 'read', 'reason': set([('fd', 'file')])},
+                 {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+                 {'call': 'utime', 'reason': set([('fd', 'file')])},
+                 {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                 {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                 {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                 {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                 {'call': 'tee', 'reason': set([('fd', 'file')])},
+                 {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+                 {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                 {'call': 'connect', 'reason': set([('fd', 'file')])},
+                 {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                 {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+                 {'call': 'flock', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                 {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                 {'call': 'accept4', 'reason': set([('fd', 'file')])},
+                 {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                 {'call': 'inotify_rm_watch',
+                  'reason': set([('fd', 'file')])},
+                 {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                 {'call': 'inotify_add_watch',
+                  'reason': set([('fd', 'file')])},
+                 {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                 {'call': 'splice', 'reason': set([('fd', 'file')])},
+                 {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                 {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                 {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                 {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                 {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                 {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                 {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                 {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                 {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                 {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                 {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                 {'call': 'listen', 'reason': set([('fd', 'file')])},
+                 {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+                 {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                 {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                 {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                 {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                 {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                 {'call': 'readv', 'reason': set([('fd', 'file')])},
+                 {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                 {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                 {'call': 'write', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+                 {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                 {'call': 'bind', 'reason': set([('fd', 'file')])},
+                 {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'getppid': [{'call': 'keyctl',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'msgrcv',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'kill',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'ioprio_set',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getppid',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'capget',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'signal',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'semtimedop',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'umount',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setsid',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sigaltstack',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getitimer',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setpgid',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getsid',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'prlimit64',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getpgid',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getpriority',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sigaction',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setns',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'fork',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'ptrace',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getrusage',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setitimer',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'ioprio_get',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'vfork',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'prctl',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'move_pages',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setpriority',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'clone',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'real_parent')])}],
+ 'getpriority': [{'call': 'keyctl',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'msgrcv',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'kill',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'capget',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'signal',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setreuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'umount',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setsid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getsid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getpriority',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setns',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'fork',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ptrace',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setresuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'vfork',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'prctl',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setpriority',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'clone',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])}],
+ 'getresgid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'getresgid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpriority',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpriority',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred')])}],
+ 'getresuid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'getresuid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpriority',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpriority',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred')])}],
+ 'getrlimit': [{'call': 'setrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'old_getrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'prlimit64',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])}],
+ 'getrusage': [{'call': 'timer_create',
+                'reason': set([('signal_struct', 'maxrss')])},
+               {'call': 'exit_group',
+                'reason': set([('signal_struct', 'maxrss')])}],
+ 'getsockname': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                 {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                 {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                 {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                 {'call': 'writev', 'reason': set([('fd', 'file')])},
+                 {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                 {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                 {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                 {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                 {'call': 'read', 'reason': set([('fd', 'file')])},
+                 {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+                 {'call': 'utime', 'reason': set([('fd', 'file')])},
+                 {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                 {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                 {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                 {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                 {'call': 'tee', 'reason': set([('fd', 'file')])},
+                 {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+                 {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                 {'call': 'connect', 'reason': set([('fd', 'file')])},
+                 {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                 {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+                 {'call': 'flock', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                 {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                 {'call': 'accept4', 'reason': set([('fd', 'file')])},
+                 {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                 {'call': 'inotify_rm_watch',
+                  'reason': set([('fd', 'file')])},
+                 {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                 {'call': 'inotify_add_watch',
+                  'reason': set([('fd', 'file')])},
+                 {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                 {'call': 'splice', 'reason': set([('fd', 'file')])},
+                 {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                 {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                 {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                 {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                 {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                 {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                 {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                 {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                 {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                 {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                 {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                 {'call': 'listen', 'reason': set([('fd', 'file')])},
+                 {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+                 {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                 {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                 {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                 {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                 {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                 {'call': 'readv', 'reason': set([('fd', 'file')])},
+                 {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                 {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                 {'call': 'write', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+                 {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                 {'call': 'bind', 'reason': set([('fd', 'file')])},
+                 {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'getsockopt': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+                {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                {'call': 'writev', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                {'call': 'read', 'reason': set([('fd', 'file')])},
+                {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+                {'call': 'utime', 'reason': set([('fd', 'file')])},
+                {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                {'call': 'tee', 'reason': set([('fd', 'file')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+                {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                {'call': 'connect', 'reason': set([('fd', 'file')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+                {'call': 'flock', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                {'call': 'accept4',
+                 'reason': set([('fd', 'file'),
+                                ('proto_ops', 'compat_getsockopt')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'file')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                {'call': 'splice', 'reason': set([('fd', 'file')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                {'call': 'listen', 'reason': set([('fd', 'file')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                {'call': 'readv', 'reason': set([('fd', 'file')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                {'call': 'write', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                {'call': 'bind', 'reason': set([('fd', 'file')])},
+                {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'getuid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'getuid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'getxattr': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+              {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+              {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+              {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry')])},
+              {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+              {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+              {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+              {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+              {'call': 'flock', 'reason': set([('path', 'dentry')])},
+              {'call': 'openat', 'reason': set([('path', 'dentry')])},
+              {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+              {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+              {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+              {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+              {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+              {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+              {'call': 'socket', 'reason': set([('path', 'dentry')])},
+              {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry')])},
+              {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+              {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+              {'call': 'acct', 'reason': set([('path', 'dentry')])},
+              {'call': 'open', 'reason': set([('path', 'dentry')])},
+              {'call': 'dup', 'reason': set([('path', 'dentry')])},
+              {'call': 'setns', 'reason': set([('path', 'dentry')])},
+              {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+              {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+              {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+              {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry')])}],
+ 'init_module': [{'call': 'delete_module',
+                  'reason': set([('module', 'args'),
+                                 ('module', 'kp'),
+                                 ('module', 'num_kp'),
+                                 ('module_layout', 'base'),
+                                 ('module_layout', 'size')])},
+                 {'call': 'init_module',
+                  'reason': set([('load_info', 'debug'),
+                                 ('load_info', 'hdr'),
+                                 ('load_info', 'len'),
+                                 ('load_info', 'num_debug'),
+                                 ('module', 'args'),
+                                 ('module', 'kp'),
+                                 ('module', 'num_kp'),
+                                 ('module_layout', 'base'),
+                                 ('module_layout', 'size')])},
+                 {'call': 'finit_module',
+                  'reason': set([('load_info', 'debug'),
+                                 ('load_info', 'hdr'),
+                                 ('load_info', 'len'),
+                                 ('load_info', 'num_debug'),
+                                 ('module', 'args'),
+                                 ('module', 'kp'),
+                                 ('module', 'num_kp'),
+                                 ('module_layout', 'base'),
+                                 ('module_layout', 'size')])}],
+ 'inotify_add_watch': [{'call': 'syncfs',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'vmsplice',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'eventfd2',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'mq_unlink',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'pwritev64',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fremovexattr',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'readahead',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'getdents',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'writev',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'preadv64',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'fchmod',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'pread64',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'pivot_root',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'signalfd4',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'memfd_create',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'remap_file_pages',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                       {'call': 'read',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'fchown',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'mq_timedreceive',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'utime',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'fsync',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'bpf',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'recvfrom',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'fsetxattr',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'sendto',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'mkdirat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'epoll_create1',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'tee',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'sync_file_range',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'lseek',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'connect',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'getsockname',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'epoll_ctl',
+                        'reason': set([('fd', 'file'),
+                                       ('fd', 'flags'),
+                                       ('file', 'f_op')])},
+                       {'call': 'flock',
+                        'reason': set([('fd', 'file'),
+                                       ('fd', 'flags'),
+                                       ('file', 'f_op')])},
+                       {'call': 'pwritev',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'fchdir',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                       {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                       {'call': 'renameat2',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'accept4',
+                        'reason': set([('fd', 'file'),
+                                       ('fd', 'flags'),
+                                       ('file', 'f_op')])},
+                       {'call': 'old_readdir',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'inotify_rm_watch',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'socketpair',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'utimensat',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'getcwd',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'inotify_add_watch',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'preadv2',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'splice',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'ftruncate',
+                        'reason': set([('dentry', 'd_inode'),
+                                       ('fd', 'file'),
+                                       ('fd', 'flags')])},
+                       {'call': 'preadv',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'getpeername',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                       {'call': 'setsockopt',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'mknodat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                       {'call': 'symlinkat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fcntl',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'ioctl',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'pwrite64',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('fd', 'file'),
+                                       ('fd', 'flags'),
+                                       ('file', 'f_op')])},
+                       {'call': 'linkat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                       {'call': 'pwritev64v2',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'futimesat',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'pwritev2',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'shutdown',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                       {'call': 'open', 'reason': set([('file', 'f_op')])},
+                       {'call': 'unlink',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'getsockopt',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'mq_getsetattr',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'rmdir',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fdatasync',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'setns', 'reason': set([('file', 'f_op')])},
+                       {'call': 'getdents64',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'listen',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'copy_file_range',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'mq_timedsend',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'fgetxattr',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fcntl64',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fallocate',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'epoll_wait',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'llseek',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'mmap_pgoff',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'preadv64v2',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'readv',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'fstatfs',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'fstatfs64',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'write',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'mq_notify',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'sendfile',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'mq_open',
+                        'reason': set([('dentry', 'd_inode'),
+                                       ('file', 'f_op')])},
+                       {'call': 'unlinkat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'open_by_handle_at',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'bind',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'flistxattr',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                       {'call': 'sendfile64',
+                        'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'inotify_init1': [{'call': 'keyctl',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'inotify_rm_watch',
+                    'reason': set([('fsnotify_group', 'overflow_event'),
+                                   ('inotify_group_private_data',
+                                    'ucounts')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'inotify_add_watch',
+                    'reason': set([('fsnotify_group', 'overflow_event'),
+                                   ('inotify_group_private_data',
+                                    'ucounts')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getpriority',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setpriority',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'inotify_init1',
+                    'reason': set([('fsnotify_group', 'overflow_event'),
+                                   ('inotify_group_private_data',
+                                    'ucounts')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'cred')])}],
+ 'inotify_rm_watch': [{'call': 'syncfs',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'vmsplice',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+                      {'call': 'pwritev64',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fremovexattr',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'readahead',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'getdents',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'writev',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'preadv64',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'fchmod',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'pread64',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'signalfd4',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'memfd_create',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'remap_file_pages',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                      {'call': 'read',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'fchown',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'mq_timedreceive',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'utime',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'fsync',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'bpf',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'recvfrom',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'fsetxattr',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'sendto',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'epoll_create1',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'tee',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'sync_file_range',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'lseek',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'connect',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'getsockname',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'epoll_ctl',
+                       'reason': set([('fd', 'file'),
+                                      ('fd', 'flags'),
+                                      ('file', 'f_op')])},
+                      {'call': 'flock',
+                       'reason': set([('fd', 'file'),
+                                      ('fd', 'flags'),
+                                      ('file', 'f_op')])},
+                      {'call': 'pwritev',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'fchdir',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                      {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                      {'call': 'accept4',
+                       'reason': set([('fd', 'file'),
+                                      ('fd', 'flags'),
+                                      ('file', 'f_op')])},
+                      {'call': 'old_readdir',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'inotify_rm_watch',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'socketpair',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'utimensat',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'inotify_add_watch',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'preadv2',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'splice',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'ftruncate',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'preadv',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'getpeername',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                      {'call': 'setsockopt',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                      {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fcntl',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'ioctl',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'pwrite64',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'perf_event_open',
+                       'reason': set([('fd', 'file'),
+                                      ('fd', 'flags'),
+                                      ('file', 'f_op')])},
+                      {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                      {'call': 'pwritev64v2',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'futimesat',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'pwritev2',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'shutdown',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                      {'call': 'open', 'reason': set([('file', 'f_op')])},
+                      {'call': 'getsockopt',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'mq_getsetattr',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fdatasync',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'setns', 'reason': set([('file', 'f_op')])},
+                      {'call': 'getdents64',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'listen',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'copy_file_range',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'mq_timedsend',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'fgetxattr',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fcntl64',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fallocate',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'epoll_wait',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'llseek',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'mmap_pgoff',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'preadv64v2',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'readv',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'fstatfs',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'fstatfs64',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'write',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'mq_notify',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'sendfile',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+                      {'call': 'open_by_handle_at',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'bind',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'flistxattr',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                      {'call': 'sendfile64',
+                       'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'io_cancel': [{'call': 'swapoff',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'io_getevents',
+                'reason': set([('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr'),
+                               ('mm_struct', 'ioctx_table')])},
+               {'call': 'migrate_pages',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'shmdt',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'brk', 'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'get_mempolicy',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'io_submit', 'reason': set([('kioctx', 'user_id')])},
+               {'call': 'getrusage',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'io_setup',
+                'reason': set([('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr'),
+                               ('mm_struct', 'ioctx_table')])},
+               {'call': 'mremap',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'io_destroy',
+                'reason': set([('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr'),
+                               ('mm_struct', 'ioctx_table')])},
+               {'call': 'mbind',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'prctl',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'move_pages',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'modify_ldt',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'mincore',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'io_cancel',
+                'reason': set([('aio_kiocb', 'ki_user_iocb'),
+                               ('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr'),
+                               ('mm_struct', 'ioctx_table')])}],
+ 'io_destroy': [{'call': 'swapoff',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'io_getevents',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr'),
+                                ('mm_struct', 'ioctx_table')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'shmdt',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'brk',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'io_submit',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'io_setup',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr'),
+                                ('mm_struct', 'ioctx_table')])},
+                {'call': 'mremap',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'io_destroy',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr'),
+                                ('mm_struct', 'ioctx_table')])},
+                {'call': 'mbind',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'prctl',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'modify_ldt',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'mincore',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'io_cancel',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr'),
+                                ('mm_struct', 'ioctx_table')])}],
+ 'io_getevents': [{'call': 'keyctl',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'rt_sigtimedwait',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'msgrcv',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'kill',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'swapoff',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'sched_getaffinity',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setparam',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'ioprio_set',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'remap_file_pages',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'io_getevents',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr'),
+                                  ('mm_struct', 'ioctx_table')])},
+                  {'call': 'getppid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'capget',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setaffinity',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'signal',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'semtimedop',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'umount',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_rr_get_interval',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'rt_sigprocmask',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setsid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sigaltstack',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setattr',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'migrate_pages',
+                   'reason': set([('mm_struct', 'ioctx_table'),
+                                  ('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getitimer',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setpgid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getsid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'prlimit64',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'shmdt',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'rt_sigaction',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getpgid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'brk',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'getpriority',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sigaction',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setns',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'fork',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'get_mempolicy',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'io_submit',
+                   'reason': set([('kioctx', 'user_id')])},
+                  {'call': 'get_robust_list',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getscheduler',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'ptrace',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getattr',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getrusage',
+                   'reason': set([('mm_struct', 'ioctx_table'),
+                                  ('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setscheduler',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setitimer',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'ioprio_get',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'vfork',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'io_setup',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr'),
+                                  ('mm_struct', 'ioctx_table')])},
+                  {'call': 'mremap',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'io_destroy',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr'),
+                                  ('mm_struct', 'ioctx_table')])},
+                  {'call': 'mbind',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'prctl',
+                   'reason': set([('mm_struct', 'ioctx_table'),
+                                  ('task_struct', 'timer_slack_ns')])},
+                  {'call': 'move_pages',
+                   'reason': set([('mm_struct', 'ioctx_table'),
+                                  ('task_struct', 'timer_slack_ns')])},
+                  {'call': 'modify_ldt',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'setpriority',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'mincore',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'clone',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getparam',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'io_cancel',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr'),
+                                  ('mm_struct', 'ioctx_table')])}],
+ 'io_setup': [{'call': 'io_getevents',
+               'reason': set([('kioctx', 'cpu'),
+                              ('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_submit',
+               'reason': set([('kioctx', 'cpu'),
+                              ('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_setup',
+               'reason': set([('kioctx', 'cpu'),
+                              ('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_destroy',
+               'reason': set([('kioctx', 'cpu'),
+                              ('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_cancel',
+               'reason': set([('kioctx', 'cpu'),
+                              ('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])}],
+ 'io_submit': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setparam',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_set',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'semtimedop',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaltstack',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'migrate_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prlimit64',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'perf_event_open',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'get_robust_list',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getrusage',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_get',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'move_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getparam',
+                'reason': set([('mm_segment_t', 'seg')])}],
+ 'ioctl': [{'call': 'syncfs',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'vmsplice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fremovexattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readahead',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getdents',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'writev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchmod',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pread64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'signalfd4',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'read', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'utime',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fsync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'recvfrom',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fsetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendto',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sync_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'lseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'connect',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getsockname',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'flock',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'accept4',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'old_readdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_rm_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'utimensat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'splice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ftruncate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getpeername',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'setsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fcntl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ioctl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwrite64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'perf_event_open',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'futimesat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'shutdown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fdatasync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getdents64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'listen',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'copy_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fgetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fcntl64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fallocate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_wait',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'llseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'write',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_notify',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'bind', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'flistxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'ioperm': [{'call': 'keyctl',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'msgrcv',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'kill',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setparam',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ioprio_set',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getppid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ioperm',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'capget',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'signal',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'semtimedop',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'umount',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setsid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sigaltstack',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setattr',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'migrate_pages',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getitimer',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setpgid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getsid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'prlimit64',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'perf_event_open',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getpgid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getpriority',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sigaction',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setns',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'fork',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'get_robust_list',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ptrace',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getattr',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getrusage',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setitimer',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ioprio_get',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'vfork',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'prctl',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'move_pages',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setpriority',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'clone',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getparam',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])}],
+ 'ioprio_get': [{'call': 'keyctl',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'msgrcv',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'kill',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getppid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'capget',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'signal',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'semtimedop',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'umount',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setsid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getitimer',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setpgid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getsid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'prlimit64',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getpgid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getpriority',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sigaction',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setns',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'fork',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ptrace',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getrusage',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setitimer',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'vfork',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'prctl',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'move_pages',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setpriority',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'clone',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])}],
+ 'ioprio_set': [{'call': 'keyctl',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'msgrcv',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'kill',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getppid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'capget',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'signal',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'semtimedop',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'umount',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setsid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getitimer',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setpgid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getsid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'prlimit64',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getpgid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getpriority',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sigaction',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setns',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'fork',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ptrace',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getrusage',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setitimer',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'vfork',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'prctl',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'move_pages',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setpriority',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'clone',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])}],
+ 'keyctl': [{'call': 'keyctl',
+             'reason': set([('cred', 'session_keyring'),
+                            ('key', 'description'),
+                            ('key', 'gid'),
+                            ('key', 'perm'),
+                            ('key', 'quotalen'),
+                            ('key', 'serial'),
+                            ('key', 'uid'),
+                            ('key_type', 'name'),
+                            ('key_type', 'read'),
+                            ('key_user', 'qnbytes'),
+                            ('key_user', 'qnkeys'),
+                            ('request_key_auth', 'target_key'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setfsuid',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'kill',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getresuid16',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'getresgid',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setgid',
+             'reason': set([('cred', 'egid'),
+                            ('cred', 'gid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'sgid')])},
+            {'call': 'ioprio_set',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'capset', 'reason': set([('cred', 'session_keyring')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getresgid16',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setfsgid',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'unshare', 'reason': set([('cred', 'session_keyring')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setreuid',
+             'reason': set([('cred', 'euid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'suid'),
+                            ('cred', 'uid')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'epoll_create1',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'getresuid',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setresgid',
+             'reason': set([('cred', 'egid'),
+                            ('cred', 'gid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'sgid')])},
+            {'call': 'setregid',
+             'reason': set([('cred', 'egid'),
+                            ('cred', 'gid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'sgid')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'prlimit64',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getgroups16',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'request_key',
+             'reason': set([('key', 'description'),
+                            ('key', 'perm'),
+                            ('key', 'quotalen'),
+                            ('key', 'serial'),
+                            ('key_type', 'name'),
+                            ('key_type', 'read')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getpriority',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'faccessat',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'fork',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'ptrace',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getrusage',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setresuid',
+             'reason': set([('cred', 'euid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'suid'),
+                            ('cred', 'uid')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'ioprio_get',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setuid',
+             'reason': set([('cred', 'euid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'suid'),
+                            ('cred', 'uid')])},
+            {'call': 'prctl',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'move_pages',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getgroups',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'setpriority',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])}],
+ 'kill': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'rt_sigtimedwait',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_getaffinity',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_setparam',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'mq_timedreceive',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_setaffinity',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_rr_get_interval',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'rt_sigprocmask',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_setattr', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'migrate_pages', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'perf_event_open',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'rt_sigaction', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'get_robust_list',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'mq_timedsend', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_getscheduler',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_getattr', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_setscheduler',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_getparam',
+           'reason': set([('task_struct', 'cred')])}],
+ 'lgetxattr': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+               {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+               {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+               {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+               {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+               {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+               {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+               {'call': 'flock', 'reason': set([('path', 'dentry')])},
+               {'call': 'openat', 'reason': set([('path', 'dentry')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+               {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+               {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+               {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+               {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+               {'call': 'socket', 'reason': set([('path', 'dentry')])},
+               {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+               {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+               {'call': 'acct', 'reason': set([('path', 'dentry')])},
+               {'call': 'open', 'reason': set([('path', 'dentry')])},
+               {'call': 'dup', 'reason': set([('path', 'dentry')])},
+               {'call': 'setns', 'reason': set([('path', 'dentry')])},
+               {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+               {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+               {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+               {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'dentry')])}],
+ 'linkat': [{'call': 'eventfd2', 'reason': set([('path', 'mnt')])},
+            {'call': 'swapoff', 'reason': set([('path', 'mnt')])},
+            {'call': 'pivot_root', 'reason': set([('path', 'mnt')])},
+            {'call': 'memfd_create', 'reason': set([('path', 'mnt')])},
+            {'call': 'remap_file_pages', 'reason': set([('path', 'mnt')])},
+            {'call': 'dup3', 'reason': set([('path', 'mnt')])},
+            {'call': 'unshare', 'reason': set([('path', 'mnt')])},
+            {'call': 'epoll_create1', 'reason': set([('path', 'mnt')])},
+            {'call': 'epoll_ctl', 'reason': set([('path', 'mnt')])},
+            {'call': 'flock', 'reason': set([('path', 'mnt')])},
+            {'call': 'openat', 'reason': set([('path', 'mnt')])},
+            {'call': 'lookup_dcookie', 'reason': set([('path', 'mnt')])},
+            {'call': 'uselib', 'reason': set([('path', 'mnt')])},
+            {'call': 'accept4', 'reason': set([('path', 'mnt')])},
+            {'call': 'socketpair', 'reason': set([('path', 'mnt')])},
+            {'call': 'getcwd', 'reason': set([('path', 'mnt')])},
+            {'call': 'shmat', 'reason': set([('path', 'mnt')])},
+            {'call': 'socket', 'reason': set([('path', 'mnt')])},
+            {'call': 'pipe2', 'reason': set([('path', 'mnt')])},
+            {'call': 'perf_event_open', 'reason': set([('path', 'mnt')])},
+            {'call': 'shmdt', 'reason': set([('path', 'mnt')])},
+            {'call': 'quotactl', 'reason': set([('path', 'mnt')])},
+            {'call': 'acct', 'reason': set([('path', 'mnt')])},
+            {'call': 'open', 'reason': set([('path', 'mnt')])},
+            {'call': 'dup', 'reason': set([('path', 'mnt')])},
+            {'call': 'setns', 'reason': set([('path', 'mnt')])},
+            {'call': 'shmctl', 'reason': set([('path', 'mnt')])},
+            {'call': 'swapon', 'reason': set([('path', 'mnt')])},
+            {'call': 'mmap_pgoff', 'reason': set([('path', 'mnt')])},
+            {'call': 'mq_open', 'reason': set([('path', 'mnt')])},
+            {'call': 'open_by_handle_at', 'reason': set([('path', 'mnt')])}],
+ 'listen': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+            {'call': 'readahead', 'reason': set([('fd', 'file')])},
+            {'call': 'getdents', 'reason': set([('fd', 'file')])},
+            {'call': 'writev', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+            {'call': 'pread64', 'reason': set([('fd', 'file')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+            {'call': 'read', 'reason': set([('fd', 'file')])},
+            {'call': 'fchown', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+            {'call': 'utime', 'reason': set([('fd', 'file')])},
+            {'call': 'fsync', 'reason': set([('fd', 'file')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'sendto', 'reason': set([('fd', 'file')])},
+            {'call': 'tee', 'reason': set([('fd', 'file')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+            {'call': 'lseek', 'reason': set([('fd', 'file')])},
+            {'call': 'connect', 'reason': set([('fd', 'file')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+            {'call': 'flock', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+            {'call': 'accept4', 'reason': set([('fd', 'file')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+            {'call': 'splice', 'reason': set([('fd', 'file')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv', 'reason': set([('fd', 'file')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+            {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+            {'call': 'listen', 'reason': set([('fd', 'file')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+            {'call': 'llseek', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+            {'call': 'readv', 'reason': set([('fd', 'file')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+            {'call': 'write', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+            {'call': 'bind', 'reason': set([('fd', 'file')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'listxattr': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+               {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+               {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+               {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+               {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+               {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+               {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+               {'call': 'flock', 'reason': set([('path', 'dentry')])},
+               {'call': 'openat', 'reason': set([('path', 'dentry')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+               {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+               {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+               {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+               {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+               {'call': 'socket', 'reason': set([('path', 'dentry')])},
+               {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+               {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+               {'call': 'acct', 'reason': set([('path', 'dentry')])},
+               {'call': 'open', 'reason': set([('path', 'dentry')])},
+               {'call': 'dup', 'reason': set([('path', 'dentry')])},
+               {'call': 'setns', 'reason': set([('path', 'dentry')])},
+               {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+               {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+               {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+               {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'dentry')])}],
+ 'llistxattr': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+                {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+                {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+                {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+                {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+                {'call': 'flock', 'reason': set([('path', 'dentry')])},
+                {'call': 'openat', 'reason': set([('path', 'dentry')])},
+                {'call': 'lookup_dcookie',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+                {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+                {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+                {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+                {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+                {'call': 'socket', 'reason': set([('path', 'dentry')])},
+                {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+                {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+                {'call': 'acct', 'reason': set([('path', 'dentry')])},
+                {'call': 'open', 'reason': set([('path', 'dentry')])},
+                {'call': 'dup', 'reason': set([('path', 'dentry')])},
+                {'call': 'setns', 'reason': set([('path', 'dentry')])},
+                {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+                {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+                {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+                {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('path', 'dentry')])}],
+ 'llseek': [{'call': 'syncfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'vmsplice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fremovexattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readahead',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getdents',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'writev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchmod',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pread64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'signalfd4',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'read',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'utime',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'recvfrom',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendto',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sync_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'lseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'connect',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getsockname',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'old_readdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'inotify_rm_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'utimensat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'splice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ftruncate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getpeername',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'setsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fcntl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ioctl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwrite64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'futimesat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shutdown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fdatasync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getdents64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'listen',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'copy_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fgetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fcntl64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fallocate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_wait',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'llseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'write',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_notify',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'bind',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'flistxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'lremovexattr': [{'call': 'eventfd2',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'swapoff',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'pivot_root',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'memfd_create',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'remap_file_pages',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'dup3',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'unshare',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'epoll_create1',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'epoll_ctl',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'flock',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'openat',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'lookup_dcookie',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'uselib',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'accept4',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'socketpair',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'getcwd',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'shmat',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'socket',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'pipe2',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'shmdt',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'quotactl',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'acct',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'open',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'dup',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'setns',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'shmctl',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'swapon',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'mmap_pgoff',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'mq_open',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'open_by_handle_at',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'lseek': [{'call': 'syncfs',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'vmsplice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fremovexattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readahead',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getdents',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'writev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchmod',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pread64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'signalfd4',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'read', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'utime',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fsync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'recvfrom',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fsetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendto',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sync_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'lseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'connect',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getsockname',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'flock',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'accept4',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'old_readdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_rm_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'utimensat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'splice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ftruncate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getpeername',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'setsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fcntl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ioctl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwrite64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'perf_event_open',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'futimesat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'shutdown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fdatasync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getdents64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'listen',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'copy_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fgetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fcntl64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fallocate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_wait',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'llseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'write',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_notify',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'bind', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'flistxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'lsetxattr': [{'call': 'eventfd2',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'swapoff',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'pivot_root',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'memfd_create',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'dup3',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'unshare',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'epoll_create1',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'flock',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'openat',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'uselib',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'accept4',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'socketpair',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'getcwd',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'shmat',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'socket',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'pipe2',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'shmdt',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'quotactl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'acct',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'open',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'dup',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'setns',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'shmctl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'swapon',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mmap_pgoff',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mq_open',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'lstat': [{'call': 'lstat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])},
+           {'call': 'stat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])},
+           {'call': 'fstat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink'),
+                           ('kstat', 'dev'),
+                           ('kstat', 'ino'),
+                           ('kstat', 'nlink'),
+                           ('kstat', 'rdev')])},
+           {'call': 'newfstat',
+            'reason': set([('kstat', 'dev'),
+                           ('kstat', 'ino'),
+                           ('kstat', 'nlink'),
+                           ('kstat', 'rdev')])}],
+ 'madvise': [{'call': 'remap_file_pages',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'shmdt',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'brk',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'get_mempolicy',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'munlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'pkey_mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'madvise',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mremap',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'prctl',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'munlock',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mincore',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])}],
+ 'migrate_pages': [{'call': 'keyctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'kill',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getppid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'ioperm',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'capget',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'signal',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setreuid',
+                    'reason': set([('cred', 'euid'),
+                                   ('cred', 'suid'),
+                                   ('cred', 'uid')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'umount',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setns',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'fork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'ptrace',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getrusage',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setresuid',
+                    'reason': set([('cred', 'euid'),
+                                   ('cred', 'suid'),
+                                   ('cred', 'uid')])},
+                   {'call': 'setitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'vfork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setuid',
+                    'reason': set([('cred', 'euid'),
+                                   ('cred', 'suid'),
+                                   ('cred', 'uid')])},
+                   {'call': 'prctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'move_pages',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'clone',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])}],
+ 'mincore': [{'call': 'keyctl',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'msgrcv',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'kill',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_setparam',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'ioprio_set',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'getppid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'capget',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'signal',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'semtimedop',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'umount',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'setsid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sigaltstack',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_setattr',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'migrate_pages',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'getitimer',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'setpgid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'getsid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'prlimit64',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'perf_event_open',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'shmdt',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'getpgid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'brk', 'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'getpriority',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sigaction',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'setns',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'fork',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'get_mempolicy',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'get_robust_list',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'ptrace',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'munlockall',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'pkey_mprotect',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'madvise',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'sched_getattr',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'getrusage',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'setitimer',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'ioprio_get',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'vfork',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'mprotect',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'mremap',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'prctl',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'move_pages',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'munlock',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'setpriority',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'mincore',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'clone',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_getparam',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'mlockall',
+              'reason': set([('vm_area_struct', 'vm_start')])}],
+ 'mkdirat': [{'call': 'syncfs', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'umount', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'quotactl',
+              'reason': set([('super_block', 's_flags')])},
+             {'call': 'swapon', 'reason': set([('super_block', 's_flags')])}],
+ 'mknodat': [{'call': 'syncfs', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'umount', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'quotactl',
+              'reason': set([('super_block', 's_flags')])},
+             {'call': 'swapon', 'reason': set([('super_block', 's_flags')])}],
+ 'mlock': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setparam', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'rt_sigprocmask', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setattr', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'migrate_pages', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getattr', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getparam', 'reason': set([('task_struct', 'mm')])}],
+ 'mlock2': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_setattr', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'migrate_pages', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_getattr', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'mm')])}],
+ 'mlockall': [{'call': 'keyctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'swapoff', 'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'io_getevents',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'getppid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'shmdt',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'brk',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'get_mempolicy',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'munlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'pkey_mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'madvise',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'io_setup',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'mremap',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'io_destroy',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'mbind', 'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'prctl',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'modify_ldt',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'munlock',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mincore',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'clone',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'io_cancel',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'mlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])}],
+ 'mmap_pgoff': [{'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_op')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+                {'call': 'epoll_ctl', 'reason': set([('file', 'f_op')])},
+                {'call': 'flock', 'reason': set([('file', 'f_op')])},
+                {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                {'call': 'accept4', 'reason': set([('file', 'f_op')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('file', 'f_op')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                {'call': 'open', 'reason': set([('file', 'f_op')])},
+                {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                {'call': 'setns', 'reason': set([('file', 'f_op')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_op')])}],
+ 'modify_ldt': [{'call': 'swapoff', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'io_getevents',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'get_thread_area',
+                 'reason': set([('user_desc', 'base_addr'),
+                                ('user_desc', 'contents'),
+                                ('user_desc', 'entry_number'),
+                                ('user_desc', 'limit'),
+                                ('user_desc', 'limit_in_pages'),
+                                ('user_desc', 'read_exec_only'),
+                                ('user_desc', 'seg_32bit'),
+                                ('user_desc', 'seg_not_present'),
+                                ('user_desc', 'useable')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'shmdt', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'brk', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'io_setup',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'mremap', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'io_destroy',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'mbind', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'prctl', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'modify_ldt',
+                 'reason': set([('ldt_struct', 'entries'),
+                                ('mm_context_t', 'ldt'),
+                                ('user_desc', 'base_addr'),
+                                ('user_desc', 'contents'),
+                                ('user_desc', 'entry_number'),
+                                ('user_desc', 'limit'),
+                                ('user_desc', 'limit_in_pages'),
+                                ('user_desc', 'read_exec_only'),
+                                ('user_desc', 'seg_32bit'),
+                                ('user_desc', 'seg_not_present'),
+                                ('user_desc', 'useable')])},
+                {'call': 'mincore', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'set_thread_area',
+                 'reason': set([('user_desc', 'base_addr'),
+                                ('user_desc', 'contents'),
+                                ('user_desc', 'entry_number'),
+                                ('user_desc', 'limit'),
+                                ('user_desc', 'limit_in_pages'),
+                                ('user_desc', 'read_exec_only'),
+                                ('user_desc', 'seg_32bit'),
+                                ('user_desc', 'seg_not_present'),
+                                ('user_desc', 'useable')])},
+                {'call': 'io_cancel',
+                 'reason': set([('mm_context_t', 'ldt')])}],
+ 'mount': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mount',
+            'reason': set([('compat_nfs4_mount_data_v1', 'auth_flavours'),
+                           ('compat_nfs4_mount_data_v1', 'host_addr')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getrusage',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'move_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'personality')])}],
+ 'mprotect': [{'call': 'keyctl',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'getppid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'shmdt',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'brk',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'get_mempolicy',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'munlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'pkey_mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'madvise',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'mremap',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'prctl',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'munlock',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mincore',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'clone',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])}],
+ 'mq_getsetattr': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                   {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                   {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+                   {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                   {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                   {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+                   {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                   {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                   {'call': 'writev', 'reason': set([('fd', 'file')])},
+                   {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                   {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                   {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                   {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                   {'call': 'memfd_create',
+                    'reason': set([('file', 'f_op')])},
+                   {'call': 'remap_file_pages',
+                    'reason': set([('file', 'f_op')])},
+                   {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                   {'call': 'read', 'reason': set([('fd', 'file')])},
+                   {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('fd', 'file'), ('mq_attr', 'mq_flags')])},
+                   {'call': 'utime', 'reason': set([('fd', 'file')])},
+                   {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                   {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                   {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                   {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                   {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                   {'call': 'epoll_create1',
+                    'reason': set([('file', 'f_op')])},
+                   {'call': 'tee', 'reason': set([('fd', 'file')])},
+                   {'call': 'sync_file_range',
+                    'reason': set([('fd', 'file')])},
+                   {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                   {'call': 'connect', 'reason': set([('fd', 'file')])},
+                   {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                   {'call': 'epoll_ctl',
+                    'reason': set([('fd', 'file'), ('file', 'f_op')])},
+                   {'call': 'flock',
+                    'reason': set([('fd', 'file'), ('file', 'f_op')])},
+                   {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                   {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                   {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                   {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                   {'call': 'accept4',
+                    'reason': set([('fd', 'file'), ('file', 'f_op')])},
+                   {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                   {'call': 'inotify_rm_watch',
+                    'reason': set([('fd', 'file')])},
+                   {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+                   {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                   {'call': 'inotify_add_watch',
+                    'reason': set([('fd', 'file')])},
+                   {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                   {'call': 'splice', 'reason': set([('fd', 'file')])},
+                   {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                   {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                   {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                   {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                   {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                   {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                   {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                   {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                   {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                   {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('fd', 'file'), ('file', 'f_op')])},
+                   {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                   {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                   {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                   {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                   {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                   {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                   {'call': 'open', 'reason': set([('file', 'f_op')])},
+                   {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                   {'call': 'mq_getsetattr',
+                    'reason': set([('fd', 'file'), ('mq_attr', 'mq_flags')])},
+                   {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                   {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                   {'call': 'setns', 'reason': set([('file', 'f_op')])},
+                   {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                   {'call': 'listen', 'reason': set([('fd', 'file')])},
+                   {'call': 'copy_file_range',
+                    'reason': set([('fd', 'file')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('fd', 'file'), ('mq_attr', 'mq_flags')])},
+                   {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                   {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                   {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                   {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                   {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                   {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                   {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                   {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+                   {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                   {'call': 'readv', 'reason': set([('fd', 'file')])},
+                   {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                   {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                   {'call': 'write', 'reason': set([('fd', 'file')])},
+                   {'call': 'mq_notify',
+                    'reason': set([('fd', 'file'), ('mq_attr', 'mq_flags')])},
+                   {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                   {'call': 'mq_open',
+                    'reason': set([('file', 'f_op'),
+                                   ('mq_attr', 'mq_flags')])},
+                   {'call': 'open_by_handle_at',
+                    'reason': set([('file', 'f_op')])},
+                   {'call': 'bind', 'reason': set([('fd', 'file')])},
+                   {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                   {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'mq_notify': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+               {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+               {'call': 'readahead', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents', 'reason': set([('fd', 'file')])},
+               {'call': 'writev', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+               {'call': 'pread64', 'reason': set([('fd', 'file')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+               {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_op')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+               {'call': 'read', 'reason': set([('fd', 'file')])},
+               {'call': 'fchown', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'file'),
+                               ('mqueue_inode_info', 'notify_owner'),
+                               ('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'utime', 'reason': set([('fd', 'file')])},
+               {'call': 'fsync', 'reason': set([('fd', 'file')])},
+               {'call': 'bpf', 'reason': set([('fd', 'file')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'timer_create',
+                'reason': set([('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'sendto', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+               {'call': 'tee', 'reason': set([('fd', 'file')])},
+               {'call': 'rt_sigqueueinfo',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'lseek', 'reason': set([('fd', 'file')])},
+               {'call': 'connect', 'reason': set([('fd', 'file')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'file'), ('file', 'f_op')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'file'), ('file', 'f_op')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+               {'call': 'tgkill', 'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'openat', 'reason': set([('file', 'f_op')])},
+               {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'file'), ('file', 'f_op')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+               {'call': 'splice', 'reason': set([('fd', 'file')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv', 'reason': set([('fd', 'file')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+               {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'socket', 'reason': set([('file', 'f_op')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'file'), ('file', 'f_op')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+               {'call': 'acct', 'reason': set([('file', 'f_op')])},
+               {'call': 'open', 'reason': set([('file', 'f_op')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'rt_tgsigqueueinfo',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'file'),
+                               ('mqueue_inode_info', 'notify_owner'),
+                               ('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'dup', 'reason': set([('file', 'f_op')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+               {'call': 'setns', 'reason': set([('file', 'f_op')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+               {'call': 'listen', 'reason': set([('fd', 'file')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'file'),
+                               ('mqueue_inode_info', 'notify_owner'),
+                               ('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+               {'call': 'llseek', 'reason': set([('fd', 'file')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'readv', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+               {'call': 'rt_sigreturn',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'write', 'reason': set([('fd', 'file')])},
+               {'call': 'tkill', 'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'file'),
+                               ('mqueue_inode_info', 'notify_owner'),
+                               ('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr'),
+                               ('sk_buff', 'data')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_op')])},
+               {'call': 'bind', 'reason': set([('fd', 'file')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'mq_open': [{'call': 'sysfs', 'reason': set([('filename', 'name')])},
+             {'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+             {'call': 'mq_unlink', 'reason': set([('filename', 'name')])},
+             {'call': 'swapoff',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+             {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('path', 'dentry')])},
+             {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+             {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+             {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+             {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+             {'call': 'flock', 'reason': set([('path', 'dentry')])},
+             {'call': 'openat',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+             {'call': 'uselib',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'renameat2', 'reason': set([('filename', 'name')])},
+             {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+             {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+             {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+             {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+             {'call': 'socket', 'reason': set([('path', 'dentry')])},
+             {'call': 'symlinkat', 'reason': set([('filename', 'name')])},
+             {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+             {'call': 'perf_event_open', 'reason': set([('path', 'dentry')])},
+             {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+             {'call': 'quotactl',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'acct',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'open',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'unlink', 'reason': set([('filename', 'name')])},
+             {'call': 'rmdir', 'reason': set([('filename', 'name')])},
+             {'call': 'dup', 'reason': set([('path', 'dentry')])},
+             {'call': 'setns', 'reason': set([('path', 'dentry')])},
+             {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+             {'call': 'swapon',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+             {'call': 'mq_open',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'unlinkat', 'reason': set([('filename', 'name')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('path', 'dentry')])}],
+ 'mq_timedreceive': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                     {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                     {'call': 'msgrcv', 'reason': set([('msg_msg', 'm_ts')])},
+                     {'call': 'eventfd2',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                     {'call': 'swapoff',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'file')])},
+                     {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                     {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                     {'call': 'writev', 'reason': set([('fd', 'file')])},
+                     {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                     {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                     {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                     {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                     {'call': 'memfd_create',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'remap_file_pages',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'dup3',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'read', 'reason': set([('fd', 'file')])},
+                     {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'file'),
+                                     ('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize'),
+                                     ('mqueue_inode_info', 'node_cache'),
+                                     ('msg_msg', 'm_ts')])},
+                     {'call': 'utime', 'reason': set([('fd', 'file')])},
+                     {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                     {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                     {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                     {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                     {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                     {'call': 'epoll_create1',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'tee', 'reason': set([('fd', 'file')])},
+                     {'call': 'sync_file_range',
+                      'reason': set([('fd', 'file')])},
+                     {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                     {'call': 'connect', 'reason': set([('fd', 'file')])},
+                     {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                     {'call': 'epoll_ctl',
+                      'reason': set([('fd', 'file'),
+                                     ('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'flock',
+                      'reason': set([('fd', 'file'),
+                                     ('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                     {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                     {'call': 'openat',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'uselib',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'accept4',
+                      'reason': set([('fd', 'file'),
+                                     ('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'file')])},
+                     {'call': 'socketpair',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'file')])},
+                     {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                     {'call': 'splice', 'reason': set([('fd', 'file')])},
+                     {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                     {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                     {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                     {'call': 'shmat',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                     {'call': 'socket',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'pipe2',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                     {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                     {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('fd', 'file'),
+                                     ('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'shmdt',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                     {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                     {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                     {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                     {'call': 'acct',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'open',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'file'),
+                                     ('file', 'f_flags'),
+                                     ('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize'),
+                                     ('mqueue_inode_info', 'node_cache')])},
+                     {'call': 'dup',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                     {'call': 'setns',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                     {'call': 'listen', 'reason': set([('fd', 'file')])},
+                     {'call': 'copy_file_range',
+                      'reason': set([('fd', 'file')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'file'),
+                                     ('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize'),
+                                     ('mqueue_inode_info', 'node_cache'),
+                                     ('msg_msg', 'm_ts')])},
+                     {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                     {'call': 'shmctl',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                     {'call': 'swapon',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                     {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                     {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                     {'call': 'mmap_pgoff',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                     {'call': 'readv', 'reason': set([('fd', 'file')])},
+                     {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                     {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                     {'call': 'msgsnd', 'reason': set([('msg_msg', 'm_ts')])},
+                     {'call': 'write', 'reason': set([('fd', 'file')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('fd', 'file'),
+                                     ('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize'),
+                                     ('mqueue_inode_info', 'node_cache')])},
+                     {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                     {'call': 'mq_open',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op'),
+                                     ('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize')])},
+                     {'call': 'open_by_handle_at',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'bind', 'reason': set([('fd', 'file')])},
+                     {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                     {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'mq_timedsend': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                  {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                  {'call': 'eventfd2',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                  {'call': 'swapoff',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+                  {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                  {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                  {'call': 'writev', 'reason': set([('fd', 'file')])},
+                  {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                  {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                  {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                  {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                  {'call': 'memfd_create',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'remap_file_pages',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'dup3',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'read', 'reason': set([('fd', 'file')])},
+                  {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('fd', 'file'),
+                                  ('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize'),
+                                  ('mqueue_inode_info', 'node_cache')])},
+                  {'call': 'utime', 'reason': set([('fd', 'file')])},
+                  {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                  {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                  {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                  {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                  {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                  {'call': 'epoll_create1',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'tee', 'reason': set([('fd', 'file')])},
+                  {'call': 'sync_file_range',
+                   'reason': set([('fd', 'file')])},
+                  {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                  {'call': 'connect', 'reason': set([('fd', 'file')])},
+                  {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                  {'call': 'epoll_ctl',
+                   'reason': set([('fd', 'file'),
+                                  ('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'flock',
+                   'reason': set([('fd', 'file'),
+                                  ('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                  {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                  {'call': 'openat',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'uselib',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'accept4',
+                   'reason': set([('fd', 'file'),
+                                  ('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                  {'call': 'inotify_rm_watch',
+                   'reason': set([('fd', 'file')])},
+                  {'call': 'socketpair',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                  {'call': 'inotify_add_watch',
+                   'reason': set([('fd', 'file')])},
+                  {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                  {'call': 'splice', 'reason': set([('fd', 'file')])},
+                  {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                  {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                  {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                  {'call': 'shmat',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                  {'call': 'socket',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'pipe2',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                  {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                  {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('fd', 'file'),
+                                  ('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'shmdt',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                  {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                  {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                  {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                  {'call': 'acct',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'open',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                  {'call': 'mq_getsetattr',
+                   'reason': set([('fd', 'file'),
+                                  ('file', 'f_flags'),
+                                  ('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize'),
+                                  ('mqueue_inode_info', 'node_cache')])},
+                  {'call': 'dup',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                  {'call': 'setns',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                  {'call': 'listen', 'reason': set([('fd', 'file')])},
+                  {'call': 'copy_file_range',
+                   'reason': set([('fd', 'file')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('fd', 'file'),
+                                  ('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize'),
+                                  ('mqueue_inode_info', 'node_cache')])},
+                  {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                  {'call': 'shmctl',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                  {'call': 'swapon',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                  {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                  {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                  {'call': 'mmap_pgoff',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                  {'call': 'readv', 'reason': set([('fd', 'file')])},
+                  {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                  {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                  {'call': 'write', 'reason': set([('fd', 'file')])},
+                  {'call': 'mq_notify',
+                   'reason': set([('fd', 'file'),
+                                  ('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize'),
+                                  ('mqueue_inode_info', 'node_cache')])},
+                  {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                  {'call': 'mq_open',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op'),
+                                  ('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize')])},
+                  {'call': 'open_by_handle_at',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'bind', 'reason': set([('fd', 'file')])},
+                  {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                  {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'mremap': [{'call': 'keyctl',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'swapoff', 'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioprio_set',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'personality',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'io_getevents',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'prlimit64',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'shmdt',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'brk',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'get_mempolicy',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ptrace',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'munlockall',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'pkey_mprotect',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'madvise',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getrusage',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioprio_get',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'io_setup', 'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'mprotect',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'mremap',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'io_destroy',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'mbind', 'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'prctl',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'move_pages',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality')])},
+            {'call': 'modify_ldt',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'munlock',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mincore',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'io_cancel',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'mlockall',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])}],
+ 'msgctl': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgrcv',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'mq_unlink',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgget',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setparam',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semtimedop',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'shmget',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('msqid64_ds', 'msg_qbytes')])},
+            {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semget',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'shmat',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'perf_event_open',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setns',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'get_robust_list',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'shmctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'sched_getattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgsnd',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_open',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'sched_getparam',
+             'reason': set([('mm_segment_t', 'seg')])}],
+ 'msgrcv': [{'call': 'msgrcv', 'reason': set([('msg_msg', 'm_ts')])},
+            {'call': 'mq_timedreceive', 'reason': set([('msg_msg', 'm_ts')])},
+            {'call': 'mq_timedsend', 'reason': set([('msg_msg', 'm_ts')])},
+            {'call': 'msgsnd', 'reason': set([('msg_msg', 'm_ts')])}],
+ 'msgsnd': [{'call': 'msgrcv',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'mq_unlink',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'msgget',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'semtimedop',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'semctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'shmget',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'msgctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'semget',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'shmat',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'setns',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'shmctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'msgsnd',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'mq_open',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])}],
+ 'munlock': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'shmdt',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'brk',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'setns', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'get_mempolicy',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'munlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'pkey_mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'madvise',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mremap',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'prctl',
+              'reason': set([('task_struct', 'mm'),
+                             ('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'munlock',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mincore',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'mlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])}],
+ 'munlockall': [{'call': 'remap_file_pages',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'shmdt',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'brk',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'munlockall',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'pkey_mprotect',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'madvise',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mprotect',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mremap',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'prctl',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'munlock',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mincore',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mlockall',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])}],
+ 'name_to_handle_at': [{'call': 'name_to_handle_at',
+                        'reason': set([('file_handle', 'handle_bytes')])},
+                       {'call': 'syncfs',
+                        'reason': set([('super_block', 's_export_op')])},
+                       {'call': 'eventfd2',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'swapoff',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'pivot_root',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'memfd_create',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'remap_file_pages',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'dup3',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'ustat',
+                        'reason': set([('super_block', 's_export_op')])},
+                       {'call': 'unshare',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'umount',
+                        'reason': set([('super_block', 's_export_op')])},
+                       {'call': 'epoll_create1',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'epoll_ctl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'flock',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'openat',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'lookup_dcookie',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'uselib',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'accept4',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'socketpair',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'getcwd',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmat',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'socket',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'pipe2',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmdt',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'quotactl',
+                        'reason': set([('path', 'dentry'),
+                                       ('path', 'mnt'),
+                                       ('super_block', 's_export_op')])},
+                       {'call': 'acct',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'dup',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'setns',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmctl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'swapon',
+                        'reason': set([('path', 'dentry'),
+                                       ('path', 'mnt'),
+                                       ('super_block', 's_export_op')])},
+                       {'call': 'mmap_pgoff',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'mq_open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'open_by_handle_at',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'nanosleep': [{'call': 'rt_sigtimedwait',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_unlink',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'swapoff',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchmod',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'memfd_create',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'readlinkat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'io_getevents',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchown',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'utime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'semtimedop',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'settimeofday',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'pselect6',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'uselib',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchmodat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timer_settime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'ftruncate',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timer_gettime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'ioctl',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'linkat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'stime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'futimesat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'poll',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'select',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'unlink',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'nanosleep',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'faccessat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'swapon',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'epoll_wait',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchownat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fstat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_notify',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'sendfile',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'newfstat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'clock_nanosleep',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'unlinkat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'futex',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'recvmmsg',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'sendfile64',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'ppoll',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])}],
+ 'newfstat': [{'call': 'newlstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newfstatat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'fstat',
+               'reason': set([('kstat', 'dev'),
+                              ('kstat', 'ino'),
+                              ('kstat', 'nlink'),
+                              ('kstat', 'rdev'),
+                              ('kstat', 'size')])},
+              {'call': 'newfstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('kstat', 'dev'),
+                              ('kstat', 'ino'),
+                              ('kstat', 'nlink'),
+                              ('kstat', 'rdev'),
+                              ('kstat', 'size'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])}],
+ 'newfstatat': [{'call': 'newlstat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])},
+                {'call': 'newfstatat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])},
+                {'call': 'newstat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])},
+                {'call': 'fstat',
+                 'reason': set([('kstat', 'dev'),
+                                ('kstat', 'ino'),
+                                ('kstat', 'nlink'),
+                                ('kstat', 'rdev'),
+                                ('kstat', 'size')])},
+                {'call': 'newfstat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('kstat', 'dev'),
+                                ('kstat', 'ino'),
+                                ('kstat', 'nlink'),
+                                ('kstat', 'rdev'),
+                                ('kstat', 'size'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])}],
+ 'newlstat': [{'call': 'newlstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newfstatat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'fstat',
+               'reason': set([('kstat', 'dev'),
+                              ('kstat', 'ino'),
+                              ('kstat', 'nlink'),
+                              ('kstat', 'rdev'),
+                              ('kstat', 'size')])},
+              {'call': 'newfstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('kstat', 'dev'),
+                              ('kstat', 'ino'),
+                              ('kstat', 'nlink'),
+                              ('kstat', 'rdev'),
+                              ('kstat', 'size'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])}],
+ 'newstat': [{'call': 'newlstat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])},
+             {'call': 'newfstatat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])},
+             {'call': 'newstat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])},
+             {'call': 'fstat',
+              'reason': set([('kstat', 'dev'),
+                             ('kstat', 'ino'),
+                             ('kstat', 'nlink'),
+                             ('kstat', 'rdev'),
+                             ('kstat', 'size')])},
+             {'call': 'newfstat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('kstat', 'dev'),
+                             ('kstat', 'ino'),
+                             ('kstat', 'nlink'),
+                             ('kstat', 'rdev'),
+                             ('kstat', 'size'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])}],
+ 'newuname': [{'call': 'keyctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getppid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'clone',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'personality')])}],
+ 'old_getrlimit': [{'call': 'setrlimit',
+                    'reason': set([('rlimit', 'rlim_cur'),
+                                   ('rlimit', 'rlim_max')])},
+                   {'call': 'old_getrlimit',
+                    'reason': set([('rlimit', 'rlim_cur'),
+                                   ('rlimit', 'rlim_max')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('rlimit', 'rlim_cur'),
+                                   ('rlimit', 'rlim_max')])}],
+ 'old_readdir': [{'call': 'syncfs',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'vmsplice',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'pwritev64',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fremovexattr',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'readahead',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'getdents',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'writev',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'preadv64',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fchmod',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'pread64',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'signalfd4',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'read',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fchown',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'utime',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fsync',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'bpf',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'recvfrom',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fsetxattr',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'sendto',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'tee',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'sync_file_range',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'lseek',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'connect',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'getsockname',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'epoll_ctl',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'flock',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'pwritev',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fchdir',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'accept4',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'old_readdir',
+                  'reason': set([('compat_readdir_callback', 'result'),
+                                 ('fd', 'file'),
+                                 ('fd', 'flags'),
+                                 ('readdir_callback', 'result')])},
+                 {'call': 'inotify_rm_watch',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'utimensat',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'inotify_add_watch',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'preadv2',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'splice',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'ftruncate',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'preadv',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'getpeername',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'setsockopt',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fcntl',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'ioctl',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'pwrite64',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'pwritev64v2',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'futimesat',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'pwritev2',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'shutdown',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'getsockopt',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'mq_getsetattr',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fdatasync',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'getdents64',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'listen',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'copy_file_range',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fgetxattr',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fcntl64',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fallocate',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'epoll_wait',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'llseek',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'preadv64v2',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'readv',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fstatfs',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'fstatfs64',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'write',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'mq_notify',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'sendfile',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'bind',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'flistxattr',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                 {'call': 'sendfile64',
+                  'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'olduname': [{'call': 'keyctl',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getppid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getpriority',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'get_robust_list',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getattr',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'prctl',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setpriority',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'clone',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])}],
+ 'open_by_handle_at': [{'call': 'eventfd2',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'swapoff',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'pivot_root',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'memfd_create',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'remap_file_pages',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'dup3',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'unshare',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'epoll_create1',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'epoll_ctl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'flock',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'openat',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'lookup_dcookie',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'uselib',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'accept4',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'socketpair',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'getcwd',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmat',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'socket',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'pipe2',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmdt',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'quotactl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'acct',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'dup',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'setns',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmctl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'swapon',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'mmap_pgoff',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'mq_open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'open_by_handle_at',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'perf_event_open': [{'call': 'syncfs',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'keyctl',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'rt_sigtimedwait',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'vmsplice',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'msgrcv',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'eventfd2',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'mq_unlink',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'pwritev64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'kill',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'swapoff',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'readahead',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'getdents',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'timer_delete',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_getaffinity',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'writev',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'preadv64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sched_setparam',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchmod',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'setgid',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'pread64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pivot_root',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'signalfd4',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'memfd_create',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'ioprio_set',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'delete_module',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'remap_file_pages',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'dup3',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'readlinkat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'read',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'io_getevents',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getppid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchown',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'ioperm',
+                      'reason': set([('mm_segment_t', 'seg')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'capget',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'utime',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sched_setaffinity',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'ustat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'fsync',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'bpf',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'unshare',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'signal',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setreuid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'umount',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'recvfrom',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fsetxattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'timer_create',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sendto',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mkdirat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'epoll_create1',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'timerfd_gettime',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'tee',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'semctl',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sync_file_range',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'lseek',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'connect',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getsockname',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'epoll_ctl',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'flock',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'pwritev',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fchdir',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'openat',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'lookup_dcookie',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'uselib',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'renameat2',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'rt_sigprocmask',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'accept4',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'msgctl',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'reboot',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setsid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'set_trip_temp',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sigaltstack',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sched_setattr',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'old_readdir',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'socketpair',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'utimensat',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'migrate_pages',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'getitimer',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchmodat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setpgid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'init_module',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setresgid',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getcwd',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'get_trip_temp',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'preadv2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'timer_settime',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setregid',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'splice',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'ftruncate',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'timer_gettime',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'preadv',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getpeername',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getsid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'shmat',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'setsockopt',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mknodat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'socket',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'symlinkat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'pipe2',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fcntl',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'ioctl',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'prlimit64',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'pwrite64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('file', 'f_op'),
+                                     ('hw_perf_event', 'sample_period'),
+                                     ('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('perf_cpu_context', 'online'),
+                                     ('perf_event', 'addr_filters_offs'),
+                                     ('perf_event', 'attach_state'),
+                                     ('perf_event', 'clock'),
+                                     ('perf_event', 'cpu'),
+                                     ('perf_event', 'ctx'),
+                                     ('perf_event', 'destroy'),
+                                     ('perf_event', 'event_caps'),
+                                     ('perf_event', 'group_caps'),
+                                     ('perf_event', 'group_leader'),
+                                     ('perf_event', 'header_size'),
+                                     ('perf_event', 'id_header_size'),
+                                     ('perf_event', 'nr_siblings'),
+                                     ('perf_event', 'ns'),
+                                     ('perf_event', 'parent'),
+                                     ('perf_event', 'pmu'),
+                                     ('perf_event', 'prog'),
+                                     ('perf_event', 'read_size'),
+                                     ('perf_event_attr', '__reserved_1'),
+                                     ('perf_event_attr', 'disabled'),
+                                     ('perf_event_attr', 'exclude_hv'),
+                                     ('perf_event_attr', 'exclude_kernel'),
+                                     ('perf_event_attr', 'exclude_user'),
+                                     ('perf_event_attr', 'exclusive'),
+                                     ('perf_event_attr', 'freq'),
+                                     ('perf_event_attr', 'inherit'),
+                                     ('perf_event_attr', 'namespaces'),
+                                     ('perf_event_attr', 'pinned'),
+                                     ('perf_event_attr', 'read_format'),
+                                     ('perf_event_attr', 'sample_freq'),
+                                     ('perf_event_attr',
+                                      'sample_max_stack'),
+                                     ('perf_event_attr', 'sample_period'),
+                                     ('perf_event_attr',
+                                      'sample_regs_intr'),
+                                     ('perf_event_attr',
+                                      'sample_regs_user'),
+                                     ('perf_event_attr',
+                                      'sample_stack_user'),
+                                     ('perf_event_attr', 'sample_type'),
+                                     ('perf_event_attr', 'use_clockid'),
+                                     ('perf_event_context', 'parent_ctx'),
+                                     ('perf_event_context', 'task'),
+                                     ('perf_event_context',
+                                      'task_ctx_data'),
+                                     ('pmu', 'capabilities'),
+                                     ('pmu', 'module'),
+                                     ('pmu', 'nr_addr_filters'),
+                                     ('pmu', 'task_ctx_nr'),
+                                     ('pmu', 'task_ctx_size'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'linkat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getgroups16',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'shmdt',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'pwritev64v2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'quotactl',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'rt_sigaction',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'futimesat',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'request_key',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getpgid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'brk', 'reason': set([('list_head', 'prev')])},
+                     {'call': 'pwritev2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'shutdown',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'acct',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'open',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'unlink',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getsockopt',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'exit_group',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getpriority',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sigaction',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'faccessat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'rmdir',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'dup',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fdatasync',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'setgroups16',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setns',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'getdents64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'listen',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fork',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'get_mempolicy',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'io_submit',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'get_robust_list',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'copy_file_range',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sched_yield',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_getscheduler',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fgetxattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'ptrace',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'shmctl',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fcntl64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'munlockall',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'swapon',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fallocate',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pkey_mprotect',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'madvise',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'epoll_wait',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'sched_getattr',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchownat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getrusage',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'timerfd_settime',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_setscheduler',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setresuid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setitimer',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'ioprio_get',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'vfork',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setuid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'llseek',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'io_setup',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mprotect',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mmap_pgoff',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'mremap',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'io_destroy',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mbind',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'preadv64v2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'readv',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'prctl',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'move_pages',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'timerfd_create',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'fstatfs',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'modify_ldt',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getgroups',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'fstatfs64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'dup2', 'reason': set([('list_head', 'prev')])},
+                     {'call': 'get_curr_temp',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'msgsnd',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'write',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'munlock',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setpriority',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'inotify_init1',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mincore',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'sendfile',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'timer_getoverrun',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'kexec_load',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'clone',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'mq_open',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'setgroups',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'unlinkat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_getparam',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'io_cancel',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'open_by_handle_at',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'bind',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'flistxattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'finit_module',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sendfile64',
+                      'reason': set([('fd', 'file'),
+                                     ('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'mlockall',
+                      'reason': set([('list_head', 'prev')])}],
+ 'pivot_root': [{'call': 'eventfd2',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'mq_unlink',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'swapoff',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'pivot_root',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent'),
+                                ('mount', 'mnt_ns'),
+                                ('mount', 'mnt_parent'),
+                                ('path', 'dentry'),
+                                ('path', 'mnt'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'memfd_create',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'dup3',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'unshare',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'umount',
+                 'reason': set([('mount', 'mnt_ns'),
+                                ('mount', 'mnt_parent'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'mkdirat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'epoll_ctl',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'flock',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'openat',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'lookup_dcookie',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'uselib',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'renameat2',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'accept4',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'socketpair',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'getcwd',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent'),
+                                ('mount', 'mnt_ns'),
+                                ('mount', 'mnt_parent'),
+                                ('path', 'dentry'),
+                                ('path', 'mnt'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'ftruncate',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'shmat',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'mknodat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'socket',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'symlinkat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'pipe2',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'linkat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'shmdt',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'quotactl',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'acct',
+                 'reason': set([('path', 'dentry'),
+                                ('path', 'mnt'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'open',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'unlink',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'rmdir',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'dup',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'setns',
+                 'reason': set([('nsproxy', 'mnt_ns'),
+                                ('path', 'dentry'),
+                                ('path', 'mnt')])},
+                {'call': 'shmctl',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'swapon',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'mmap_pgoff',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'mq_open',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent'),
+                                ('path', 'dentry'),
+                                ('path', 'mnt'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'unlinkat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'pkey_alloc': [{'call': 'swapoff',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'pkey_alloc',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_getevents',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'pkey_free',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'shmdt',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'brk',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_setup',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'mremap',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_destroy',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'mbind',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'prctl',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'modify_ldt',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'mincore',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_cancel',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])}],
+ 'pkey_mprotect': [{'call': 'keyctl',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'kill',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'personality',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'remap_file_pages',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'shmdt',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'brk',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'getpriority',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'fork',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'get_mempolicy',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'munlockall',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'pkey_mprotect',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'madvise',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mprotect',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'mremap',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality'),
+                                   ('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'munlock',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'setpriority',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mincore',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mlockall',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])}],
+ 'poll': [{'call': 'poll', 'reason': set([('poll_list', 'len')])},
+          {'call': 'ppoll', 'reason': set([('poll_list', 'len')])}],
+ 'ppoll': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'swapoff',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchmod',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'memfd_create',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'readlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'io_getevents',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchown',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'utime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'settimeofday',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'pselect6',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'uselib',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchmodat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ftruncate',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioctl',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'linkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'stime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'futimesat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'poll',
+            'reason': set([('poll_list', 'len'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'select',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'nanosleep',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'faccessat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'swapon',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'epoll_wait',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchownat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getrusage',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fstat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'move_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_notify',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'newfstat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'clock_nanosleep',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'unlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'futex',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'recvmmsg',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile64',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ppoll',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('poll_list', 'len'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])}],
+ 'prctl': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'kill',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'swapoff', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'remap_file_pages',
+            'reason': set([('mm_struct', 'flags')])},
+           {'call': 'io_getevents', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'migrate_pages',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'shmdt', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'brk', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setns',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'fork',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'get_mempolicy', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getrusage',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'vfork',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+           {'call': 'io_setup', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'mremap', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'io_destroy', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'mbind', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'prctl',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'move_pages',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'modify_ldt', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'mincore', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'clone',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'io_cancel', 'reason': set([('mm_struct', 'flags')])}],
+ 'pread64': [{'call': 'syncfs',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'vmsplice',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fremovexattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'readahead',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'getdents',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'writev',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'preadv64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fchmod',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'pread64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'signalfd4',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'read',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fchown',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'utime',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fsync',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'bpf',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'recvfrom',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fsetxattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'sendto',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'tee',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'sync_file_range',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'lseek',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'connect',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'getsockname',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'epoll_ctl',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('file', 'f_mode')])},
+             {'call': 'flock',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('file', 'f_mode')])},
+             {'call': 'pwritev',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fchdir',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('file', 'f_mode')])},
+             {'call': 'old_readdir',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'inotify_rm_watch',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'utimensat',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'inotify_add_watch',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'preadv2',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'splice',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'ftruncate',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'preadv',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'getpeername',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setsockopt',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'ioctl',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'pwrite64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'perf_event_open',
+              'reason': set([('fd', 'file'),
+                             ('fd', 'flags'),
+                             ('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64v2',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'futimesat',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'pwritev2',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'shutdown',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getsockopt',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_getsetattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fdatasync',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getdents64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'listen',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'copy_file_range',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fgetxattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fallocate',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'epoll_wait',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'llseek',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'preadv64v2',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'readv',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fstatfs',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'fstatfs64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'write',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_notify',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'sendfile',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'bind',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'flistxattr',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])},
+             {'call': 'sendfile64',
+              'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'preadv': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+            {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+            {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+            {'call': 'readahead', 'reason': set([('fd', 'file')])},
+            {'call': 'getdents', 'reason': set([('fd', 'file')])},
+            {'call': 'writev', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+            {'call': 'pread64', 'reason': set([('fd', 'file')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+            {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+            {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+            {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+            {'call': 'read', 'reason': set([('fd', 'file')])},
+            {'call': 'fchown', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+            {'call': 'utime', 'reason': set([('fd', 'file')])},
+            {'call': 'fsync', 'reason': set([('fd', 'file')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'sendto', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+            {'call': 'tee', 'reason': set([('fd', 'file')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+            {'call': 'lseek', 'reason': set([('fd', 'file')])},
+            {'call': 'connect', 'reason': set([('fd', 'file')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+            {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+            {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+            {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+            {'call': 'splice', 'reason': set([('fd', 'file')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv', 'reason': set([('fd', 'file')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+            {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+            {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+            {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+            {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+            {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+            {'call': 'open', 'reason': set([('file', 'f_mode')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+            {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+            {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+            {'call': 'listen', 'reason': set([('fd', 'file')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+            {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+            {'call': 'llseek', 'reason': set([('fd', 'file')])},
+            {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+            {'call': 'readv', 'reason': set([('fd', 'file')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+            {'call': 'write', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('file', 'f_mode')])},
+            {'call': 'bind', 'reason': set([('fd', 'file')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'preadv2': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+             {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+             {'call': 'readahead', 'reason': set([('fd', 'file')])},
+             {'call': 'getdents', 'reason': set([('fd', 'file')])},
+             {'call': 'writev', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+             {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+             {'call': 'pread64', 'reason': set([('fd', 'file')])},
+             {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'read', 'reason': set([('fd', 'file')])},
+             {'call': 'fchown', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+             {'call': 'utime', 'reason': set([('fd', 'file')])},
+             {'call': 'fsync', 'reason': set([('fd', 'file')])},
+             {'call': 'bpf', 'reason': set([('fd', 'file')])},
+             {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+             {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendto', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'tee', 'reason': set([('fd', 'file')])},
+             {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'lseek', 'reason': set([('fd', 'file')])},
+             {'call': 'connect', 'reason': set([('fd', 'file')])},
+             {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_ctl',
+              'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+             {'call': 'flock',
+              'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+             {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+             {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4',
+              'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+             {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+             {'call': 'splice', 'reason': set([('fd', 'file')])},
+             {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv', 'reason': set([('fd', 'file')])},
+             {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+             {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+             {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+             {'call': 'perf_event_open',
+              'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+             {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+             {'call': 'listen', 'reason': set([('fd', 'file')])},
+             {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+             {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+             {'call': 'llseek', 'reason': set([('fd', 'file')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'readv', 'reason': set([('fd', 'file')])},
+             {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+             {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+             {'call': 'write', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'bind', 'reason': set([('fd', 'file')])},
+             {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'preadv64': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+              {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+              {'call': 'readahead', 'reason': set([('fd', 'file')])},
+              {'call': 'getdents', 'reason': set([('fd', 'file')])},
+              {'call': 'writev', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+              {'call': 'pread64', 'reason': set([('fd', 'file')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'read', 'reason': set([('fd', 'file')])},
+              {'call': 'fchown', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+              {'call': 'utime', 'reason': set([('fd', 'file')])},
+              {'call': 'fsync', 'reason': set([('fd', 'file')])},
+              {'call': 'bpf', 'reason': set([('fd', 'file')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendto', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'tee', 'reason': set([('fd', 'file')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'lseek', 'reason': set([('fd', 'file')])},
+              {'call': 'connect', 'reason': set([('fd', 'file')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+              {'call': 'splice', 'reason': set([('fd', 'file')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv', 'reason': set([('fd', 'file')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+              {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+              {'call': 'listen', 'reason': set([('fd', 'file')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+              {'call': 'llseek', 'reason': set([('fd', 'file')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'readv', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+              {'call': 'write', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'bind', 'reason': set([('fd', 'file')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'preadv64v2': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+                {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                {'call': 'writev', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+                {'call': 'read', 'reason': set([('fd', 'file')])},
+                {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+                {'call': 'utime', 'reason': set([('fd', 'file')])},
+                {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'tee', 'reason': set([('fd', 'file')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+                {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                {'call': 'connect', 'reason': set([('fd', 'file')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_ctl',
+                 'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                {'call': 'flock',
+                 'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+                {'call': 'accept4',
+                 'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'file')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                {'call': 'splice', 'reason': set([('fd', 'file')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+                {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+                {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                {'call': 'listen', 'reason': set([('fd', 'file')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                {'call': 'readv', 'reason': set([('fd', 'file')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                {'call': 'write', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'bind', 'reason': set([('fd', 'file')])},
+                {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'prlimit64': [{'call': 'keyctl',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'msgrcv',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'kill',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setgid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'ioprio_set',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'getppid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'capget',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'signal',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setreuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'umount',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'epoll_create1',
+                'reason': set([('cred', 'user_ns')])},
+               {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setsid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'migrate_pages',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setpgid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setresgid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'setregid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'getsid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'old_getrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'prlimit64',
+                'reason': set([('cred', 'user_ns'),
+                               ('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max'),
+                               ('rlimit64', 'rlim_cur'),
+                               ('rlimit64', 'rlim_max'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getpgid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getpriority',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'faccessat', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setns',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'fork',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ptrace',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setresuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ioprio_get',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'vfork',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'prctl',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setpriority',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'clone',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])}],
+ 'pselect6': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'swapoff',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchmod',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'memfd_create',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ioprio_set',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'readlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'io_getevents',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchown',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'utime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'semtimedop',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'settimeofday',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'pselect6',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'uselib',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaltstack',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchmodat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'inotify_add_watch',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ftruncate',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ioctl',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'perf_event_open',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'linkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'stime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'futimesat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'poll',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'select',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'nanosleep',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'faccessat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'get_robust_list',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'swapon',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'epoll_wait',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchownat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fstat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ioprio_get',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_notify',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'newfstat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'clock_nanosleep',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'futex',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'recvmmsg',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile64',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ppoll',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])}],
+ 'ptrace': [{'call': 'keyctl',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'kill',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'pause', 'reason': set([('task_struct', 'state')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'ioprio_set',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigsuspend',
+             'reason': set([('task_struct', 'state')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'prlimit64',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'fork',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'ptrace',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'epoll_wait', 'reason': set([('task_struct', 'state')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getrusage',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'ioprio_get',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'prctl',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'move_pages',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sigsuspend', 'reason': set([('task_struct', 'state')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])}],
+ 'pwrite64': [{'call': 'syncfs',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'vmsplice',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fremovexattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'readahead',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getdents',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'writev',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fchmod',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'pread64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'signalfd4',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'read',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fchown',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'utime',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fsync',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'bpf',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'recvfrom',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fsetxattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sendto',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'tee',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sync_file_range',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'lseek',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'connect',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getsockname',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('file', 'f_mode')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('file', 'f_mode')])},
+              {'call': 'pwritev',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fchdir',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('file', 'f_mode')])},
+              {'call': 'old_readdir',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'inotify_rm_watch',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'utimensat',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'inotify_add_watch',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'splice',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'ftruncate',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getpeername',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setsockopt',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'ioctl',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'pwrite64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64v2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'futimesat',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'pwritev2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'shutdown',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getsockopt',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fdatasync',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getdents64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'listen',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'copy_file_range',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fgetxattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fallocate',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'epoll_wait',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'llseek',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'preadv64v2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'readv',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fstatfs',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fstatfs64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'write',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_notify',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sendfile',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'bind',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'flistxattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sendfile64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'pwritev': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+             {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+             {'call': 'readahead', 'reason': set([('fd', 'file')])},
+             {'call': 'getdents', 'reason': set([('fd', 'file')])},
+             {'call': 'writev', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+             {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+             {'call': 'pread64', 'reason': set([('fd', 'file')])},
+             {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'read', 'reason': set([('fd', 'file')])},
+             {'call': 'fchown', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+             {'call': 'utime', 'reason': set([('fd', 'file')])},
+             {'call': 'fsync', 'reason': set([('fd', 'file')])},
+             {'call': 'bpf', 'reason': set([('fd', 'file')])},
+             {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+             {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendto', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'tee', 'reason': set([('fd', 'file')])},
+             {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'lseek', 'reason': set([('fd', 'file')])},
+             {'call': 'connect', 'reason': set([('fd', 'file')])},
+             {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_ctl',
+              'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+             {'call': 'flock',
+              'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+             {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+             {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4',
+              'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+             {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+             {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+             {'call': 'splice', 'reason': set([('fd', 'file')])},
+             {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+             {'call': 'preadv', 'reason': set([('fd', 'file')])},
+             {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+             {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+             {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+             {'call': 'perf_event_open',
+              'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+             {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+             {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+             {'call': 'listen', 'reason': set([('fd', 'file')])},
+             {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+             {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+             {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+             {'call': 'llseek', 'reason': set([('fd', 'file')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+             {'call': 'readv', 'reason': set([('fd', 'file')])},
+             {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+             {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+             {'call': 'write', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'bind', 'reason': set([('fd', 'file')])},
+             {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+             {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'pwritev2': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+              {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+              {'call': 'readahead', 'reason': set([('fd', 'file')])},
+              {'call': 'getdents', 'reason': set([('fd', 'file')])},
+              {'call': 'writev', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+              {'call': 'pread64', 'reason': set([('fd', 'file')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'read', 'reason': set([('fd', 'file')])},
+              {'call': 'fchown', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+              {'call': 'utime', 'reason': set([('fd', 'file')])},
+              {'call': 'fsync', 'reason': set([('fd', 'file')])},
+              {'call': 'bpf', 'reason': set([('fd', 'file')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendto', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'tee', 'reason': set([('fd', 'file')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'lseek', 'reason': set([('fd', 'file')])},
+              {'call': 'connect', 'reason': set([('fd', 'file')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+              {'call': 'splice', 'reason': set([('fd', 'file')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv', 'reason': set([('fd', 'file')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+              {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+              {'call': 'listen', 'reason': set([('fd', 'file')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+              {'call': 'llseek', 'reason': set([('fd', 'file')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'readv', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+              {'call': 'write', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'bind', 'reason': set([('fd', 'file')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'pwritev64': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+               {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+               {'call': 'readahead', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents', 'reason': set([('fd', 'file')])},
+               {'call': 'writev', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+               {'call': 'pread64', 'reason': set([('fd', 'file')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+               {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+               {'call': 'read', 'reason': set([('fd', 'file')])},
+               {'call': 'fchown', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+               {'call': 'utime', 'reason': set([('fd', 'file')])},
+               {'call': 'fsync', 'reason': set([('fd', 'file')])},
+               {'call': 'bpf', 'reason': set([('fd', 'file')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'sendto', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+               {'call': 'tee', 'reason': set([('fd', 'file')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'lseek', 'reason': set([('fd', 'file')])},
+               {'call': 'connect', 'reason': set([('fd', 'file')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+               {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+               {'call': 'splice', 'reason': set([('fd', 'file')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv', 'reason': set([('fd', 'file')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+               {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+               {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+               {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+               {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+               {'call': 'listen', 'reason': set([('fd', 'file')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+               {'call': 'llseek', 'reason': set([('fd', 'file')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'readv', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+               {'call': 'write', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'bind', 'reason': set([('fd', 'file')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'pwritev64v2': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                 {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                 {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                 {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                 {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                 {'call': 'writev', 'reason': set([('fd', 'file')])},
+                 {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                 {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                 {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                 {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                 {'call': 'memfd_create',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'remap_file_pages',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'read', 'reason': set([('fd', 'file')])},
+                 {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+                 {'call': 'utime', 'reason': set([('fd', 'file')])},
+                 {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                 {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                 {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                 {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                 {'call': 'epoll_create1',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'tee', 'reason': set([('fd', 'file')])},
+                 {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+                 {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                 {'call': 'connect', 'reason': set([('fd', 'file')])},
+                 {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                 {'call': 'epoll_ctl',
+                  'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                 {'call': 'flock',
+                  'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                 {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                 {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                 {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'accept4',
+                  'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                 {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                 {'call': 'inotify_rm_watch',
+                  'reason': set([('fd', 'file')])},
+                 {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                 {'call': 'inotify_add_watch',
+                  'reason': set([('fd', 'file')])},
+                 {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                 {'call': 'splice', 'reason': set([('fd', 'file')])},
+                 {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                 {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                 {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                 {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                 {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                 {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                 {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                 {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                 {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                 {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                 {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'open', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                 {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                 {'call': 'listen', 'reason': set([('fd', 'file')])},
+                 {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+                 {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                 {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                 {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                 {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                 {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                 {'call': 'readv', 'reason': set([('fd', 'file')])},
+                 {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                 {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                 {'call': 'write', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+                 {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                 {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'open_by_handle_at',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'bind', 'reason': set([('fd', 'file')])},
+                 {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                 {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'quotactl': [{'call': 'syncfs',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_qcop'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'sysfs', 'reason': set([('filename', 'name')])},
+              {'call': 'mq_unlink', 'reason': set([('filename', 'name')])},
+              {'call': 'swapoff', 'reason': set([('filename', 'name')])},
+              {'call': 'ustat',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_qcop'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'umount',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_qcop'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'openat', 'reason': set([('filename', 'name')])},
+              {'call': 'uselib', 'reason': set([('filename', 'name')])},
+              {'call': 'renameat2', 'reason': set([('filename', 'name')])},
+              {'call': 'symlinkat', 'reason': set([('filename', 'name')])},
+              {'call': 'quotactl',
+               'reason': set([('filename', 'name'),
+                              ('super_block', 's_flags'),
+                              ('super_block', 's_qcop'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'acct', 'reason': set([('filename', 'name')])},
+              {'call': 'open', 'reason': set([('filename', 'name')])},
+              {'call': 'unlink', 'reason': set([('filename', 'name')])},
+              {'call': 'rmdir', 'reason': set([('filename', 'name')])},
+              {'call': 'swapon',
+               'reason': set([('filename', 'name'),
+                              ('super_block', 's_flags'),
+                              ('super_block', 's_qcop'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'mq_open', 'reason': set([('filename', 'name')])},
+              {'call': 'unlinkat', 'reason': set([('filename', 'name')])}],
+ 'read': [{'call': 'syncfs',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'vmsplice',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'pwritev64',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fremovexattr',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'readahead',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'getdents',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'writev',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'preadv64',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fchmod',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'pread64',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'signalfd4',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'read', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fchown',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'mq_timedreceive',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'utime', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fsync', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'recvfrom',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fsetxattr',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'sendto',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'sync_file_range',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'lseek', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'connect',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'getsockname',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'epoll_ctl',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'flock', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'pwritev',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fchdir',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'accept4',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'old_readdir',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'inotify_rm_watch',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'utimensat',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'inotify_add_watch',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'preadv2',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'splice',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'ftruncate',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'preadv',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'getpeername',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'setsockopt',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fcntl', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'ioctl', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'pwrite64',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'perf_event_open',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'pwritev64v2',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'futimesat',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'pwritev2',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'shutdown',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'getsockopt',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'mq_getsetattr',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fdatasync',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'getdents64',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'listen',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'copy_file_range',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'mq_timedsend',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fgetxattr',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fcntl64',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fallocate',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'epoll_wait',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'llseek',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'preadv64v2',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'readv', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fstatfs',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'fstatfs64',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'write', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'mq_notify',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'sendfile',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'bind', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'flistxattr',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])},
+          {'call': 'sendfile64',
+           'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'readahead': [{'call': 'syncfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'vmsplice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'mq_unlink',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'pwritev64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'swapoff',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'fremovexattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readahead',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'getdents',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'writev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchmod',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'pread64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'signalfd4',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'memfd_create',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+               {'call': 'readlinkat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'read',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchown',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'utime',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'bpf',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'recvfrom',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendto',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+               {'call': 'tee',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sync_file_range',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'lseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'connect',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsockname',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_mode')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_mode')])},
+               {'call': 'pwritev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'uselib',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_mode')])},
+               {'call': 'old_readdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_rm_watch',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+               {'call': 'utimensat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchmodat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'preadv2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'splice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ftruncate',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'preadv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getpeername',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shmat',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'setsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fcntl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ioctl',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'pwrite64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_mode')])},
+               {'call': 'linkat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pwritev64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'futimesat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shutdown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'unlink',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'getsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'faccessat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fdatasync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+               {'call': 'getdents64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'listen',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'copy_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'fgetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fcntl64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'swapon',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'fallocate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_wait',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchownat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'llseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'preadv64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'write',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_notify',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'sendfile',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'unlinkat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'bind',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'flistxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendfile64',
+                'reason': set([('address_space', 'a_ops'),
+                               ('fd', 'file'),
+                               ('fd', 'flags')])}],
+ 'readlinkat': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+                {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+                {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+                {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+                {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+                {'call': 'flock', 'reason': set([('path', 'dentry')])},
+                {'call': 'openat', 'reason': set([('path', 'dentry')])},
+                {'call': 'lookup_dcookie',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+                {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+                {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+                {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+                {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+                {'call': 'socket', 'reason': set([('path', 'dentry')])},
+                {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+                {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+                {'call': 'acct', 'reason': set([('path', 'dentry')])},
+                {'call': 'open', 'reason': set([('path', 'dentry')])},
+                {'call': 'dup', 'reason': set([('path', 'dentry')])},
+                {'call': 'setns', 'reason': set([('path', 'dentry')])},
+                {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+                {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+                {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+                {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('path', 'dentry')])}],
+ 'readv': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+           {'call': 'readahead', 'reason': set([('fd', 'file')])},
+           {'call': 'getdents', 'reason': set([('fd', 'file')])},
+           {'call': 'writev', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+           {'call': 'pread64', 'reason': set([('fd', 'file')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+           {'call': 'read', 'reason': set([('fd', 'file')])},
+           {'call': 'fchown', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+           {'call': 'utime', 'reason': set([('fd', 'file')])},
+           {'call': 'fsync', 'reason': set([('fd', 'file')])},
+           {'call': 'bpf', 'reason': set([('fd', 'file')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+           {'call': 'sendto', 'reason': set([('fd', 'file')])},
+           {'call': 'tee', 'reason': set([('fd', 'file')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+           {'call': 'lseek', 'reason': set([('fd', 'file')])},
+           {'call': 'connect', 'reason': set([('fd', 'file')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+           {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+           {'call': 'flock', 'reason': set([('fd', 'file')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+           {'call': 'accept4', 'reason': set([('fd', 'file')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+           {'call': 'splice', 'reason': set([('fd', 'file')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv', 'reason': set([('fd', 'file')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+           {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+           {'call': 'listen', 'reason': set([('fd', 'file')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+           {'call': 'llseek', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+           {'call': 'readv', 'reason': set([('fd', 'file')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+           {'call': 'write', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+           {'call': 'bind', 'reason': set([('fd', 'file')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'reboot': [{'call': 'reboot', 'reason': set([('pid_namespace', 'user_ns')])},
+            {'call': 'perf_event_open',
+             'reason': set([('pid_namespace', 'user_ns')])},
+            {'call': 'acct', 'reason': set([('pid_namespace', 'user_ns')])},
+            {'call': 'setns', 'reason': set([('pid_namespace', 'user_ns')])}],
+ 'recvfrom': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+              {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_flags')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_flags')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+              {'call': 'readahead', 'reason': set([('fd', 'file')])},
+              {'call': 'getdents', 'reason': set([('fd', 'file')])},
+              {'call': 'writev', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+              {'call': 'pread64', 'reason': set([('fd', 'file')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_flags')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_flags')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_flags')])},
+              {'call': 'read', 'reason': set([('fd', 'file')])},
+              {'call': 'fchown', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+              {'call': 'utime', 'reason': set([('fd', 'file')])},
+              {'call': 'fsync', 'reason': set([('fd', 'file')])},
+              {'call': 'bpf', 'reason': set([('fd', 'file')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendto', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_flags')])},
+              {'call': 'tee', 'reason': set([('fd', 'file')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'lseek', 'reason': set([('fd', 'file')])},
+              {'call': 'connect', 'reason': set([('fd', 'file')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+              {'call': 'openat', 'reason': set([('file', 'f_flags')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_flags')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_flags')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+              {'call': 'splice', 'reason': set([('fd', 'file')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv', 'reason': set([('fd', 'file')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_flags')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'socket', 'reason': set([('file', 'f_flags')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_flags')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+              {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_flags')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+              {'call': 'acct', 'reason': set([('file', 'f_flags')])},
+              {'call': 'open', 'reason': set([('file', 'f_flags')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+              {'call': 'dup', 'reason': set([('file', 'f_flags')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+              {'call': 'setns', 'reason': set([('file', 'f_flags')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+              {'call': 'listen', 'reason': set([('fd', 'file')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_flags')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_flags')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+              {'call': 'llseek', 'reason': set([('fd', 'file')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_flags')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'readv', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+              {'call': 'write', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_flags')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_flags')])},
+              {'call': 'bind', 'reason': set([('fd', 'file')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'recvmmsg': [{'call': 'rt_sigtimedwait',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'swapoff',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchmod',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'memfd_create',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'readlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'io_getevents',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchown',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'utime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'semtimedop',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'recvfrom',
+               'reason': set([('msghdr', 'msg_flags'),
+                              ('socket', 'file'),
+                              ('socket', 'sk')])},
+              {'call': 'settimeofday',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendto',
+               'reason': set([('msghdr', 'msg_flags'),
+                              ('socket', 'file'),
+                              ('socket', 'sk')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'connect',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'getsockname',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'pselect6',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'uselib',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'accept4',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'fchmodat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'inotify_add_watch',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ftruncate',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getpeername',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'setsockopt',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'ioctl',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'linkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendmsg',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'stime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'futimesat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'shutdown',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'poll',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'select',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getsockopt',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'nanosleep',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'faccessat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'listen',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'swapon',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'epoll_wait',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchownat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fstat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'recvmsg',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'mq_notify',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendmmsg',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'newfstat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'clock_nanosleep',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'bind',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'futex',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'recvmmsg',
+               'reason': set([('socket', 'file'),
+                              ('socket', 'sk'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile64',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ppoll',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])}],
+ 'recvmsg': [{'call': 'recvfrom', 'reason': set([('socket', 'file')])},
+             {'call': 'sendto', 'reason': set([('socket', 'file')])},
+             {'call': 'connect', 'reason': set([('socket', 'file')])},
+             {'call': 'getsockname', 'reason': set([('socket', 'file')])},
+             {'call': 'accept4', 'reason': set([('socket', 'file')])},
+             {'call': 'getpeername', 'reason': set([('socket', 'file')])},
+             {'call': 'setsockopt', 'reason': set([('socket', 'file')])},
+             {'call': 'sendmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'shutdown', 'reason': set([('socket', 'file')])},
+             {'call': 'getsockopt', 'reason': set([('socket', 'file')])},
+             {'call': 'listen', 'reason': set([('socket', 'file')])},
+             {'call': 'recvmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'sendmmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'bind', 'reason': set([('socket', 'file')])},
+             {'call': 'recvmmsg', 'reason': set([('socket', 'file')])}],
+ 'remap_file_pages': [{'call': 'remap_file_pages',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'shmdt',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'brk',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'get_mempolicy',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'munlockall',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'pkey_mprotect',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'madvise',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mprotect',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mremap',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'prctl',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'munlock',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mincore',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mlockall',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])}],
+ 'removexattr': [{'call': 'eventfd2',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'swapoff',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'pivot_root',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'memfd_create',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'remap_file_pages',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'dup3',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'unshare',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'epoll_create1',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'epoll_ctl',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'flock',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'openat',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'lookup_dcookie',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'uselib',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'accept4',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'socketpair',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'getcwd',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'shmat',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'socket',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'pipe2',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'shmdt',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'quotactl',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'acct',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'open',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'dup',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'setns',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'shmctl',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'swapon',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'mmap_pgoff',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'mq_open',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'open_by_handle_at',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'renameat2': [{'call': 'sysfs',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'eventfd2',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mq_unlink',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapoff',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'pivot_root',
+                'reason': set([('dentry', 'd_inode'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'memfd_create',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'dup3',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'unshare',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mkdirat', 'reason': set([('dentry', 'd_inode')])},
+               {'call': 'epoll_create1',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'flock',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'openat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'uselib',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'renameat2',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'accept4',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'socketpair',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'getcwd',
+                'reason': set([('dentry', 'd_inode'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'ftruncate', 'reason': set([('dentry', 'd_inode')])},
+               {'call': 'shmat',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mknodat', 'reason': set([('dentry', 'd_inode')])},
+               {'call': 'socket',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'symlinkat',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'pipe2',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'linkat', 'reason': set([('dentry', 'd_inode')])},
+               {'call': 'shmdt',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'quotactl',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'acct',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'unlink',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'rmdir',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'dup',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'setns',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'shmctl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'swapon',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'mmap_pgoff',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mq_open',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'unlinkat',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'rmdir': [{'call': 'eventfd2',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mq_unlink', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'swapoff',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'pivot_root',
+            'reason': set([('dentry', 'd_inode'),
+                           ('path', 'dentry'),
+                           ('path', 'mnt')])},
+           {'call': 'memfd_create',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'remap_file_pages',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'dup3',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'unshare',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mkdirat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'epoll_create1',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'flock',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'openat',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'lookup_dcookie',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'uselib',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'renameat2', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'accept4',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'socketpair',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'getcwd',
+            'reason': set([('dentry', 'd_inode'),
+                           ('path', 'dentry'),
+                           ('path', 'mnt')])},
+           {'call': 'ftruncate', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'shmat',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mknodat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'socket',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'symlinkat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'pipe2',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'perf_event_open',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'linkat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'shmdt',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'quotactl',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'acct',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'open',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'unlink', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'rmdir', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'dup',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'setns',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'shmctl',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'swapon',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mmap_pgoff',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mq_open',
+            'reason': set([('dentry', 'd_inode'),
+                           ('path', 'dentry'),
+                           ('path', 'mnt')])},
+           {'call': 'unlinkat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'open_by_handle_at',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'rt_sigqueueinfo': [{'call': 'rt_sigtimedwait',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'kill',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'timer_create',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'rt_sigqueueinfo',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'tgkill',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'rt_tgsigqueueinfo',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'rt_sigreturn',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'tkill',
+                      'reason': set([('siginfo', 'si_code')])}],
+ 'rt_sigreturn': [{'call': 'keyctl',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigtimedwait',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'msgrcv',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'kill',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getaffinity',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setparam',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ioprio_set',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getppid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ioperm',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'capget',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setaffinity',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'signal',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'semtimedop',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'umount',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_rr_get_interval',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigprocmask',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setsid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sigaltstack',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setattr',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'migrate_pages',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getitimer',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setpgid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getsid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'prlimit64',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigaction',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getpgid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getpriority',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sigaction',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setns',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'fork',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'get_robust_list',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getscheduler',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ptrace',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getattr',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getrusage',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setscheduler',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setitimer',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ioprio_get',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'vfork',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'prctl',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'move_pages',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigreturn',
+                   'reason': set([('thread_struct', 'uaccess_err')])},
+                  {'call': 'setpriority',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'clone',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getparam',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])}],
+ 'rt_sigtimedwait': [{'call': 'keyctl',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigtimedwait',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'msgrcv',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'kill',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getaffinity',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setparam',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ioprio_set',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getppid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ioperm',
+                      'reason': set([('mm_segment_t', 'seg')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'capget',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setaffinity',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'signal',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'umount',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'timer_create',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigqueueinfo',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'tgkill',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'rt_sigprocmask',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'setsid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sigaltstack',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setattr',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'migrate_pages',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getitimer',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'setpgid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getsid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'prlimit64',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigaction',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getpgid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getpriority',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sigaction',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_tgsigqueueinfo',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'setns',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'fork',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'get_robust_list',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getscheduler',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ptrace',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getattr',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getrusage',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setscheduler',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'setitimer',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ioprio_get',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'vfork',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'prctl',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'move_pages',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigreturn',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'tkill',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'setpriority',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'clone',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getparam',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])}],
+ 'rt_tgsigqueueinfo': [{'call': 'rt_sigtimedwait',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'kill',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'timer_create',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'rt_sigqueueinfo',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'tgkill',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'rt_tgsigqueueinfo',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'rt_sigreturn',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'tkill',
+                        'reason': set([('siginfo', 'si_code')])}],
+ 'sched_getattr': [{'call': 'keyctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'kill',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getppid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ioperm',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'capget',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'signal',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'umount',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('sched_attr', 'size'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setns',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'fork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ptrace',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('sched_attr', 'size'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getrusage',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'vfork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'prctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'move_pages',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'clone',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])}],
+ 'sched_getparam': [{'call': 'keyctl',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'rt_sigtimedwait',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'msgrcv',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'kill',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getaffinity',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setparam',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'ioprio_set',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getppid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'mq_timedreceive',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'capget',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setaffinity',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'signal',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'semtimedop',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'umount',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_rr_get_interval',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'rt_sigprocmask',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setsid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sigaltstack',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setattr',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'migrate_pages',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getitimer',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setpgid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getsid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'prlimit64',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'perf_event_open',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'rt_sigaction',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getpgid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getpriority',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sigaction',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setns',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'fork',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'get_robust_list',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'mq_timedsend',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getscheduler',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'ptrace',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getattr',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getrusage',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setscheduler',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setitimer',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'ioprio_get',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'vfork',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'prctl',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'move_pages',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setpriority',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'clone',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getparam',
+                     'reason': set([('task_struct', 'policy')])}],
+ 'sched_getscheduler': [{'call': 'keyctl',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'rt_sigtimedwait',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'msgrcv',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'kill',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getaffinity',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setparam',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'ioprio_set',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getppid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'mq_timedreceive',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'capget',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setaffinity',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'signal',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'semtimedop',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'umount',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_rr_get_interval',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'rt_sigprocmask',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setsid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sigaltstack',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setattr',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'migrate_pages',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getitimer',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setpgid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getsid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'prlimit64',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'perf_event_open',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'rt_sigaction',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getpgid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getpriority',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sigaction',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setns',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'fork',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'get_robust_list',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'mq_timedsend',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getscheduler',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'ptrace',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getattr',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getrusage',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setscheduler',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setitimer',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'ioprio_get',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'vfork',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'prctl',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'move_pages',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setpriority',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'clone',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getparam',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])}],
+ 'sched_rr_get_interval': [{'call': 'sched_rr_get_interval',
+                            'reason': set([('rq_flags', 'flags')])}],
+ 'sched_setaffinity': [{'call': 'keyctl',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'rt_sigtimedwait',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setfsuid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'msgrcv',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'kill',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getresuid16',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'getresgid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'sched_getaffinity',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_setparam',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setgid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'ioprio_set',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'capset',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'getppid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'mq_timedreceive',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getresgid16',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'capget',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_setaffinity',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setfsgid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'unshare',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'signal',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setreuid',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags')])},
+                       {'call': 'semtimedop',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'umount',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_rr_get_interval',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'epoll_create1',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'getresuid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'rt_sigprocmask',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setsid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sigaltstack',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_setattr',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'migrate_pages',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getitimer',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setpgid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setresgid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'setregid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'getsid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'prlimit64',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getgroups16',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'rt_sigaction',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getpgid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getpriority',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sigaction',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'faccessat',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'setns',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'fork',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'get_robust_list',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'mq_timedsend',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_getscheduler',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'ptrace',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_getattr',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getrusage',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_setscheduler',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setresuid',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags')])},
+                       {'call': 'setitimer',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'ioprio_get',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'vfork',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setuid',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags')])},
+                       {'call': 'prctl',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'move_pages',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getgroups',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'setpriority',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'clone',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_getparam',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])}],
+ 'sched_setattr': [{'call': 'keyctl',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getppid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioperm',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'capget',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'signal',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'umount',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setsid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('sched_attr', 'sched_policy')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getitimer',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setpgid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getsid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getpgid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getpriority',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sigaction',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setns',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ptrace',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('sched_attr', 'sched_policy')])},
+                   {'call': 'getrusage',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setitimer',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'vfork',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'prctl',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'move_pages',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setpriority',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'clone',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('mm_segment_t', 'seg')])}],
+ 'select': [{'call': 'keyctl',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_unlink',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'swapoff',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchmod',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'memfd_create',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'ioprio_set',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'personality',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'dup3', 'reason': set([('files_struct', 'fdt')])},
+            {'call': 'readlinkat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'io_getevents',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchown',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'utime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'unshare', 'reason': set([('files_struct', 'fdt')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'settimeofday',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timerfd_gettime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'pselect6',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'uselib',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchmodat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timer_settime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'ftruncate',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timer_gettime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioctl',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'prlimit64',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'linkat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'stime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'futimesat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'poll',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'select',
+             'reason': set([('fd_set_bits', 'ex'),
+                            ('fd_set_bits', 'in'),
+                            ('fd_set_bits', 'out'),
+                            ('fd_set_bits', 'res_ex'),
+                            ('fd_set_bits', 'res_in'),
+                            ('fd_set_bits', 'res_out'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'unlink',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'nanosleep',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'faccessat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ptrace',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'swapon',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'epoll_wait',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchownat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getrusage',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fstat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timerfd_settime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioprio_get',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'prctl',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'move_pages',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'dup2', 'reason': set([('files_struct', 'fdt')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_notify',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sendfile',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'newfstat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'clock_nanosleep',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'unlinkat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'futex',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'recvmmsg',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sendfile64',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'ppoll',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])}],
+ 'semctl': [{'call': 'semtimedop',
+             'reason': set([('sem_array', 'sem_nsems')])},
+            {'call': 'semctl', 'reason': set([('sem_array', 'sem_nsems')])}],
+ 'semtimedop': [{'call': 'syncfs', 'reason': set([('list_head', 'prev')])},
+                {'call': 'keyctl', 'reason': set([('list_head', 'prev')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'vmsplice', 'reason': set([('list_head', 'prev')])},
+                {'call': 'msgrcv',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'eventfd2', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mq_unlink',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'kill', 'reason': set([('list_head', 'prev')])},
+                {'call': 'swapoff',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'readahead', 'reason': set([('list_head', 'prev')])},
+                {'call': 'timer_delete',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'fchmod',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'setgid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'pivot_root',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'memfd_create',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'delete_module',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'dup3', 'reason': set([('list_head', 'prev')])},
+                {'call': 'readlinkat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'io_getevents',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'getppid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'fchown',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'capget', 'reason': set([('list_head', 'prev')])},
+                {'call': 'utime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'ustat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'bpf', 'reason': set([('list_head', 'prev')])},
+                {'call': 'unshare', 'reason': set([('list_head', 'prev')])},
+                {'call': 'signal', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setreuid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'semtimedop',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev'),
+                                ('sem_array', 'complex_count'),
+                                ('sem_array', 'sem_nsems'),
+                                ('sem_array', 'use_global_lock'),
+                                ('sem_queue', 'dupsop'),
+                                ('sem_queue', 'nsops'),
+                                ('sem_undo', 'semid'),
+                                ('sembuf', 'sem_flg'),
+                                ('sembuf', 'sem_num'),
+                                ('sembuf', 'sem_op'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'umount', 'reason': set([('list_head', 'prev')])},
+                {'call': 'settimeofday',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timer_create',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mkdirat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'timerfd_gettime',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'tee', 'reason': set([('list_head', 'prev')])},
+                {'call': 'semctl',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev'),
+                                ('sem_array', 'complex_count'),
+                                ('sem_array', 'sem_nsems'),
+                                ('sem_array', 'use_global_lock'),
+                                ('sem_undo', 'semid')])},
+                {'call': 'sync_file_range',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'epoll_ctl', 'reason': set([('list_head', 'prev')])},
+                {'call': 'flock', 'reason': set([('list_head', 'prev')])},
+                {'call': 'openat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'lookup_dcookie',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'pselect6',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'uselib',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'renameat2', 'reason': set([('list_head', 'prev')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'accept4', 'reason': set([('list_head', 'prev')])},
+                {'call': 'msgctl',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'reboot', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setsid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'set_trip_temp',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'socketpair',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'getitimer', 'reason': set([('list_head', 'prev')])},
+                {'call': 'fchmodat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'setpgid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'init_module',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'setresgid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'getcwd', 'reason': set([('list_head', 'prev')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'get_trip_temp',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'timer_settime',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'setregid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'splice', 'reason': set([('list_head', 'prev')])},
+                {'call': 'ftruncate',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timer_gettime',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'getsid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'shmat',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'mknodat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'socket', 'reason': set([('list_head', 'prev')])},
+                {'call': 'symlinkat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'pipe2', 'reason': set([('list_head', 'prev')])},
+                {'call': 'ioctl',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'prlimit64', 'reason': set([('list_head', 'prev')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'linkat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'stime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'getgroups16',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'shmdt', 'reason': set([('list_head', 'prev')])},
+                {'call': 'quotactl', 'reason': set([('list_head', 'prev')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'futimesat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'request_key',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'getpgid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'brk', 'reason': set([('list_head', 'prev')])},
+                {'call': 'acct', 'reason': set([('list_head', 'prev')])},
+                {'call': 'poll',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'open', 'reason': set([('list_head', 'prev')])},
+                {'call': 'select',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'unlink',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'exit_group',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'getpriority',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sigaction', 'reason': set([('list_head', 'prev')])},
+                {'call': 'nanosleep',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mq_getsetattr',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'faccessat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'rmdir', 'reason': set([('list_head', 'prev')])},
+                {'call': 'dup', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setgroups16',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'setns', 'reason': set([('list_head', 'prev')])},
+                {'call': 'fork', 'reason': set([('list_head', 'prev')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'io_submit', 'reason': set([('list_head', 'prev')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_yield',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'ptrace', 'reason': set([('list_head', 'prev')])},
+                {'call': 'shmctl',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'munlockall',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'swapon',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'pkey_mprotect',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'madvise', 'reason': set([('list_head', 'prev')])},
+                {'call': 'epoll_wait',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'fchownat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'getrusage', 'reason': set([('list_head', 'prev')])},
+                {'call': 'fstat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timerfd_settime',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'setresuid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setitimer', 'reason': set([('list_head', 'prev')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'vfork', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setuid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'io_setup', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mprotect', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mmap_pgoff',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mremap', 'reason': set([('list_head', 'prev')])},
+                {'call': 'io_destroy',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mbind', 'reason': set([('list_head', 'prev')])},
+                {'call': 'prctl', 'reason': set([('list_head', 'prev')])},
+                {'call': 'move_pages',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'timerfd_create',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'modify_ldt',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'getgroups', 'reason': set([('list_head', 'prev')])},
+                {'call': 'dup2', 'reason': set([('list_head', 'prev')])},
+                {'call': 'get_curr_temp',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'msgsnd',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'munlock', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setpriority',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'inotify_init1',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mincore', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mq_notify',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sendfile',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timer_getoverrun',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'newfstat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'kexec_load',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'clone', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mq_open', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setgroups', 'reason': set([('list_head', 'prev')])},
+                {'call': 'clock_nanosleep',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'unlinkat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'io_cancel', 'reason': set([('list_head', 'prev')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'futex',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'recvmmsg',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'finit_module',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sendfile64',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mlockall', 'reason': set([('list_head', 'prev')])},
+                {'call': 'ppoll',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])}],
+ 'sendfile': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+              {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+              {'call': 'readahead', 'reason': set([('fd', 'file')])},
+              {'call': 'getdents', 'reason': set([('fd', 'file')])},
+              {'call': 'writev', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+              {'call': 'pread64', 'reason': set([('fd', 'file')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'read', 'reason': set([('fd', 'file')])},
+              {'call': 'fchown', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+              {'call': 'utime', 'reason': set([('fd', 'file')])},
+              {'call': 'fsync', 'reason': set([('fd', 'file')])},
+              {'call': 'bpf', 'reason': set([('fd', 'file')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendto', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'tee', 'reason': set([('fd', 'file')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'lseek', 'reason': set([('fd', 'file')])},
+              {'call': 'connect', 'reason': set([('fd', 'file')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+              {'call': 'splice', 'reason': set([('fd', 'file')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv', 'reason': set([('fd', 'file')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+              {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+              {'call': 'listen', 'reason': set([('fd', 'file')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+              {'call': 'llseek', 'reason': set([('fd', 'file')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'readv', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+              {'call': 'write', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'bind', 'reason': set([('fd', 'file')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'sendfile64': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+                {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                {'call': 'writev', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+                {'call': 'read', 'reason': set([('fd', 'file')])},
+                {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+                {'call': 'utime', 'reason': set([('fd', 'file')])},
+                {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'tee', 'reason': set([('fd', 'file')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+                {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                {'call': 'connect', 'reason': set([('fd', 'file')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_ctl',
+                 'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                {'call': 'flock',
+                 'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+                {'call': 'accept4',
+                 'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'file')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                {'call': 'splice', 'reason': set([('fd', 'file')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('fd', 'file'), ('file', 'f_mode')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+                {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+                {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                {'call': 'listen', 'reason': set([('fd', 'file')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                {'call': 'readv', 'reason': set([('fd', 'file')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                {'call': 'write', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'bind', 'reason': set([('fd', 'file')])},
+                {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'sendmmsg': [{'call': 'recvfrom', 'reason': set([('socket', 'file')])},
+              {'call': 'sendto', 'reason': set([('socket', 'file')])},
+              {'call': 'connect', 'reason': set([('socket', 'file')])},
+              {'call': 'getsockname', 'reason': set([('socket', 'file')])},
+              {'call': 'accept4', 'reason': set([('socket', 'file')])},
+              {'call': 'getpeername', 'reason': set([('socket', 'file')])},
+              {'call': 'setsockopt', 'reason': set([('socket', 'file')])},
+              {'call': 'sendmsg', 'reason': set([('socket', 'file')])},
+              {'call': 'shutdown', 'reason': set([('socket', 'file')])},
+              {'call': 'getsockopt', 'reason': set([('socket', 'file')])},
+              {'call': 'listen', 'reason': set([('socket', 'file')])},
+              {'call': 'recvmsg', 'reason': set([('socket', 'file')])},
+              {'call': 'sendmmsg', 'reason': set([('socket', 'file')])},
+              {'call': 'bind', 'reason': set([('socket', 'file')])},
+              {'call': 'recvmmsg', 'reason': set([('socket', 'file')])}],
+ 'sendmsg': [{'call': 'recvfrom', 'reason': set([('socket', 'file')])},
+             {'call': 'sendto', 'reason': set([('socket', 'file')])},
+             {'call': 'connect', 'reason': set([('socket', 'file')])},
+             {'call': 'getsockname', 'reason': set([('socket', 'file')])},
+             {'call': 'accept4', 'reason': set([('socket', 'file')])},
+             {'call': 'getpeername', 'reason': set([('socket', 'file')])},
+             {'call': 'setsockopt', 'reason': set([('socket', 'file')])},
+             {'call': 'sendmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'shutdown', 'reason': set([('socket', 'file')])},
+             {'call': 'getsockopt', 'reason': set([('socket', 'file')])},
+             {'call': 'listen', 'reason': set([('socket', 'file')])},
+             {'call': 'recvmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'sendmmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'bind', 'reason': set([('socket', 'file')])},
+             {'call': 'recvmmsg', 'reason': set([('socket', 'file')])}],
+ 'sendto': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+            {'call': 'eventfd2', 'reason': set([('file', 'f_flags')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+            {'call': 'swapoff', 'reason': set([('file', 'f_flags')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+            {'call': 'readahead', 'reason': set([('fd', 'file')])},
+            {'call': 'getdents', 'reason': set([('fd', 'file')])},
+            {'call': 'writev', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+            {'call': 'pread64', 'reason': set([('fd', 'file')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+            {'call': 'memfd_create', 'reason': set([('file', 'f_flags')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('file', 'f_flags')])},
+            {'call': 'dup3', 'reason': set([('file', 'f_flags')])},
+            {'call': 'read', 'reason': set([('fd', 'file')])},
+            {'call': 'fchown', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+            {'call': 'utime', 'reason': set([('fd', 'file')])},
+            {'call': 'fsync', 'reason': set([('fd', 'file')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'sendto', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_create1', 'reason': set([('file', 'f_flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'file')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+            {'call': 'lseek', 'reason': set([('fd', 'file')])},
+            {'call': 'connect', 'reason': set([('fd', 'file')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+            {'call': 'openat', 'reason': set([('file', 'f_flags')])},
+            {'call': 'uselib', 'reason': set([('file', 'f_flags')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+            {'call': 'socketpair', 'reason': set([('file', 'f_flags')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+            {'call': 'splice', 'reason': set([('fd', 'file')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv', 'reason': set([('fd', 'file')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+            {'call': 'shmat', 'reason': set([('file', 'f_flags')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+            {'call': 'socket', 'reason': set([('file', 'f_flags')])},
+            {'call': 'pipe2', 'reason': set([('file', 'f_flags')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+            {'call': 'shmdt', 'reason': set([('file', 'f_flags')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+            {'call': 'acct', 'reason': set([('file', 'f_flags')])},
+            {'call': 'open', 'reason': set([('file', 'f_flags')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('fd', 'file'), ('file', 'f_flags')])},
+            {'call': 'dup', 'reason': set([('file', 'f_flags')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+            {'call': 'setns', 'reason': set([('file', 'f_flags')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+            {'call': 'listen', 'reason': set([('fd', 'file')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'shmctl', 'reason': set([('file', 'f_flags')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+            {'call': 'swapon', 'reason': set([('file', 'f_flags')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+            {'call': 'llseek', 'reason': set([('fd', 'file')])},
+            {'call': 'mmap_pgoff', 'reason': set([('file', 'f_flags')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+            {'call': 'readv', 'reason': set([('fd', 'file')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+            {'call': 'write', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_open', 'reason': set([('file', 'f_flags')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('file', 'f_flags')])},
+            {'call': 'bind', 'reason': set([('fd', 'file')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'set_mempolicy': [{'call': 'set_mempolicy',
+                    'reason': set([('mempolicy', 'mode')])},
+                   {'call': 'get_mempolicy',
+                    'reason': set([('mempolicy', 'mode')])},
+                   {'call': 'mbind', 'reason': set([('mempolicy', 'mode')])}],
+ 'set_thread_area': [{'call': 'keyctl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'rt_sigtimedwait',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'msgrcv',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'kill',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getaffinity',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'arch_prctl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setparam',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ioprio_set',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getppid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ioperm',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'capget',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setaffinity',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'signal',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'umount',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'rt_sigprocmask',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setsid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sigaltstack',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setattr',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'migrate_pages',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getitimer',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setpgid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getsid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'prlimit64',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'rt_sigaction',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getpgid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getpriority',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sigaction',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setns',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'fork',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'get_robust_list',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getscheduler',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ptrace',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getattr',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getrusage',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setscheduler',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setitimer',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ioprio_get',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'vfork',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'prctl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'move_pages',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setpriority',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'clone',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getparam',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])}],
+ 'set_trip_temp': [{'call': 'set_trip_temp',
+                    'reason': set([('pkg_device', 'cpu'),
+                                   ('pkg_device', 'tj_max')])},
+                   {'call': 'get_trip_temp',
+                    'reason': set([('pkg_device', 'cpu'),
+                                   ('pkg_device', 'tj_max')])},
+                   {'call': 'get_curr_temp',
+                    'reason': set([('pkg_device', 'cpu'),
+                                   ('pkg_device', 'tj_max')])}],
+ 'setdomainname': [{'call': 'setns',
+                    'reason': set([('uts_namespace', 'user_ns')])}],
+ 'setfsgid': [{'call': 'keyctl',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setgid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'fsgid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'ioprio_set',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'setfsgid',
+               'reason': set([('cred', 'fsgid'), ('cred', 'user_ns')])},
+              {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setreuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'epoll_create1', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresgid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'fsgid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'setregid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'fsgid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'faccessat',
+               'reason': set([('cred', 'fsgid'), ('cred', 'user_ns')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'setfsuid': [{'call': 'keyctl',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setfsuid',
+               'reason': set([('cred', 'fsuid'), ('cred', 'user_ns')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'ioprio_set',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setreuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'fsuid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'epoll_create1', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setregid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'faccessat',
+               'reason': set([('cred', 'fsuid'), ('cred', 'user_ns')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'fsuid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'fsuid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'setgid': [{'call': 'keyctl',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setgid',
+             'reason': set([('cred', 'gid'),
+                            ('cred', 'sgid'),
+                            ('cred', 'user_ns')])},
+            {'call': 'ioprio_set',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setreuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'epoll_create1', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setresgid',
+             'reason': set([('cred', 'gid'),
+                            ('cred', 'sgid'),
+                            ('cred', 'user_ns')])},
+            {'call': 'setregid',
+             'reason': set([('cred', 'gid'),
+                            ('cred', 'sgid'),
+                            ('cred', 'user_ns')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'faccessat', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setresuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'setpriority',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'setgroups16': [{'call': 'setgroups16',
+                  'reason': set([('group_info', 'ngroups')])},
+                 {'call': 'setgroups',
+                  'reason': set([('group_info', 'ngroups')])}],
+ 'sethostname': [{'call': 'setns',
+                  'reason': set([('uts_namespace', 'user_ns')])}],
+ 'setitimer': [{'call': 'waitid',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'settimeofday',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'timer_create',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'adjtimex',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'getitimer',
+                'reason': set([('itimerval', 'it_interval'),
+                               ('itimerval', 'it_value'),
+                               ('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'select',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'exit_group',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'wait4',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'getrusage',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'setitimer',
+                'reason': set([('itimerval', 'it_interval'),
+                               ('itimerval', 'it_value'),
+                               ('signal_struct', 'it_real_incr'),
+                               ('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'clock_adjtime',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'alarm',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'ppoll',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])}],
+ 'setns': [{'call': 'setns',
+            'reason': set([('nsproxy', 'cgroup_ns'),
+                           ('nsproxy', 'ipc_ns'),
+                           ('nsproxy', 'mnt_ns'),
+                           ('nsproxy', 'net_ns'),
+                           ('nsproxy', 'pid_ns_for_children'),
+                           ('nsproxy', 'uts_ns')])}],
+ 'setpgid': [{'call': 'keyctl',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'msgrcv',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'kill',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'ioprio_set',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getppid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'capget',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'signal',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+             {'call': 'semtimedop',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'umount',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'timer_create',
+              'reason': set([('signal_struct', 'leader')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setsid',
+              'reason': set([('signal_struct', 'leader'),
+                             ('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sigaltstack',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getitimer',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setpgid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getsid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'prlimit64',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getpgid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'exit_group',
+              'reason': set([('signal_struct', 'leader')])},
+             {'call': 'getpriority',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sigaction',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setns',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'fork',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'ptrace',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getrusage',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+             {'call': 'setitimer',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'ioprio_get',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'vfork',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+             {'call': 'prctl',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'move_pages',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setpriority',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'clone',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])}],
+ 'setpriority': [{'call': 'keyctl',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'msgrcv',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'kill',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'capget',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'signal',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setreuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'umount',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setsid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getsid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getpriority',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setns',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'fork',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ptrace',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setresuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'vfork',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'prctl',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setpriority',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'clone',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])}],
+ 'setregid': [{'call': 'keyctl',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setgid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'ioprio_set',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setreuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'epoll_create1', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresgid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'setregid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'faccessat', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'setresgid': [{'call': 'keyctl',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setgid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'ioprio_set',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setreuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'epoll_create1',
+                'reason': set([('cred', 'user_ns')])},
+               {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresgid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'setregid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'faccessat', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setpriority',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'setresuid': [{'call': 'keyctl',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setfsuid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresuid16',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'getresgid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setgid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'ioprio_set',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'capset',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresgid16',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'setfsgid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'unshare',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setreuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user'),
+                               ('cred', 'user_ns')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'epoll_create1',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'getresuid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresgid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'setregid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups16',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'faccessat',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user'),
+                               ('cred', 'user_ns')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user'),
+                               ('cred', 'user_ns')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'setpriority',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'setreuid': [{'call': 'keyctl',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setfsuid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresuid16',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'getresgid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setgid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'ioprio_set',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'capset',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresgid16',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'setfsgid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'unshare',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setreuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user'),
+                              ('cred', 'user_ns')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'epoll_create1',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'getresuid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresgid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'setregid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups16',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'faccessat',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user'),
+                              ('cred', 'user_ns')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user'),
+                              ('cred', 'user_ns')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'setpriority',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'setrlimit': [{'call': 'keyctl',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'msgrcv',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'kill',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getppid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'capget',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'signal',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'umount',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setsid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setrlimit',
+                'reason': set([('compat_rlimit', 'rlim_cur'),
+                               ('compat_rlimit', 'rlim_max'),
+                               ('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setpgid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getsid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'old_getrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'prlimit64',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getpgid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setns',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'fork',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ptrace',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'vfork',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'prctl',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getrlimit',
+                'reason': set([('compat_rlimit', 'rlim_cur'),
+                               ('compat_rlimit', 'rlim_max')])},
+               {'call': 'clone',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])}],
+ 'setsid': [{'call': 'timer_create',
+             'reason': set([('signal_struct', 'leader')])},
+            {'call': 'setsid', 'reason': set([('signal_struct', 'leader')])},
+            {'call': 'exit_group',
+             'reason': set([('signal_struct', 'leader')])}],
+ 'setsockopt': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+                {'call': 'readahead', 'reason': set([('fd', 'file')])},
+                {'call': 'getdents', 'reason': set([('fd', 'file')])},
+                {'call': 'writev', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+                {'call': 'pread64', 'reason': set([('fd', 'file')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+                {'call': 'read', 'reason': set([('fd', 'file')])},
+                {'call': 'fchown', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+                {'call': 'utime', 'reason': set([('fd', 'file')])},
+                {'call': 'fsync', 'reason': set([('fd', 'file')])},
+                {'call': 'bpf', 'reason': set([('fd', 'file')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'sendto', 'reason': set([('fd', 'file')])},
+                {'call': 'tee', 'reason': set([('fd', 'file')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+                {'call': 'lseek', 'reason': set([('fd', 'file')])},
+                {'call': 'connect', 'reason': set([('fd', 'file')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+                {'call': 'flock', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+                {'call': 'accept4',
+                 'reason': set([('fd', 'file'),
+                                ('proto_ops', 'compat_setsockopt')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+                {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'file')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+                {'call': 'splice', 'reason': set([('fd', 'file')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv', 'reason': set([('fd', 'file')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+                {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+                {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+                {'call': 'listen', 'reason': set([('fd', 'file')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+                {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+                {'call': 'llseek', 'reason': set([('fd', 'file')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+                {'call': 'readv', 'reason': set([('fd', 'file')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+                {'call': 'write', 'reason': set([('fd', 'file')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+                {'call': 'bind', 'reason': set([('fd', 'file')])},
+                {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'settimeofday': [{'call': 'waitid',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'settimeofday',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec'),
+                                  ('timezone', 'tz_minuteswest')])},
+                  {'call': 'adjtimex',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'getitimer',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'select',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'wait4',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'getrusage',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'setitimer',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'clock_adjtime',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'alarm',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'ppoll',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])}],
+ 'setuid': [{'call': 'keyctl',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setfsuid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getresuid16',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'getresgid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setgid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'ioprio_set',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'capset',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getresgid16',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'setfsgid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'unshare',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setreuid',
+             'reason': set([('cred', 'suid'),
+                            ('cred', 'uid'),
+                            ('cred', 'user'),
+                            ('cred', 'user_ns')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'epoll_create1',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'getresuid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setresgid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'setregid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getgroups16',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'faccessat',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setresuid',
+             'reason': set([('cred', 'suid'),
+                            ('cred', 'uid'),
+                            ('cred', 'user'),
+                            ('cred', 'user_ns')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setuid',
+             'reason': set([('cred', 'suid'),
+                            ('cred', 'uid'),
+                            ('cred', 'user'),
+                            ('cred', 'user_ns')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getgroups',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'setpriority',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'setxattr': [{'call': 'eventfd2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pivot_root',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'memfd_create',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup3',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'unshare',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_create1',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'flock',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'openat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'lookup_dcookie',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'uselib',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'accept4',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socketpair',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'getcwd',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socket',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pipe2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmdt',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'quotactl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'acct',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'setns',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapon',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mmap_pgoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mq_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'shmat': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setparam', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+           {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+           {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'remap_file_pages', 'reason': set([('path', 'dentry')])},
+           {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+           {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+           {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+           {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+           {'call': 'flock', 'reason': set([('path', 'dentry')])},
+           {'call': 'openat', 'reason': set([('path', 'dentry')])},
+           {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+           {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+           {'call': 'rt_sigprocmask', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+           {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setattr', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+           {'call': 'migrate_pages', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+           {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'shmat',
+            'reason': set([('path', 'dentry'),
+                           ('shmid_kernel', 'shm_file')])},
+           {'call': 'socket', 'reason': set([('path', 'dentry')])},
+           {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+           {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'perf_event_open',
+            'reason': set([('path', 'dentry'), ('task_struct', 'mm')])},
+           {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+           {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+           {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'acct', 'reason': set([('path', 'dentry')])},
+           {'call': 'open', 'reason': set([('path', 'dentry')])},
+           {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'dup', 'reason': set([('path', 'dentry')])},
+           {'call': 'setns',
+            'reason': set([('path', 'dentry'), ('task_struct', 'mm')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'shmctl',
+            'reason': set([('path', 'dentry'),
+                           ('shmid_kernel', 'shm_file')])},
+           {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+           {'call': 'sched_getattr', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+           {'call': 'sched_getparam', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'open_by_handle_at', 'reason': set([('path', 'dentry')])}],
+ 'shmctl': [{'call': 'keyctl',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'msgrcv',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode'),
+                            ('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+            {'call': 'mq_unlink',
+             'reason': set([('ipc_namespace', 'user_ns')])},
+            {'call': 'kill',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+            {'call': 'msgget', 'reason': set([('ipc_namespace', 'user_ns')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+            {'call': 'ioprio_set',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'remap_file_pages', 'reason': set([('file', 'f_op')])},
+            {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+            {'call': 'getppid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'capget',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'signal',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'semtimedop',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode'),
+                            ('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'umount',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+            {'call': 'semctl',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'epoll_ctl', 'reason': set([('file', 'f_op')])},
+            {'call': 'flock', 'reason': set([('file', 'f_op')])},
+            {'call': 'openat', 'reason': set([('file', 'f_op')])},
+            {'call': 'shmget', 'reason': set([('ipc_namespace', 'user_ns')])},
+            {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'accept4', 'reason': set([('file', 'f_op')])},
+            {'call': 'msgctl',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'setsid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sigaltstack',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'getitimer',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'setpgid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'semget', 'reason': set([('ipc_namespace', 'user_ns')])},
+            {'call': 'getsid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'shmat',
+             'reason': set([('file', 'f_op'),
+                            ('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'socket', 'reason': set([('file', 'f_op')])},
+            {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+            {'call': 'prlimit64',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('file', 'f_op'),
+                            ('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'getpgid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'acct', 'reason': set([('file', 'f_op')])},
+            {'call': 'open', 'reason': set([('file', 'f_op')])},
+            {'call': 'getpriority',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sigaction',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'dup', 'reason': set([('file', 'f_op')])},
+            {'call': 'setns',
+             'reason': set([('file', 'f_op'),
+                            ('ipc_namespace', 'user_ns'),
+                            ('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'fork',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'ptrace',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'shmctl',
+             'reason': set([('file', 'f_op'),
+                            ('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode'),
+                            ('shminfo64', 'shmmax')])},
+            {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+            {'call': 'sched_getattr',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'getrusage',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'setitimer',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'ioprio_get',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'vfork',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+            {'call': 'prctl',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'move_pages',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'msgsnd',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'setpriority',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'clone',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'mq_open',
+             'reason': set([('file', 'f_op'), ('ipc_namespace', 'user_ns')])},
+            {'call': 'sched_getparam',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'open_by_handle_at', 'reason': set([('file', 'f_op')])}],
+ 'shmdt': [{'call': 'remap_file_pages',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'shmdt',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'brk',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'get_mempolicy',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'munlockall',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'pkey_mprotect',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'madvise',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mprotect',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mremap',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'prctl',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'munlock',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mincore',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mlockall',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])}],
+ 'shutdown': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+              {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+              {'call': 'readahead', 'reason': set([('fd', 'file')])},
+              {'call': 'getdents', 'reason': set([('fd', 'file')])},
+              {'call': 'writev', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+              {'call': 'pread64', 'reason': set([('fd', 'file')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+              {'call': 'read', 'reason': set([('fd', 'file')])},
+              {'call': 'fchown', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+              {'call': 'utime', 'reason': set([('fd', 'file')])},
+              {'call': 'fsync', 'reason': set([('fd', 'file')])},
+              {'call': 'bpf', 'reason': set([('fd', 'file')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendto', 'reason': set([('fd', 'file')])},
+              {'call': 'tee', 'reason': set([('fd', 'file')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'lseek', 'reason': set([('fd', 'file')])},
+              {'call': 'connect', 'reason': set([('fd', 'file')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+              {'call': 'flock', 'reason': set([('fd', 'file')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+              {'call': 'accept4', 'reason': set([('fd', 'file')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+              {'call': 'splice', 'reason': set([('fd', 'file')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv', 'reason': set([('fd', 'file')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+              {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+              {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+              {'call': 'listen', 'reason': set([('fd', 'file')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+              {'call': 'llseek', 'reason': set([('fd', 'file')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+              {'call': 'readv', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+              {'call': 'write', 'reason': set([('fd', 'file')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+              {'call': 'bind', 'reason': set([('fd', 'file')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'file')])}],
+ 'sigaction': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setparam',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_set',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'semtimedop',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaltstack',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'migrate_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prlimit64',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'perf_event_open',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'get_robust_list',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getrusage',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_get',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'move_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getparam',
+                'reason': set([('mm_segment_t', 'seg')])}],
+ 'signalfd4': [{'call': 'syncfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'vmsplice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+               {'call': 'pwritev64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+               {'call': 'fremovexattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readahead',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getdents',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'writev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchmod',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pread64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'signalfd4',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_op')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+               {'call': 'read',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'utime',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'bpf',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'recvfrom',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fsetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendto',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+               {'call': 'tee',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sync_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'lseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'connect',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getsockname',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_op')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_op')])},
+               {'call': 'pwritev',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fchdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'openat', 'reason': set([('file', 'f_op')])},
+               {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_op')])},
+               {'call': 'old_readdir',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_rm_watch',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+               {'call': 'utimensat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'splice',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ftruncate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'preadv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'getpeername',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+               {'call': 'setsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'socket', 'reason': set([('file', 'f_op')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+               {'call': 'fcntl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'ioctl',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwrite64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'file'),
+                               ('fd', 'flags'),
+                               ('file', 'f_op')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+               {'call': 'pwritev64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'futimesat',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'pwritev2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shutdown',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'acct', 'reason': set([('file', 'f_op')])},
+               {'call': 'open', 'reason': set([('file', 'f_op')])},
+               {'call': 'getsockopt',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'dup', 'reason': set([('file', 'f_op')])},
+               {'call': 'fdatasync',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'setns', 'reason': set([('file', 'f_op')])},
+               {'call': 'getdents64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'listen',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'copy_file_range',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fgetxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+               {'call': 'fcntl64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+               {'call': 'fallocate',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'epoll_wait',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'llseek',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+               {'call': 'preadv64v2',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'readv',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'fstatfs64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'write',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendfile',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_op')])},
+               {'call': 'bind',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'flistxattr',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])},
+               {'call': 'sendfile64',
+                'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'splice': [{'call': 'syncfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'vmsplice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'eventfd2',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'pwritev64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'swapoff',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fremovexattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readahead',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getdents',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'writev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchmod',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pread64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'signalfd4',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'memfd_create',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'dup3',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'read',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'utime',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'recvfrom',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendto',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_create1',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sync_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'lseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'connect',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getsockname',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'pwritev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'openat',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'uselib',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'old_readdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'inotify_rm_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'socketpair',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'utimensat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'splice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ftruncate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getpeername',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shmat',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'setsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'socket',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'pipe2',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fcntl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ioctl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwrite64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'shmdt',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'pwritev64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'futimesat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shutdown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'acct',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'open',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'getsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('fd', 'file'),
+                            ('fd', 'flags'),
+                            ('file', 'f_flags')])},
+            {'call': 'dup',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fdatasync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'setns',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'getdents64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'listen',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'copy_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fgetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shmctl',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fcntl64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'swapon',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fallocate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_wait',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'llseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'preadv64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'write',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_notify',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_open',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'bind',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'flistxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'stat': [{'call': 'lstat',
+           'reason': set([('__old_kernel_stat', 'st_ino'),
+                          ('__old_kernel_stat', 'st_nlink')])},
+          {'call': 'stat',
+           'reason': set([('__old_kernel_stat', 'st_ino'),
+                          ('__old_kernel_stat', 'st_nlink')])},
+          {'call': 'fstat',
+           'reason': set([('__old_kernel_stat', 'st_ino'),
+                          ('__old_kernel_stat', 'st_nlink'),
+                          ('kstat', 'dev'),
+                          ('kstat', 'ino'),
+                          ('kstat', 'nlink'),
+                          ('kstat', 'rdev')])},
+          {'call': 'newfstat',
+           'reason': set([('kstat', 'dev'),
+                          ('kstat', 'ino'),
+                          ('kstat', 'nlink'),
+                          ('kstat', 'rdev')])}],
+ 'statfs': [{'call': 'ustat',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'fstatfs',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'statfs',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'fstatfs64',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'statfs64',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])}],
+ 'statfs64': [{'call': 'ustat',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'fstatfs',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'statfs',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'fstatfs64',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'statfs64',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])}],
+ 'swapoff': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'swapoff',
+              'reason': set([('file', 'f_mapping'),
+                             ('page', 'private'),
+                             ('swap_info_struct', 'cluster_info'),
+                             ('swap_info_struct', 'flags'),
+                             ('swap_info_struct', 'inuse_pages'),
+                             ('swap_info_struct', 'pages'),
+                             ('swap_info_struct', 'prio'),
+                             ('swap_info_struct', 'swap_map'),
+                             ('swp_entry_t', 'val')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mapping')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'epoll_create1',
+              'reason': set([('file', 'f_mapping')])},
+             {'call': 'epoll_ctl', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'flock', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'accept4', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'perf_event_open',
+              'reason': set([('file', 'f_mapping'), ('task_struct', 'mm')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'open', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'setns',
+              'reason': set([('file', 'f_mapping'), ('task_struct', 'mm')])},
+             {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'swapon',
+              'reason': set([('file', 'f_mapping'),
+                             ('page', 'private'),
+                             ('swap_info_struct', 'cluster_info'),
+                             ('swap_info_struct', 'flags'),
+                             ('swap_info_struct', 'inuse_pages'),
+                             ('swap_info_struct', 'pages'),
+                             ('swap_info_struct', 'prio'),
+                             ('swap_info_struct', 'swap_map')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'prctl', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mapping')])}],
+ 'swapon': [{'call': 'mq_unlink', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'swapoff',
+             'reason': set([('inode', 'i_flags'),
+                            ('swap_info_struct', 'bdev'),
+                            ('swap_info_struct', 'flags'),
+                            ('swap_info_struct', 'percpu_cluster'),
+                            ('swap_info_struct', 'type')])},
+            {'call': 'fchmod', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'memfd_create', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'readlinkat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'fchown', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('inode', 'i_flags')])},
+            {'call': 'uselib', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'fchmodat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('inode', 'i_flags')])},
+            {'call': 'ftruncate', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'ioctl', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'linkat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'unlink', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'faccessat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'swapon',
+             'reason': set([('inode', 'i_flags'),
+                            ('swap_info_struct', 'bdev'),
+                            ('swap_info_struct', 'flags'),
+                            ('swap_info_struct', 'percpu_cluster'),
+                            ('swap_info_struct', 'type')])},
+            {'call': 'fchownat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_notify', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'sendfile', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'unlinkat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'sendfile64', 'reason': set([('inode', 'i_flags')])}],
+ 'symlinkat': [{'call': 'sysfs',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'mq_unlink',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapoff',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'openat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'uselib',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'renameat2',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'symlinkat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'quotactl',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'acct',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'unlink',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'rmdir',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapon',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'mq_open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'unlinkat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])}],
+ 'sync_file_range': [{'call': 'syncfs',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'vmsplice',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwritev64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'readahead',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getdents',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'writev',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'preadv64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fchmod',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pread64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'signalfd4',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'read',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fchown',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'utime',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fsync',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'bpf',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'recvfrom',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fsetxattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sendto',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'tee',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sync_file_range',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'lseek',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'connect',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getsockname',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'epoll_ctl',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'flock',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwritev',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fchdir',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'accept4',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'old_readdir',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'utimensat',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'preadv2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'splice',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'ftruncate',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'preadv',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getpeername',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'setsockopt',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fcntl',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'ioctl',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwrite64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwritev64v2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'futimesat',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'pwritev2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'shutdown',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getsockopt',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fdatasync',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'getdents64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'listen',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'copy_file_range',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fgetxattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fcntl64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fallocate',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'epoll_wait',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'llseek',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'preadv64v2',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'readv',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fstatfs',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'fstatfs64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'write',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sendfile',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'bind',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'flistxattr',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])},
+                     {'call': 'sendfile64',
+                      'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'syncfs': [{'call': 'syncfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'vmsplice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fremovexattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readahead',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getdents',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'writev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchmod',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pread64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'signalfd4',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'read',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'utime',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'recvfrom',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fsetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendto',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sync_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'lseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'connect',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getsockname',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fchdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'old_readdir',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'inotify_rm_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'utimensat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'splice',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ftruncate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getpeername',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'setsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fcntl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'ioctl',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwrite64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'futimesat',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'pwritev2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'shutdown',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getsockopt',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fdatasync',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'getdents64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'listen',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'copy_file_range',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fgetxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fcntl64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fallocate',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'epoll_wait',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'llseek',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'preadv64v2',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'readv',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'fstatfs64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'write',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'mq_notify',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'bind',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'flistxattr',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])},
+            {'call': 'sendfile64',
+             'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'sysctl': [{'call': 'sysctl',
+             'reason': set([('__sysctl_args', 'oldlenp'),
+                            ('__sysctl_args', 'oldval'),
+                            ('compat_sysctl_args', 'oldlenp'),
+                            ('compat_sysctl_args', 'oldval')])}],
+ 'sysfs': [{'call': 'sysfs',
+            'reason': set([('file_system_type', 'name'),
+                           ('file_system_type', 'owner'),
+                           ('filename', 'name')])},
+           {'call': 'mq_unlink', 'reason': set([('filename', 'name')])},
+           {'call': 'swapoff', 'reason': set([('filename', 'name')])},
+           {'call': 'openat', 'reason': set([('filename', 'name')])},
+           {'call': 'uselib', 'reason': set([('filename', 'name')])},
+           {'call': 'renameat2', 'reason': set([('filename', 'name')])},
+           {'call': 'symlinkat', 'reason': set([('filename', 'name')])},
+           {'call': 'quotactl', 'reason': set([('filename', 'name')])},
+           {'call': 'acct', 'reason': set([('filename', 'name')])},
+           {'call': 'open', 'reason': set([('filename', 'name')])},
+           {'call': 'unlink', 'reason': set([('filename', 'name')])},
+           {'call': 'rmdir', 'reason': set([('filename', 'name')])},
+           {'call': 'swapon', 'reason': set([('filename', 'name')])},
+           {'call': 'mq_open', 'reason': set([('filename', 'name')])},
+           {'call': 'unlinkat', 'reason': set([('filename', 'name')])}],
+ 'sysinfo': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_unlink', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setparam',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchmod', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'memfd_create',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'readlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'io_getevents',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchown', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'utime', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'semtimedop',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'settimeofday',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'timerfd_gettime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sigaltstack',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setattr',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'migrate_pages',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'inotify_add_watch',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'timer_settime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ftruncate', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'timer_gettime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sysinfo',
+              'reason': set([('sysinfo', 'mem_unit'),
+                             ('sysinfo', 'totalram'),
+                             ('sysinfo', 'totalswap')])},
+             {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ioctl', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'perf_event_open',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'futimesat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'select', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getpriority',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'nanosleep', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'mq_getsetattr',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'faccessat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'get_robust_list',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'epoll_wait', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_getattr',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fstat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'timerfd_settime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setpriority',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_notify', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sendfile', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'newfstat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'clock_nanosleep',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_getparam',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sendfile64', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ppoll', 'reason': set([('timespec', 'tv_nsec')])}],
+ 'syslog': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setparam',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semtimedop', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'perf_event_open',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'get_robust_list',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getparam',
+             'reason': set([('mm_segment_t', 'seg')])}],
+ 'tee': [{'call': 'syncfs', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'vmsplice',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+         {'call': 'pwritev64',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fremovexattr',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'readahead',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'getdents',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'writev', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'preadv64',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'fchmod', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'pread64',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'signalfd4',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+         {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+         {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+         {'call': 'read', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'fchown', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'mq_timedreceive',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'utime', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'fsync', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'recvfrom',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'fsetxattr',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'sendto', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+         {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'sync_file_range',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'lseek', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'connect',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'getsockname',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'epoll_ctl',
+          'reason': set([('fd', 'file'),
+                         ('fd', 'flags'),
+                         ('file', 'f_mode')])},
+         {'call': 'flock',
+          'reason': set([('fd', 'file'),
+                         ('fd', 'flags'),
+                         ('file', 'f_mode')])},
+         {'call': 'pwritev',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'fchdir', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+         {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+         {'call': 'accept4',
+          'reason': set([('fd', 'file'),
+                         ('fd', 'flags'),
+                         ('file', 'f_mode')])},
+         {'call': 'old_readdir',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'inotify_rm_watch',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+         {'call': 'utimensat',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'inotify_add_watch',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'preadv2',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'splice', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'ftruncate',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'preadv', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'getpeername',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+         {'call': 'setsockopt',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+         {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fcntl', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'ioctl', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'pwrite64',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'perf_event_open',
+          'reason': set([('fd', 'file'),
+                         ('fd', 'flags'),
+                         ('file', 'f_mode')])},
+         {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+         {'call': 'pwritev64v2',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'futimesat',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'pwritev2',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'shutdown',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+         {'call': 'open', 'reason': set([('file', 'f_mode')])},
+         {'call': 'getsockopt',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'mq_getsetattr',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fdatasync',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+         {'call': 'getdents64',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'listen', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'copy_file_range',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'mq_timedsend',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'fgetxattr',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fcntl64',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fallocate',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'epoll_wait',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'llseek', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+         {'call': 'preadv64v2',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'readv', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'fstatfs',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'fstatfs64',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'write', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'mq_notify',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'sendfile',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+         {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])},
+         {'call': 'bind', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'flistxattr',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])},
+         {'call': 'sendfile64',
+          'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'tgkill': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'timer_create': [{'call': 'clock_getres',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'timer_delete',
+                   'reason': set([('k_clock', 'timer_create'),
+                                  ('k_itimer', 'it_pid')])},
+                  {'call': 'timer_create',
+                   'reason': set([('k_clock', 'timer_create'),
+                                  ('k_itimer', 'it_pid')])},
+                  {'call': 'clock_gettime',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'timer_settime',
+                   'reason': set([('k_clock', 'timer_create'),
+                                  ('k_itimer', 'it_pid')])},
+                  {'call': 'timer_gettime',
+                   'reason': set([('k_clock', 'timer_create'),
+                                  ('k_itimer', 'it_pid')])},
+                  {'call': 'clock_settime',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'timer_getoverrun',
+                   'reason': set([('k_itimer', 'it_pid')])},
+                  {'call': 'clock_nanosleep',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'clock_adjtime',
+                   'reason': set([('k_clock', 'timer_create')])}],
+ 'timer_delete': [{'call': 'keyctl',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'rt_sigtimedwait',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'msgrcv',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'kill',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'clock_getres',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'timer_delete',
+                   'reason': set([('k_clock', 'timer_del'),
+                                  ('k_itimer', 'it_pid'),
+                                  ('k_itimer', 'it_signal'),
+                                  ('k_itimer', 'sigq')])},
+                  {'call': 'sched_getaffinity',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_setparam',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'ioprio_set',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'getppid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'capget',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_setaffinity',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'signal',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'semtimedop',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'umount',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'timer_create',
+                   'reason': set([('k_clock', 'timer_del'),
+                                  ('k_itimer', 'it_pid'),
+                                  ('k_itimer', 'it_signal'),
+                                  ('k_itimer', 'sigq')])},
+                  {'call': 'clock_gettime',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'sched_rr_get_interval',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'rt_sigprocmask',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setsid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sigaltstack',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_setattr',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'migrate_pages',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'getitimer',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setpgid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'timer_settime',
+                   'reason': set([('k_clock', 'timer_del'),
+                                  ('k_itimer', 'it_pid'),
+                                  ('k_itimer', 'it_signal'),
+                                  ('k_itimer', 'sigq')])},
+                  {'call': 'timer_gettime',
+                   'reason': set([('k_clock', 'timer_del'),
+                                  ('k_itimer', 'it_pid'),
+                                  ('k_itimer', 'it_signal'),
+                                  ('k_itimer', 'sigq')])},
+                  {'call': 'getsid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'prlimit64',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'rt_sigaction',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'getpgid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'clock_settime',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'getpriority',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sigaction',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setns',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'fork',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'get_robust_list',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_getscheduler',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'ptrace',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_getattr',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'getrusage',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_setscheduler',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setitimer',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'ioprio_get',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'vfork',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'prctl',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'move_pages',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setpriority',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'timer_getoverrun',
+                   'reason': set([('k_itimer', 'it_pid'),
+                                  ('k_itimer', 'it_signal'),
+                                  ('k_itimer', 'sigq')])},
+                  {'call': 'clone',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'clock_nanosleep',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'sched_getparam',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'clock_adjtime',
+                   'reason': set([('k_clock', 'timer_del')])}],
+ 'timer_getoverrun': [{'call': 'keyctl',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'rt_sigtimedwait',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'msgrcv',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'kill',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'timer_delete',
+                       'reason': set([('k_itimer', 'it_signal')])},
+                      {'call': 'sched_getaffinity',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_setparam',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'ioprio_set',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getppid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'mq_timedreceive',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'capget',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_setaffinity',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'signal',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'semtimedop',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'umount',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'timer_create',
+                       'reason': set([('k_itimer', 'it_signal')])},
+                      {'call': 'sched_rr_get_interval',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'rt_sigprocmask',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setsid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sigaltstack',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_setattr',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'migrate_pages',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getitimer',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setpgid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'timer_settime',
+                       'reason': set([('k_itimer', 'it_signal')])},
+                      {'call': 'timer_gettime',
+                       'reason': set([('k_itimer', 'it_signal')])},
+                      {'call': 'getsid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'prlimit64',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'perf_event_open',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'rt_sigaction',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getpgid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getpriority',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sigaction',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setns',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'fork',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'get_robust_list',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'mq_timedsend',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_getscheduler',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'ptrace',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_getattr',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getrusage',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_setscheduler',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setitimer',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'ioprio_get',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'vfork',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'prctl',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'move_pages',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setpriority',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'timer_getoverrun',
+                       'reason': set([('k_itimer', 'it_signal')])},
+                      {'call': 'clone',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_getparam',
+                       'reason': set([('task_struct', 'signal')])}],
+ 'timer_gettime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'timer_get')])}],
+ 'timer_settime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'timer_set')])}],
+ 'timerfd_create': [{'call': 'timerfd_gettime',
+                     'reason': set([('timerfd_ctx', 'clockid')])},
+                    {'call': 'timerfd_settime',
+                     'reason': set([('timerfd_ctx', 'clockid')])},
+                    {'call': 'timerfd_create',
+                     'reason': set([('timerfd_ctx', 'clockid')])}],
+ 'timerfd_gettime': [{'call': 'timerfd_gettime',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])},
+                     {'call': 'timerfd_settime',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])},
+                     {'call': 'timerfd_create',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])}],
+ 'timerfd_settime': [{'call': 'timerfd_gettime',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])},
+                     {'call': 'timerfd_settime',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])},
+                     {'call': 'timerfd_create',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])}],
+ 'tkill': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'rt_sigaction', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'mq_timedsend', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'cred')])}],
+ 'umount': [{'call': 'syncfs', 'reason': set([('super_block', 's_flags')])},
+            {'call': 'keyctl', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'eventfd2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_unlink',
+             'reason': set([('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'swapoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'pivot_root',
+             'reason': set([('mount', 'mnt_ns'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'memfd_create',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'dup3',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+            {'call': 'unshare',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'umount',
+             'reason': set([('mount', 'mnt_ns'),
+                            ('super_block', 's_flags'),
+                            ('task_struct', 'flags'),
+                            ('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'epoll_create1',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'flock',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'openat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'lookup_dcookie',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'uselib',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'accept4',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'socketpair',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'getcwd',
+             'reason': set([('mount', 'mnt_ns'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'shmat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'socket',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pipe2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('task_struct', 'flags')])},
+            {'call': 'shmdt',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'quotactl',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('super_block', 's_flags')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'acct',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'dup',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setns',
+             'reason': set([('nsproxy', 'mnt_ns'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('task_struct', 'flags')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'shmctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'swapon',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('super_block', 's_flags')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'mq_open',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'uname': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getrusage',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'move_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'personality')])}],
+ 'unlink': [{'call': 'eventfd2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_unlink', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'swapoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pivot_root',
+             'reason': set([('dentry', 'd_inode'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'memfd_create',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'dup3',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'unshare',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mkdirat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'epoll_create1',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'flock',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'openat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'lookup_dcookie',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'uselib',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'renameat2', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'accept4',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'socketpair',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getcwd',
+             'reason': set([('dentry', 'd_inode'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'ftruncate', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'shmat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mknodat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'socket',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'symlinkat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'pipe2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'perf_event_open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'linkat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'shmdt',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'quotactl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'acct',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'unlink', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'rmdir', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'dup',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setns',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'shmctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'swapon',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_open',
+             'reason': set([('dentry', 'd_inode'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'unlinkat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'unlinkat': [{'call': 'eventfd2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mq_unlink', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'swapoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pivot_root',
+               'reason': set([('dentry', 'd_inode'),
+                              ('path', 'dentry'),
+                              ('path', 'mnt')])},
+              {'call': 'memfd_create',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup3',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'unshare',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mkdirat', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'epoll_create1',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'flock',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'openat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'lookup_dcookie',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'uselib',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'renameat2', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'accept4',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socketpair',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'getcwd',
+               'reason': set([('dentry', 'd_inode'),
+                              ('path', 'dentry'),
+                              ('path', 'mnt')])},
+              {'call': 'ftruncate', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'shmat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mknodat', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'socket',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'symlinkat', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'pipe2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'linkat', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'shmdt',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'quotactl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'acct',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'unlink', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'rmdir', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'dup',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'setns',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapon',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mmap_pgoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mq_open',
+               'reason': set([('dentry', 'd_inode'),
+                              ('path', 'dentry'),
+                              ('path', 'mnt')])},
+              {'call': 'unlinkat', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'unshare': [{'call': 'unshare', 'reason': set([('fs_struct', 'users')])}],
+ 'uselib': [{'call': 'syncfs', 'reason': set([('super_block', 's_iflags')])},
+            {'call': 'mq_unlink', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'pivot_root',
+             'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'ustat', 'reason': set([('super_block', 's_iflags')])},
+            {'call': 'umount',
+             'reason': set([('super_block', 's_iflags'),
+                            ('vfsmount', 'mnt_flags')])},
+            {'call': 'uselib',
+             'reason': set([('linux_binfmt', 'load_shlib'),
+                            ('linux_binfmt', 'module')])},
+            {'call': 'getcwd', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'quotactl',
+             'reason': set([('super_block', 's_iflags')])},
+            {'call': 'acct', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'swapon', 'reason': set([('super_block', 's_iflags')])},
+            {'call': 'mq_open', 'reason': set([('vfsmount', 'mnt_flags')])}],
+ 'ustat': [{'call': 'syncfs', 'reason': set([('super_block', 's_root')])},
+           {'call': 'ustat', 'reason': set([('super_block', 's_root')])},
+           {'call': 'umount', 'reason': set([('super_block', 's_root')])},
+           {'call': 'quotactl', 'reason': set([('super_block', 's_root')])},
+           {'call': 'swapon', 'reason': set([('super_block', 's_root')])}],
+ 'utime': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_unlink', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+           {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+           {'call': 'readahead', 'reason': set([('fd', 'file')])},
+           {'call': 'getdents', 'reason': set([('fd', 'file')])},
+           {'call': 'writev', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+           {'call': 'fchmod',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'pread64', 'reason': set([('fd', 'file')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+           {'call': 'memfd_create', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'readlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'read', 'reason': set([('fd', 'file')])},
+           {'call': 'io_getevents', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fchown',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'utime',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'fsync', 'reason': set([('fd', 'file')])},
+           {'call': 'bpf', 'reason': set([('fd', 'file')])},
+           {'call': 'semtimedop', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+           {'call': 'settimeofday', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'sendto', 'reason': set([('fd', 'file')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timerfd_gettime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'tee', 'reason': set([('fd', 'file')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+           {'call': 'lseek', 'reason': set([('fd', 'file')])},
+           {'call': 'connect', 'reason': set([('fd', 'file')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+           {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+           {'call': 'flock', 'reason': set([('fd', 'file')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+           {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'accept4', 'reason': set([('fd', 'file')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+           {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+           {'call': 'timer_settime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'splice', 'reason': set([('fd', 'file')])},
+           {'call': 'ftruncate',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'timer_gettime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'preadv', 'reason': set([('fd', 'file')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+           {'call': 'ioctl',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+           {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+           {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+           {'call': 'futimesat',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+           {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'select', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+           {'call': 'nanosleep', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'faccessat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+           {'call': 'listen', 'reason': set([('fd', 'file')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+           {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+           {'call': 'epoll_wait',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fstat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timerfd_settime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'llseek', 'reason': set([('fd', 'file')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+           {'call': 'readv', 'reason': set([('fd', 'file')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+           {'call': 'write', 'reason': set([('fd', 'file')])},
+           {'call': 'mq_notify',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'sendfile',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'newfstat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'clock_nanosleep',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'bind', 'reason': set([('fd', 'file')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+           {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'sendfile64',
+            'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+           {'call': 'ppoll', 'reason': set([('timespec', 'tv_nsec')])}],
+ 'utimensat': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_unlink',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+               {'call': 'readahead', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents', 'reason': set([('fd', 'file')])},
+               {'call': 'writev', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+               {'call': 'fchmod',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'pread64', 'reason': set([('fd', 'file')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+               {'call': 'memfd_create',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'readlinkat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'read', 'reason': set([('fd', 'file')])},
+               {'call': 'io_getevents',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchown',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'utime',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'fsync', 'reason': set([('fd', 'file')])},
+               {'call': 'bpf', 'reason': set([('fd', 'file')])},
+               {'call': 'semtimedop',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'settimeofday',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendto', 'reason': set([('fd', 'file')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'tee', 'reason': set([('fd', 'file')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'lseek', 'reason': set([('fd', 'file')])},
+               {'call': 'connect', 'reason': set([('fd', 'file')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+               {'call': 'flock', 'reason': set([('fd', 'file')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+               {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'accept4', 'reason': set([('fd', 'file')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+               {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+               {'call': 'timer_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'splice', 'reason': set([('fd', 'file')])},
+               {'call': 'ftruncate',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'timer_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'preadv', 'reason': set([('fd', 'file')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+               {'call': 'ioctl',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+               {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'futimesat',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+               {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'select', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+               {'call': 'nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'faccessat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+               {'call': 'listen', 'reason': set([('fd', 'file')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+               {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+               {'call': 'epoll_wait',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fstat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'llseek', 'reason': set([('fd', 'file')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+               {'call': 'readv', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+               {'call': 'write', 'reason': set([('fd', 'file')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'sendfile',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'newfstat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'clock_nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'bind', 'reason': set([('fd', 'file')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+               {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile64',
+                'reason': set([('fd', 'file'), ('timespec', 'tv_nsec')])},
+               {'call': 'ppoll', 'reason': set([('timespec', 'tv_nsec')])}],
+ 'vmsplice': [{'call': 'syncfs',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'vmsplice',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('splice_desc', 'total_len')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fremovexattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'readahead',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getdents',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'writev',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fchmod',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'pread64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'signalfd4',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'read',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fchown',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'utime',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fsync',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'bpf',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'recvfrom',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fsetxattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sendto',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'tee',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sync_file_range',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'lseek',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'connect',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getsockname',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('file', 'f_mode')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('file', 'f_mode')])},
+              {'call': 'pwritev',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fchdir',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('file', 'f_mode')])},
+              {'call': 'old_readdir',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'inotify_rm_watch',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'utimensat',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'inotify_add_watch',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'splice',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'ftruncate',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'preadv',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'getpeername',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setsockopt',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'ioctl',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'pwrite64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'file'),
+                              ('fd', 'flags'),
+                              ('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64v2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'futimesat',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'pwritev2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'shutdown',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getsockopt',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fdatasync',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getdents64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'listen',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'copy_file_range',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fgetxattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fallocate',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'epoll_wait',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'llseek',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'preadv64v2',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'readv',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fstatfs',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'fstatfs64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'write',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_notify',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sendfile',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'bind',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'flistxattr',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])},
+              {'call': 'sendfile64',
+               'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'write': [{'call': 'syncfs',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'vmsplice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fremovexattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readahead',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getdents',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'writev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchmod',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pread64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'signalfd4',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'read', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'utime',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fsync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'recvfrom',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fsetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendto',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'tee', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sync_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'lseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'connect',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getsockname',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'flock',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fchdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'accept4',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'old_readdir',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_rm_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'utimensat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'splice',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ftruncate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getpeername',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'setsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fcntl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'ioctl',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwrite64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'perf_event_open',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'futimesat',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'pwritev2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'shutdown',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getsockopt',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fdatasync',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'getdents64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'listen',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'copy_file_range',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fgetxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fcntl64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fallocate',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'epoll_wait',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'llseek',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'preadv64v2',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'readv',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'fstatfs64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'write',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'mq_notify',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'bind', 'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'flistxattr',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])},
+           {'call': 'sendfile64',
+            'reason': set([('fd', 'file'), ('fd', 'flags')])}],
+ 'writev': [{'call': 'syncfs', 'reason': set([('fd', 'file')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'file')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'file')])},
+            {'call': 'readahead', 'reason': set([('fd', 'file')])},
+            {'call': 'getdents', 'reason': set([('fd', 'file')])},
+            {'call': 'writev', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'file')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'file')])},
+            {'call': 'pread64', 'reason': set([('fd', 'file')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'file')])},
+            {'call': 'read', 'reason': set([('fd', 'file')])},
+            {'call': 'fchown', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'file')])},
+            {'call': 'utime', 'reason': set([('fd', 'file')])},
+            {'call': 'fsync', 'reason': set([('fd', 'file')])},
+            {'call': 'bpf', 'reason': set([('fd', 'file')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'file')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'sendto', 'reason': set([('fd', 'file')])},
+            {'call': 'tee', 'reason': set([('fd', 'file')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'file')])},
+            {'call': 'lseek', 'reason': set([('fd', 'file')])},
+            {'call': 'connect', 'reason': set([('fd', 'file')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_ctl', 'reason': set([('fd', 'file')])},
+            {'call': 'flock', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'file')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'file')])},
+            {'call': 'accept4', 'reason': set([('fd', 'file')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'file')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'file')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'file')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'file')])},
+            {'call': 'splice', 'reason': set([('fd', 'file')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv', 'reason': set([('fd', 'file')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'file')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'file')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'file')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'file')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'file')])},
+            {'call': 'perf_event_open', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'file')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'file')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'file')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'file')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'file')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'file')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'file')])},
+            {'call': 'listen', 'reason': set([('fd', 'file')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'file')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'file')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'file')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'file')])},
+            {'call': 'llseek', 'reason': set([('fd', 'file')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'file')])},
+            {'call': 'readv', 'reason': set([('fd', 'file')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'file')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'file')])},
+            {'call': 'write', 'reason': set([('fd', 'file')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'file')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'file')])},
+            {'call': 'bind', 'reason': set([('fd', 'file')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'file')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'file')])}]}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies_verbose.json b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies_verbose.json
new file mode 100644
index 0000000000..46e3f6675a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies_verbose.json
@@ -0,0 +1 @@
+{"setdomainname": [{"reason": ["uts_namespace->user_ns"], "call": "setns"}], "name_to_handle_at": [{"reason": ["super_block->s_export_op"], "call": "syncfs"}, {"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["super_block->s_export_op"], "call": "ustat"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["super_block->s_export_op"], "call": "umount"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["super_block->s_export_op", "path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["super_block->s_export_op", "path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "syncfs": [{"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "lseek": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "rt_sigtimedwait": [{"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "msgrcv"}, {"reason": ["siginfo->si_code", "task_struct->timer_slack_ns", "mm_segment_t->seg", "siginfo->si_signo"], "call": "kill"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "capget"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "signal"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "umount"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "timer_create"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_rr_get_interval"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "rt_sigqueueinfo"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "tgkill"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setsid"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getsid"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sigaction"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "rt_tgsigqueueinfo"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setns"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "fork"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "vfork"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "prctl"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "move_pages"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "rt_sigreturn"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "tkill"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "clone"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_getparam"}], "vmsplice": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "setfsuid": [{"reason": ["cred->user_ns", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user_ns"], "call": "setgid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user_ns"], "call": "setfsgid"}, {"reason": ["cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->uid", "cred->user_ns", "cred->suid", "cred->euid", "cred->fsuid"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user_ns"], "call": "setresgid"}, {"reason": ["cred->user_ns"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user_ns", "cred->fsuid"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->uid", "cred->user_ns", "cred->suid", "cred->euid", "cred->fsuid"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->uid", "cred->user_ns", "cred->suid", "cred->euid", "cred->fsuid"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user_ns"], "call": "getgroups"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "msgrcv": [{"reason": ["msg_msg->m_ts"], "call": "mq_timedreceive"}, {"reason": ["msg_msg->m_ts"], "call": "mq_timedsend"}, {"reason": ["msg_msg->m_ts"], "call": "msgsnd"}], "uname": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}], "kill": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "io_getevents": [{"reason": ["task_struct->timer_slack_ns"], "call": "keyctl"}, {"reason": ["task_struct->timer_slack_ns"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->timer_slack_ns"], "call": "msgrcv"}, {"reason": ["task_struct->timer_slack_ns"], "call": "kill"}, {"reason": ["mm_struct->ioctx_table"], "call": "swapoff"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_getaffinity"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_setparam"}, {"reason": ["task_struct->timer_slack_ns"], "call": "ioprio_set"}, {"reason": ["mm_struct->ioctx_table"], "call": "remap_file_pages"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getppid"}, {"reason": ["task_struct->timer_slack_ns"], "call": "mq_timedreceive"}, {"reason": ["task_struct->timer_slack_ns"], "call": "capget"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_setaffinity"}, {"reason": ["task_struct->timer_slack_ns"], "call": "signal"}, {"reason": ["task_struct->timer_slack_ns"], "call": "semtimedop"}, {"reason": ["task_struct->timer_slack_ns"], "call": "umount"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->timer_slack_ns"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setsid"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sigaltstack"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_setattr"}, {"reason": ["task_struct->timer_slack_ns", "mm_struct->ioctx_table"], "call": "migrate_pages"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getitimer"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setpgid"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getsid"}, {"reason": ["task_struct->timer_slack_ns"], "call": "prlimit64"}, {"reason": ["task_struct->timer_slack_ns"], "call": "perf_event_open"}, {"reason": ["mm_struct->ioctx_table"], "call": "shmdt"}, {"reason": ["task_struct->timer_slack_ns"], "call": "rt_sigaction"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getpgid"}, {"reason": ["mm_struct->ioctx_table"], "call": "brk"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getpriority"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sigaction"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setns"}, {"reason": ["task_struct->timer_slack_ns"], "call": "fork"}, {"reason": ["mm_struct->ioctx_table"], "call": "get_mempolicy"}, {"reason": ["kioctx->user_id"], "call": "io_submit"}, {"reason": ["task_struct->timer_slack_ns"], "call": "get_robust_list"}, {"reason": ["task_struct->timer_slack_ns"], "call": "mq_timedsend"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_getscheduler"}, {"reason": ["task_struct->timer_slack_ns"], "call": "ptrace"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_getattr"}, {"reason": ["task_struct->timer_slack_ns", "mm_struct->ioctx_table"], "call": "getrusage"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_setscheduler"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setitimer"}, {"reason": ["task_struct->timer_slack_ns"], "call": "ioprio_get"}, {"reason": ["task_struct->timer_slack_ns"], "call": "vfork"}, {"reason": ["kioctx_table->nr", "kioctx->user_id", "mm_struct->ioctx_table"], "call": "io_setup"}, {"reason": ["mm_struct->ioctx_table"], "call": "mremap"}, {"reason": ["kioctx_table->nr", "kioctx->user_id", "mm_struct->ioctx_table"], "call": "io_destroy"}, {"reason": ["mm_struct->ioctx_table"], "call": "mbind"}, {"reason": ["task_struct->timer_slack_ns", "mm_struct->ioctx_table"], "call": "prctl"}, {"reason": ["task_struct->timer_slack_ns", "mm_struct->ioctx_table"], "call": "move_pages"}, {"reason": ["mm_struct->ioctx_table"], "call": "modify_ldt"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setpriority"}, {"reason": ["mm_struct->ioctx_table"], "call": "mincore"}, {"reason": ["task_struct->timer_slack_ns"], "call": "clone"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_getparam"}, {"reason": ["kioctx_table->nr", "kioctx->user_id", "mm_struct->ioctx_table"], "call": "io_cancel"}], "swapoff": [{"reason": ["task_struct->mm"], "call": "keyctl"}, {"reason": ["task_struct->mm"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->mm"], "call": "msgrcv"}, {"reason": ["file->f_mapping"], "call": "eventfd2"}, {"reason": ["task_struct->mm"], "call": "kill"}, {"reason": ["task_struct->mm"], "call": "sched_getaffinity"}, {"reason": ["task_struct->mm"], "call": "sched_setparam"}, {"reason": ["file->f_mapping"], "call": "memfd_create"}, {"reason": ["task_struct->mm"], "call": "ioprio_set"}, {"reason": ["file->f_mapping"], "call": "remap_file_pages"}, {"reason": ["file->f_mapping"], "call": "dup3"}, {"reason": ["task_struct->mm"], "call": "getppid"}, {"reason": ["task_struct->mm"], "call": "mq_timedreceive"}, {"reason": ["task_struct->mm"], "call": "capget"}, {"reason": ["task_struct->mm"], "call": "sched_setaffinity"}, {"reason": ["task_struct->mm"], "call": "signal"}, {"reason": ["task_struct->mm"], "call": "semtimedop"}, {"reason": ["task_struct->mm"], "call": "umount"}, {"reason": ["task_struct->mm"], "call": "sched_rr_get_interval"}, {"reason": ["file->f_mapping"], "call": "epoll_create1"}, {"reason": ["file->f_mapping"], "call": "epoll_ctl"}, {"reason": ["file->f_mapping"], "call": "flock"}, {"reason": ["file->f_mapping"], "call": "openat"}, {"reason": ["file->f_mapping"], "call": "uselib"}, {"reason": ["task_struct->mm"], "call": "rt_sigprocmask"}, {"reason": ["file->f_mapping"], "call": "accept4"}, {"reason": ["task_struct->mm"], "call": "setsid"}, {"reason": ["task_struct->mm"], "call": "sigaltstack"}, {"reason": ["task_struct->mm"], "call": "sched_setattr"}, {"reason": ["file->f_mapping"], "call": "socketpair"}, {"reason": ["task_struct->mm"], "call": "migrate_pages"}, {"reason": ["task_struct->mm"], "call": "getitimer"}, {"reason": ["task_struct->mm"], "call": "setpgid"}, {"reason": ["task_struct->mm"], "call": "getsid"}, {"reason": ["file->f_mapping"], "call": "shmat"}, {"reason": ["file->f_mapping"], "call": "socket"}, {"reason": ["file->f_mapping"], "call": "pipe2"}, {"reason": ["task_struct->mm"], "call": "prlimit64"}, {"reason": ["task_struct->mm", "file->f_mapping"], "call": "perf_event_open"}, {"reason": ["file->f_mapping"], "call": "shmdt"}, {"reason": ["task_struct->mm"], "call": "rt_sigaction"}, {"reason": ["task_struct->mm"], "call": "getpgid"}, {"reason": ["file->f_mapping"], "call": "acct"}, {"reason": ["file->f_mapping"], "call": "open"}, {"reason": ["task_struct->mm"], "call": "getpriority"}, {"reason": ["task_struct->mm"], "call": "sigaction"}, {"reason": ["file->f_mapping"], "call": "dup"}, {"reason": ["task_struct->mm", "file->f_mapping"], "call": "setns"}, {"reason": ["task_struct->mm"], "call": "fork"}, {"reason": ["task_struct->mm"], "call": "get_robust_list"}, {"reason": ["task_struct->mm"], "call": "mq_timedsend"}, {"reason": ["task_struct->mm"], "call": "sched_getscheduler"}, {"reason": ["task_struct->mm"], "call": "ptrace"}, {"reason": ["file->f_mapping"], "call": "shmctl"}, {"reason": ["swap_info_struct->swap_map", "swap_info_struct->flags", "swap_info_struct->inuse_pages", "swap_info_struct->cluster_info", "file->f_mapping", "swap_info_struct->prio", "page->private", "swap_info_struct->pages"], "call": "swapon"}, {"reason": ["task_struct->mm"], "call": "sched_getattr"}, {"reason": ["task_struct->mm"], "call": "getrusage"}, {"reason": ["task_struct->mm"], "call": "sched_setscheduler"}, {"reason": ["task_struct->mm"], "call": "setitimer"}, {"reason": ["task_struct->mm"], "call": "ioprio_get"}, {"reason": ["task_struct->mm"], "call": "vfork"}, {"reason": ["file->f_mapping"], "call": "mmap_pgoff"}, {"reason": ["task_struct->mm"], "call": "prctl"}, {"reason": ["task_struct->mm"], "call": "move_pages"}, {"reason": ["task_struct->mm"], "call": "setpriority"}, {"reason": ["task_struct->mm"], "call": "clone"}, {"reason": ["file->f_mapping"], "call": "mq_open"}, {"reason": ["task_struct->mm"], "call": "sched_getparam"}, {"reason": ["file->f_mapping"], "call": "open_by_handle_at"}], "getgroups16": [{"reason": ["cred->group_info", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->group_info"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->group_info"], "call": "getresuid16"}, {"reason": ["cred->group_info"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->group_info"], "call": "setgid"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->group_info"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->group_info"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->group_info"], "call": "setfsgid"}, {"reason": ["cred->group_info"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->group_info"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->group_info"], "call": "epoll_create1"}, {"reason": ["cred->group_info"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->group_info"], "call": "setresgid"}, {"reason": ["cred->group_info"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->group_info"], "call": "faccessat"}, {"reason": ["group_info->ngroups"], "call": "setgroups16"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->group_info"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->group_info"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->group_info"], "call": "getgroups"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["group_info->ngroups"], "call": "setgroups"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "newlstat": [{"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newfstatat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newstat"}, {"reason": ["kstat->size", "kstat->nlink", "kstat->ino", "kstat->rdev", "kstat->dev"], "call": "fstat"}, {"reason": ["stat->st_nlink", "kstat->nlink", "kstat->ino", "kstat->dev", "compat_stat->st_nlink", "kstat->size", "stat->st_ino", "compat_stat->st_ino", "kstat->rdev"], "call": "newfstat"}], "pkey_alloc": [{"reason": ["mm_context_t->pkey_allocation_map"], "call": "swapoff"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "remap_file_pages"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "io_getevents"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "pkey_free"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "migrate_pages"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "shmdt"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "brk"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "get_mempolicy"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "getrusage"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "io_setup"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "mremap"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "io_destroy"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "mbind"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "prctl"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "move_pages"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "modify_ldt"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "mincore"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "io_cancel"}], "readahead": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["address_space->a_ops"], "call": "mq_unlink"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["address_space->a_ops", "file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["address_space->a_ops", "file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["address_space->a_ops"], "call": "readlinkat"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "fchown"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["address_space->a_ops", "file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["address_space->a_ops"], "call": "fchmodat"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["address_space->a_ops", "file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["address_space->a_ops"], "call": "linkat"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["address_space->a_ops"], "call": "unlink"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "mq_getsetattr"}, {"reason": ["address_space->a_ops"], "call": "faccessat"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["address_space->a_ops", "file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["address_space->a_ops"], "call": "fchownat"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "mq_notify"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["address_space->a_ops"], "call": "unlinkat"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["address_space->a_ops", "fd->flags"], "call": "sendfile64"}], "newfstatat": [{"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newlstat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newstat"}, {"reason": ["kstat->size", "kstat->nlink", "kstat->ino", "kstat->rdev", "kstat->dev"], "call": "fstat"}, {"reason": ["stat->st_nlink", "kstat->nlink", "kstat->ino", "kstat->dev", "compat_stat->st_nlink", "kstat->size", "stat->st_ino", "compat_stat->st_ino", "kstat->rdev"], "call": "newfstat"}], "preadv": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "getdents": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "getresgid": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "sethostname": [{"reason": ["uts_namespace->user_ns"], "call": "setns"}], "timer_delete": [{"reason": ["task_struct->signal"], "call": "keyctl"}, {"reason": ["task_struct->signal"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->signal"], "call": "msgrcv"}, {"reason": ["task_struct->signal"], "call": "kill"}, {"reason": ["k_clock->timer_del"], "call": "clock_getres"}, {"reason": ["task_struct->signal"], "call": "sched_getaffinity"}, {"reason": ["task_struct->signal"], "call": "sched_setparam"}, {"reason": ["task_struct->signal"], "call": "ioprio_set"}, {"reason": ["task_struct->signal"], "call": "getppid"}, {"reason": ["task_struct->signal"], "call": "mq_timedreceive"}, {"reason": ["task_struct->signal"], "call": "capget"}, {"reason": ["task_struct->signal"], "call": "sched_setaffinity"}, {"reason": ["task_struct->signal"], "call": "signal"}, {"reason": ["task_struct->signal"], "call": "semtimedop"}, {"reason": ["task_struct->signal"], "call": "umount"}, {"reason": ["k_clock->timer_del", "k_itimer->it_pid", "k_itimer->it_signal", "k_itimer->sigq"], "call": "timer_create"}, {"reason": ["k_clock->timer_del"], "call": "clock_gettime"}, {"reason": ["task_struct->signal"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->signal"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->signal"], "call": "setsid"}, {"reason": ["task_struct->signal"], "call": "sigaltstack"}, {"reason": ["task_struct->signal"], "call": "sched_setattr"}, {"reason": ["task_struct->signal"], "call": "migrate_pages"}, {"reason": ["task_struct->signal"], "call": "getitimer"}, {"reason": ["task_struct->signal"], "call": "setpgid"}, {"reason": ["k_clock->timer_del", "k_itimer->it_pid", "k_itimer->it_signal", "k_itimer->sigq"], "call": "timer_settime"}, {"reason": ["k_clock->timer_del", "k_itimer->it_pid", "k_itimer->it_signal", "k_itimer->sigq"], "call": "timer_gettime"}, {"reason": ["task_struct->signal"], "call": "getsid"}, {"reason": ["task_struct->signal"], "call": "prlimit64"}, {"reason": ["task_struct->signal"], "call": "perf_event_open"}, {"reason": ["task_struct->signal"], "call": "rt_sigaction"}, {"reason": ["task_struct->signal"], "call": "getpgid"}, {"reason": ["k_clock->timer_del"], "call": "clock_settime"}, {"reason": ["task_struct->signal"], "call": "getpriority"}, {"reason": ["task_struct->signal"], "call": "sigaction"}, {"reason": ["task_struct->signal"], "call": "setns"}, {"reason": ["task_struct->signal"], "call": "fork"}, {"reason": ["task_struct->signal"], "call": "get_robust_list"}, {"reason": ["task_struct->signal"], "call": "mq_timedsend"}, {"reason": ["task_struct->signal"], "call": "sched_getscheduler"}, {"reason": ["task_struct->signal"], "call": "ptrace"}, {"reason": ["task_struct->signal"], "call": "sched_getattr"}, {"reason": ["task_struct->signal"], "call": "getrusage"}, {"reason": ["task_struct->signal"], "call": "sched_setscheduler"}, {"reason": ["task_struct->signal"], "call": "setitimer"}, {"reason": ["task_struct->signal"], "call": "ioprio_get"}, {"reason": ["task_struct->signal"], "call": "vfork"}, {"reason": ["task_struct->signal"], "call": "prctl"}, {"reason": ["task_struct->signal"], "call": "move_pages"}, {"reason": ["task_struct->signal"], "call": "setpriority"}, {"reason": ["k_itimer->it_pid", "k_itimer->it_signal", "k_itimer->sigq"], "call": "timer_getoverrun"}, {"reason": ["task_struct->signal"], "call": "clone"}, {"reason": ["k_clock->timer_del"], "call": "clock_nanosleep"}, {"reason": ["task_struct->signal"], "call": "sched_getparam"}, {"reason": ["k_clock->timer_del"], "call": "clock_adjtime"}], "pwritev2": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "fchmod": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["fd->flags", "path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "setgid": [{"reason": ["cred->user_ns", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user_ns"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user_ns"], "call": "setfsgid"}, {"reason": ["cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->user_ns"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->gid"], "call": "setresgid"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->gid"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user_ns"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->user_ns"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->user_ns"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user_ns"], "call": "getgroups"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "pivot_root": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["dentry->d_inode", "dentry->d_parent", "vfsmount->mnt_flags", "vfsmount->mnt_root"], "call": "mq_unlink"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["mount->mnt_parent", "mount->mnt_ns", "vfsmount->mnt_flags", "vfsmount->mnt_root"], "call": "umount"}, {"reason": ["dentry->d_inode", "dentry->d_parent"], "call": "mkdirat"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["dentry->d_inode", "dentry->d_parent"], "call": "renameat2"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["dentry->d_inode", "vfsmount->mnt_root", "dentry->d_parent", "path->dentry", "path->mnt", "mount->mnt_parent", "mount->mnt_ns", "vfsmount->mnt_flags"], "call": "getcwd"}, {"reason": ["dentry->d_inode", "dentry->d_parent"], "call": "ftruncate"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["dentry->d_inode", "dentry->d_parent"], "call": "mknodat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["dentry->d_inode", "dentry->d_parent"], "call": "symlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["dentry->d_inode", "dentry->d_parent"], "call": "linkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["vfsmount->mnt_flags", "path->dentry", "path->mnt", "vfsmount->mnt_root"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["dentry->d_inode", "dentry->d_parent"], "call": "unlink"}, {"reason": ["dentry->d_inode", "dentry->d_parent"], "call": "rmdir"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "nsproxy->mnt_ns", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["dentry->d_inode", "vfsmount->mnt_root", "dentry->d_parent", "path->dentry", "path->mnt", "vfsmount->mnt_flags"], "call": "mq_open"}, {"reason": ["dentry->d_inode", "dentry->d_parent"], "call": "unlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "getuid16": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "epoll_wait": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["file->f_op"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["file->f_op"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_op"], "call": "memfd_create"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["file->f_op"], "call": "remap_file_pages"}, {"reason": ["file->f_op"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["file->f_op"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["file->f_op", "fd->flags"], "call": "epoll_ctl"}, {"reason": ["file->f_op", "fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_op"], "call": "openat"}, {"reason": ["file->f_op"], "call": "uselib"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["file->f_op", "fd->flags"], "call": "accept4"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_op"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["file->f_op"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_op"], "call": "socket"}, {"reason": ["file->f_op"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["file->f_op", "mm_segment_t->seg", "fd->flags"], "call": "perf_event_open"}, {"reason": ["file->f_op"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_op"], "call": "acct"}, {"reason": ["file->f_op"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_op"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_op", "mm_segment_t->seg"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["file->f_op"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_op"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_op"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["file->f_op"], "call": "mq_open"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["file->f_op"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "ioprio_set": [{"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getparam"}], "capset": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "delete_module": [{"reason": ["module->exit", "module->init", "module->state"], "call": "init_module"}, {"reason": ["module->exit", "module->init", "module->state"], "call": "finit_module"}], "remap_file_pages": [{"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_file", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mlockall"}], "dup3": [{"reason": ["files_struct->resize_in_progress", "files_struct->fdt", "fdtable->max_fds"], "call": "unshare"}, {"reason": ["fdtable->max_fds"], "call": "select"}, {"reason": ["files_struct->resize_in_progress", "files_struct->fdt", "fdtable->max_fds"], "call": "dup2"}], "readlinkat": [{"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["path->dentry"], "call": "swapoff"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["path->dentry"], "call": "epoll_ctl"}, {"reason": ["path->dentry"], "call": "flock"}, {"reason": ["path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["path->dentry"], "call": "uselib"}, {"reason": ["path->dentry"], "call": "accept4"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["path->dentry"], "call": "shmat"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["path->dentry"], "call": "quotactl"}, {"reason": ["path->dentry"], "call": "acct"}, {"reason": ["path->dentry"], "call": "open"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["path->dentry"], "call": "setns"}, {"reason": ["path->dentry"], "call": "shmctl"}, {"reason": ["path->dentry"], "call": "swapon"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["path->dentry"], "call": "mq_open"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}], "read": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "getppid": [{"reason": ["task_struct->real_parent"], "call": "keyctl"}, {"reason": ["task_struct->real_parent"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->real_parent"], "call": "msgrcv"}, {"reason": ["task_struct->real_parent"], "call": "kill"}, {"reason": ["task_struct->real_parent"], "call": "sched_getaffinity"}, {"reason": ["task_struct->real_parent"], "call": "sched_setparam"}, {"reason": ["task_struct->real_parent"], "call": "ioprio_set"}, {"reason": ["task_struct->real_parent"], "call": "mq_timedreceive"}, {"reason": ["task_struct->real_parent"], "call": "capget"}, {"reason": ["task_struct->real_parent"], "call": "sched_setaffinity"}, {"reason": ["task_struct->real_parent"], "call": "signal"}, {"reason": ["task_struct->real_parent"], "call": "semtimedop"}, {"reason": ["task_struct->real_parent"], "call": "umount"}, {"reason": ["task_struct->real_parent"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->real_parent"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->real_parent"], "call": "setsid"}, {"reason": ["task_struct->real_parent"], "call": "sigaltstack"}, {"reason": ["task_struct->real_parent"], "call": "sched_setattr"}, {"reason": ["task_struct->real_parent"], "call": "migrate_pages"}, {"reason": ["task_struct->real_parent"], "call": "getitimer"}, {"reason": ["task_struct->real_parent"], "call": "setpgid"}, {"reason": ["task_struct->real_parent"], "call": "getsid"}, {"reason": ["task_struct->real_parent"], "call": "prlimit64"}, {"reason": ["task_struct->real_parent"], "call": "perf_event_open"}, {"reason": ["task_struct->real_parent"], "call": "rt_sigaction"}, {"reason": ["task_struct->real_parent"], "call": "getpgid"}, {"reason": ["task_struct->real_parent"], "call": "getpriority"}, {"reason": ["task_struct->real_parent"], "call": "sigaction"}, {"reason": ["task_struct->real_parent"], "call": "setns"}, {"reason": ["task_struct->real_parent"], "call": "fork"}, {"reason": ["task_struct->real_parent"], "call": "get_robust_list"}, {"reason": ["task_struct->real_parent"], "call": "mq_timedsend"}, {"reason": ["task_struct->real_parent"], "call": "sched_getscheduler"}, {"reason": ["task_struct->real_parent"], "call": "ptrace"}, {"reason": ["task_struct->real_parent"], "call": "sched_getattr"}, {"reason": ["task_struct->real_parent"], "call": "getrusage"}, {"reason": ["task_struct->real_parent"], "call": "sched_setscheduler"}, {"reason": ["task_struct->real_parent"], "call": "setitimer"}, {"reason": ["task_struct->real_parent"], "call": "ioprio_get"}, {"reason": ["task_struct->real_parent"], "call": "vfork"}, {"reason": ["task_struct->real_parent"], "call": "prctl"}, {"reason": ["task_struct->real_parent"], "call": "move_pages"}, {"reason": ["task_struct->real_parent"], "call": "setpriority"}, {"reason": ["task_struct->real_parent"], "call": "clone"}, {"reason": ["task_struct->real_parent"], "call": "sched_getparam"}], "fchown": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["path->dentry"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "path->dentry"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "path->dentry"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["path->dentry"], "call": "uselib"}, {"reason": ["fd->flags", "path->dentry"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["path->dentry"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["path->dentry"], "call": "quotactl"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["path->dentry"], "call": "acct"}, {"reason": ["path->dentry"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["path->dentry"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["path->dentry"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["path->dentry"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["path->dentry"], "call": "mq_open"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "stat": [{"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "lstat"}, {"reason": ["kstat->ino", "kstat->nlink", "__old_kernel_stat->st_nlink", "kstat->dev", "__old_kernel_stat->st_ino", "kstat->rdev"], "call": "fstat"}, {"reason": ["kstat->ino", "kstat->nlink", "kstat->rdev", "kstat->dev"], "call": "newfstat"}], "ioperm": [{"reason": ["thread_struct->io_bitmap_ptr"], "call": "keyctl"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "rt_sigtimedwait"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "msgrcv"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "kill"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_getaffinity"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_setparam"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "ioprio_set"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getppid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "mq_timedreceive"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "capget"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_setaffinity"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "signal"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "semtimedop"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "umount"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_rr_get_interval"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "rt_sigprocmask"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setsid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sigaltstack"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_setattr"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "migrate_pages"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getitimer"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setpgid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getsid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "prlimit64"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "perf_event_open"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "rt_sigaction"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getpgid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getpriority"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sigaction"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setns"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "fork"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "get_robust_list"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "mq_timedsend"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_getscheduler"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "ptrace"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_getattr"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getrusage"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_setscheduler"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setitimer"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "ioprio_get"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "vfork"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "prctl"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "move_pages"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setpriority"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "clone"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_getparam"}], "mq_timedreceive": [{"reason": ["msg_msg->m_ts"], "call": "msgrcv"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "dup3"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "flock"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "openat"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "uselib"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "accept4"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "shmat"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "socket"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "acct"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "open"}, {"reason": ["mqueue_inode_info->node_cache", "mq_attr->mq_curmsgs", "file->f_flags", "mq_attr->mq_msgsize"], "call": "mq_getsetattr"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "dup"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "setns"}, {"reason": ["mqueue_inode_info->node_cache", "mq_attr->mq_curmsgs", "msg_msg->m_ts", "mq_attr->mq_msgsize"], "call": "mq_timedsend"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["msg_msg->m_ts"], "call": "msgsnd"}, {"reason": ["mqueue_inode_info->node_cache", "mq_attr->mq_curmsgs", "mq_attr->mq_msgsize"], "call": "mq_notify"}, {"reason": ["file->f_op", "mq_attr->mq_curmsgs", "file->f_mode", "file->f_flags", "mq_attr->mq_msgsize"], "call": "mq_open"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "open_by_handle_at"}], "utime": [{"reason": ["timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_nsec"], "call": "ppoll"}], "sched_setaffinity": [{"reason": ["cred->user_ns", "task_struct->real_cred", "task_struct->flags"], "call": "keyctl"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user_ns"], "call": "setfsuid"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "msgrcv"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "kill"}, {"reason": ["cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sched_setparam"}, {"reason": ["cred->user_ns"], "call": "setgid"}, {"reason": ["cred->user_ns", "task_struct->real_cred", "task_struct->flags"], "call": "ioprio_set"}, {"reason": ["cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "getppid"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "capget"}, {"reason": ["cred->user_ns"], "call": "setfsgid"}, {"reason": ["cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "signal"}, {"reason": ["cred->user_ns", "task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "semtimedop"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "umount"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "setsid"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sigaltstack"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sched_setattr"}, {"reason": ["cred->user_ns", "task_struct->real_cred", "task_struct->flags"], "call": "migrate_pages"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "getitimer"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "setpgid"}, {"reason": ["cred->user_ns"], "call": "setresgid"}, {"reason": ["cred->user_ns"], "call": "setregid"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "getsid"}, {"reason": ["cred->user_ns", "task_struct->real_cred", "task_struct->flags"], "call": "prlimit64"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "perf_event_open"}, {"reason": ["cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "getpgid"}, {"reason": ["cred->user_ns", "task_struct->real_cred", "task_struct->flags"], "call": "getpriority"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sigaction"}, {"reason": ["cred->user_ns"], "call": "faccessat"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "setns"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "fork"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "get_robust_list"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "ptrace"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sched_getattr"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "getrusage"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["cred->user_ns", "task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "setitimer"}, {"reason": ["cred->user_ns", "task_struct->real_cred", "task_struct->flags"], "call": "ioprio_get"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "vfork"}, {"reason": ["cred->user_ns", "task_struct->flags"], "call": "setuid"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "prctl"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "move_pages"}, {"reason": ["cred->user_ns"], "call": "getgroups"}, {"reason": ["cred->user_ns", "task_struct->real_cred", "task_struct->flags"], "call": "setpriority"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "clone"}, {"reason": ["task_struct->real_cred", "task_struct->flags"], "call": "sched_getparam"}], "ustat": [{"reason": ["super_block->s_root"], "call": "syncfs"}, {"reason": ["super_block->s_root"], "call": "umount"}, {"reason": ["super_block->s_root"], "call": "quotactl"}, {"reason": ["super_block->s_root"], "call": "swapon"}], "setfsgid": [{"reason": ["cred->user_ns", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user_ns"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->gid", "cred->egid", "cred->fsgid"], "call": "setgid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->user_ns"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->gid", "cred->egid", "cred->fsgid"], "call": "setresgid"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->gid", "cred->egid", "cred->fsgid"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user_ns", "cred->fsgid"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->user_ns"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->user_ns"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user_ns"], "call": "getgroups"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "bpf": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["file->f_op", "file->private_data"], "call": "eventfd2"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["file->f_op", "file->private_data"], "call": "swapoff"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["file->f_op", "file->private_data"], "call": "memfd_create"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["file->f_op", "file->private_data"], "call": "remap_file_pages"}, {"reason": ["file->f_op", "file->private_data"], "call": "dup3"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["file->f_op", "file->private_data"], "call": "epoll_create1"}, {"reason": ["file->f_op", "file->private_data"], "call": "epoll_ctl"}, {"reason": ["file->f_op", "file->private_data"], "call": "flock"}, {"reason": ["file->f_op", "file->private_data"], "call": "openat"}, {"reason": ["file->f_op", "file->private_data"], "call": "uselib"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["file->f_op", "file->private_data"], "call": "accept4"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["file->f_op", "file->private_data"], "call": "socketpair"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["file->f_op", "file->private_data"], "call": "shmat"}, {"reason": ["file->f_op", "file->private_data"], "call": "socket"}, {"reason": ["file->f_op", "file->private_data"], "call": "pipe2"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["file->f_op", "mm_segment_t->seg", "bpf_prog->aux", "file->private_data"], "call": "perf_event_open"}, {"reason": ["file->f_op", "file->private_data"], "call": "shmdt"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["file->f_op", "file->private_data"], "call": "acct"}, {"reason": ["file->f_op", "file->private_data"], "call": "open"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["file->f_op", "file->private_data"], "call": "dup"}, {"reason": ["file->f_op", "mm_segment_t->seg", "file->private_data"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["file->f_op", "file->private_data"], "call": "shmctl"}, {"reason": ["file->f_op", "file->private_data"], "call": "swapon"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["file->f_op", "file->private_data"], "call": "mmap_pgoff"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["file->f_op", "file->private_data"], "call": "mq_open"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["file->f_op", "file->private_data"], "call": "open_by_handle_at"}], "newstat": [{"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newlstat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newfstatat"}, {"reason": ["kstat->size", "kstat->nlink", "kstat->ino", "kstat->rdev", "kstat->dev"], "call": "fstat"}, {"reason": ["stat->st_nlink", "kstat->nlink", "kstat->ino", "kstat->dev", "compat_stat->st_nlink", "kstat->size", "stat->st_ino", "compat_stat->st_ino", "kstat->rdev"], "call": "newfstat"}], "setreuid": [{"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setgid"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user", "cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setfsgid"}, {"reason": ["cred->user", "cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user", "cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setresgid"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user", "cred->user_ns"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->uid", "cred->user", "cred->suid", "cred->euid", "cred->user_ns"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->uid", "cred->user", "cred->suid", "cred->euid", "cred->user_ns"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getgroups"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "semtimedop": [{"reason": ["list_head->prev"], "call": "syncfs"}, {"reason": ["list_head->prev"], "call": "keyctl"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["list_head->prev"], "call": "vmsplice"}, {"reason": ["kern_ipc_perm->deleted", "list_head->prev"], "call": "msgrcv"}, {"reason": ["list_head->prev"], "call": "eventfd2"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["list_head->prev"], "call": "kill"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["list_head->prev"], "call": "readahead"}, {"reason": ["list_head->prev"], "call": "timer_delete"}, {"reason": ["list_head->prev"], "call": "sched_getaffinity"}, {"reason": ["list_head->prev"], "call": "sched_setparam"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["list_head->prev"], "call": "setgid"}, {"reason": ["list_head->prev"], "call": "pivot_root"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["list_head->prev"], "call": "ioprio_set"}, {"reason": ["list_head->prev"], "call": "delete_module"}, {"reason": ["list_head->prev"], "call": "remap_file_pages"}, {"reason": ["list_head->prev"], "call": "dup3"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["list_head->prev"], "call": "getppid"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["list_head->prev"], "call": "capget"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["list_head->prev"], "call": "sched_setaffinity"}, {"reason": ["list_head->prev"], "call": "ustat"}, {"reason": ["list_head->prev"], "call": "bpf"}, {"reason": ["list_head->prev"], "call": "unshare"}, {"reason": ["list_head->prev"], "call": "signal"}, {"reason": ["list_head->prev"], "call": "setreuid"}, {"reason": ["list_head->prev"], "call": "umount"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["list_head->prev"], "call": "timer_create"}, {"reason": ["list_head->prev"], "call": "mkdirat"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["list_head->prev"], "call": "epoll_create1"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["list_head->prev"], "call": "tee"}, {"reason": ["kern_ipc_perm->deleted", "sem_array->sem_nsems", "sem_array->use_global_lock", "sem_array->complex_count", "sem_undo->semid", "list_head->prev"], "call": "semctl"}, {"reason": ["list_head->prev"], "call": "sync_file_range"}, {"reason": ["list_head->prev"], "call": "epoll_ctl"}, {"reason": ["list_head->prev"], "call": "flock"}, {"reason": ["list_head->prev"], "call": "openat"}, {"reason": ["list_head->prev"], "call": "lookup_dcookie"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["list_head->prev"], "call": "renameat2"}, {"reason": ["list_head->prev"], "call": "rt_sigprocmask"}, {"reason": ["list_head->prev"], "call": "accept4"}, {"reason": ["kern_ipc_perm->deleted", "list_head->prev"], "call": "msgctl"}, {"reason": ["list_head->prev"], "call": "reboot"}, {"reason": ["list_head->prev"], "call": "setsid"}, {"reason": ["list_head->prev"], "call": "set_trip_temp"}, {"reason": ["list_head->prev"], "call": "sigaltstack"}, {"reason": ["list_head->prev"], "call": "sched_setattr"}, {"reason": ["list_head->prev"], "call": "inotify_rm_watch"}, {"reason": ["list_head->prev"], "call": "socketpair"}, {"reason": ["list_head->prev"], "call": "migrate_pages"}, {"reason": ["list_head->prev"], "call": "getitimer"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["list_head->prev"], "call": "setpgid"}, {"reason": ["list_head->prev"], "call": "init_module"}, {"reason": ["list_head->prev"], "call": "setresgid"}, {"reason": ["list_head->prev"], "call": "getcwd"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["list_head->prev"], "call": "get_trip_temp"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["list_head->prev"], "call": "setregid"}, {"reason": ["list_head->prev"], "call": "splice"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["list_head->prev"], "call": "getsid"}, {"reason": ["kern_ipc_perm->deleted", "list_head->prev"], "call": "shmat"}, {"reason": ["list_head->prev"], "call": "mknodat"}, {"reason": ["list_head->prev"], "call": "socket"}, {"reason": ["list_head->prev"], "call": "symlinkat"}, {"reason": ["list_head->prev"], "call": "pipe2"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["list_head->prev"], "call": "prlimit64"}, {"reason": ["list_head->prev"], "call": "perf_event_open"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["list_head->prev"], "call": "getgroups16"}, {"reason": ["list_head->prev"], "call": "shmdt"}, {"reason": ["list_head->prev"], "call": "quotactl"}, {"reason": ["list_head->prev"], "call": "rt_sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["list_head->prev"], "call": "request_key"}, {"reason": ["list_head->prev"], "call": "getpgid"}, {"reason": ["list_head->prev"], "call": "brk"}, {"reason": ["list_head->prev"], "call": "acct"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["list_head->prev"], "call": "open"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["list_head->prev"], "call": "exit_group"}, {"reason": ["list_head->prev"], "call": "getpriority"}, {"reason": ["list_head->prev"], "call": "sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["list_head->prev"], "call": "rmdir"}, {"reason": ["list_head->prev"], "call": "dup"}, {"reason": ["list_head->prev"], "call": "setgroups16"}, {"reason": ["list_head->prev"], "call": "setns"}, {"reason": ["list_head->prev"], "call": "fork"}, {"reason": ["list_head->prev"], "call": "get_mempolicy"}, {"reason": ["list_head->prev"], "call": "io_submit"}, {"reason": ["list_head->prev"], "call": "get_robust_list"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["list_head->prev"], "call": "sched_yield"}, {"reason": ["list_head->prev"], "call": "sched_getscheduler"}, {"reason": ["list_head->prev"], "call": "ptrace"}, {"reason": ["kern_ipc_perm->deleted", "list_head->prev"], "call": "shmctl"}, {"reason": ["list_head->prev"], "call": "munlockall"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["list_head->prev"], "call": "pkey_mprotect"}, {"reason": ["list_head->prev"], "call": "madvise"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["list_head->prev"], "call": "sched_getattr"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["list_head->prev"], "call": "getrusage"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fstat"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["list_head->prev"], "call": "sched_setscheduler"}, {"reason": ["list_head->prev"], "call": "setresuid"}, {"reason": ["list_head->prev"], "call": "setitimer"}, {"reason": ["list_head->prev"], "call": "ioprio_get"}, {"reason": ["list_head->prev"], "call": "vfork"}, {"reason": ["list_head->prev"], "call": "setuid"}, {"reason": ["list_head->prev"], "call": "io_setup"}, {"reason": ["list_head->prev"], "call": "mprotect"}, {"reason": ["list_head->prev"], "call": "mmap_pgoff"}, {"reason": ["list_head->prev"], "call": "mremap"}, {"reason": ["list_head->prev"], "call": "io_destroy"}, {"reason": ["list_head->prev"], "call": "mbind"}, {"reason": ["list_head->prev"], "call": "prctl"}, {"reason": ["list_head->prev"], "call": "move_pages"}, {"reason": ["list_head->prev"], "call": "timerfd_create"}, {"reason": ["list_head->prev"], "call": "modify_ldt"}, {"reason": ["list_head->prev"], "call": "getgroups"}, {"reason": ["list_head->prev"], "call": "dup2"}, {"reason": ["list_head->prev"], "call": "get_curr_temp"}, {"reason": ["kern_ipc_perm->deleted", "list_head->prev"], "call": "msgsnd"}, {"reason": ["list_head->prev"], "call": "munlock"}, {"reason": ["list_head->prev"], "call": "setpriority"}, {"reason": ["list_head->prev"], "call": "inotify_init1"}, {"reason": ["list_head->prev"], "call": "mincore"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["list_head->prev"], "call": "timer_getoverrun"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["list_head->prev"], "call": "kexec_load"}, {"reason": ["list_head->prev"], "call": "clone"}, {"reason": ["list_head->prev"], "call": "mq_open"}, {"reason": ["list_head->prev"], "call": "setgroups"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["list_head->prev"], "call": "sched_getparam"}, {"reason": ["list_head->prev"], "call": "io_cancel"}, {"reason": ["list_head->prev"], "call": "open_by_handle_at"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["list_head->prev"], "call": "finit_module"}, {"reason": ["list_head->prev", "timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["list_head->prev"], "call": "mlockall"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "umount": [{"reason": ["super_block->s_flags"], "call": "syncfs"}, {"reason": ["task_struct->flags"], "call": "keyctl"}, {"reason": ["task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->flags"], "call": "msgrcv"}, {"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["vfsmount->mnt_flags", "vfsmount->mnt_root"], "call": "mq_unlink"}, {"reason": ["task_struct->flags"], "call": "kill"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["task_struct->flags"], "call": "sched_setparam"}, {"reason": ["mount->mnt_ns", "vfsmount->mnt_flags", "path->dentry", "path->mnt", "vfsmount->mnt_root"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["task_struct->flags"], "call": "ioprio_set"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["task_struct->flags"], "call": "getppid"}, {"reason": ["task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["task_struct->flags"], "call": "capget"}, {"reason": ["task_struct->flags"], "call": "sched_setaffinity"}, {"reason": ["super_block->s_flags"], "call": "ustat"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["task_struct->flags"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->flags"], "call": "semtimedop"}, {"reason": ["task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["task_struct->flags"], "call": "setsid"}, {"reason": ["task_struct->flags"], "call": "sigaltstack"}, {"reason": ["task_struct->flags"], "call": "sched_setattr"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["task_struct->flags"], "call": "migrate_pages"}, {"reason": ["task_struct->flags"], "call": "getitimer"}, {"reason": ["task_struct->flags"], "call": "setpgid"}, {"reason": ["mount->mnt_ns", "vfsmount->mnt_flags", "path->dentry", "path->mnt", "vfsmount->mnt_root"], "call": "getcwd"}, {"reason": ["task_struct->flags"], "call": "getsid"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["task_struct->flags"], "call": "prlimit64"}, {"reason": ["path->dentry", "task_struct->flags", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt", "super_block->s_flags"], "call": "quotactl"}, {"reason": ["task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["task_struct->flags"], "call": "getpgid"}, {"reason": ["vfsmount->mnt_flags", "path->dentry", "path->mnt", "vfsmount->mnt_root"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["task_struct->flags"], "call": "getpriority"}, {"reason": ["task_struct->flags"], "call": "sigaction"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "nsproxy->mnt_ns", "task_struct->flags", "path->mnt"], "call": "setns"}, {"reason": ["task_struct->flags"], "call": "fork"}, {"reason": ["task_struct->flags"], "call": "get_robust_list"}, {"reason": ["task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["task_struct->flags"], "call": "ptrace"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt", "super_block->s_flags"], "call": "swapon"}, {"reason": ["task_struct->flags"], "call": "sched_getattr"}, {"reason": ["task_struct->flags"], "call": "getrusage"}, {"reason": ["task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->flags"], "call": "setitimer"}, {"reason": ["task_struct->flags"], "call": "ioprio_get"}, {"reason": ["task_struct->flags"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["task_struct->flags"], "call": "prctl"}, {"reason": ["task_struct->flags"], "call": "move_pages"}, {"reason": ["task_struct->flags"], "call": "setpriority"}, {"reason": ["task_struct->flags"], "call": "clone"}, {"reason": ["vfsmount->mnt_flags", "path->dentry", "path->mnt", "vfsmount->mnt_root"], "call": "mq_open"}, {"reason": ["task_struct->flags"], "call": "sched_getparam"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "recvfrom": [{"reason": ["file->f_flags"], "call": "eventfd2"}, {"reason": ["file->f_flags"], "call": "swapoff"}, {"reason": ["file->f_flags"], "call": "memfd_create"}, {"reason": ["file->f_flags"], "call": "remap_file_pages"}, {"reason": ["file->f_flags"], "call": "dup3"}, {"reason": ["file->f_flags"], "call": "epoll_create1"}, {"reason": ["file->f_flags"], "call": "epoll_ctl"}, {"reason": ["file->f_flags"], "call": "flock"}, {"reason": ["file->f_flags"], "call": "openat"}, {"reason": ["file->f_flags"], "call": "uselib"}, {"reason": ["file->f_flags"], "call": "accept4"}, {"reason": ["file->f_flags"], "call": "socketpair"}, {"reason": ["file->f_flags"], "call": "shmat"}, {"reason": ["file->f_flags"], "call": "socket"}, {"reason": ["file->f_flags"], "call": "pipe2"}, {"reason": ["file->f_flags"], "call": "perf_event_open"}, {"reason": ["file->f_flags"], "call": "shmdt"}, {"reason": ["file->f_flags"], "call": "acct"}, {"reason": ["file->f_flags"], "call": "open"}, {"reason": ["file->f_flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_flags"], "call": "dup"}, {"reason": ["file->f_flags"], "call": "setns"}, {"reason": ["file->f_flags"], "call": "shmctl"}, {"reason": ["file->f_flags"], "call": "swapon"}, {"reason": ["file->f_flags"], "call": "mmap_pgoff"}, {"reason": ["file->f_flags"], "call": "mq_open"}, {"reason": ["file->f_flags"], "call": "open_by_handle_at"}], "old_readdir": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "setrlimit": [{"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "keyctl"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "msgrcv"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "kill"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sched_getaffinity"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sched_setparam"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "ioprio_set"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "getppid"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "mq_timedreceive"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "capget"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sched_setaffinity"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "signal"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "semtimedop"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "umount"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "setsid"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sigaltstack"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sched_setattr"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "migrate_pages"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "getitimer"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "setpgid"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "getsid"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "old_getrlimit"}, {"reason": ["task_struct->sighand", "rlimit->rlim_max", "task_struct->group_leader", "rlimit->rlim_cur"], "call": "prlimit64"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "perf_event_open"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "rt_sigaction"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "getpgid"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "getpriority"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sigaction"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "setns"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "fork"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "get_robust_list"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "mq_timedsend"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sched_getscheduler"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "ptrace"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sched_getattr"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "getrusage"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sched_setscheduler"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "setitimer"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "ioprio_get"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "vfork"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "prctl"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "move_pages"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "setpriority"}, {"reason": ["compat_rlimit->rlim_cur", "compat_rlimit->rlim_max"], "call": "getrlimit"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "clone"}, {"reason": ["task_struct->sighand", "task_struct->group_leader"], "call": "sched_getparam"}], "timer_create": [{"reason": ["k_clock->timer_create"], "call": "clock_getres"}, {"reason": ["k_itimer->it_pid", "k_clock->timer_create"], "call": "timer_delete"}, {"reason": ["k_clock->timer_create"], "call": "clock_gettime"}, {"reason": ["k_itimer->it_pid", "k_clock->timer_create"], "call": "timer_settime"}, {"reason": ["k_itimer->it_pid", "k_clock->timer_create"], "call": "timer_gettime"}, {"reason": ["k_clock->timer_create"], "call": "clock_settime"}, {"reason": ["k_itimer->it_pid"], "call": "timer_getoverrun"}, {"reason": ["k_clock->timer_create"], "call": "clock_nanosleep"}, {"reason": ["k_clock->timer_create"], "call": "clock_adjtime"}], "sendto": [{"reason": ["file->f_flags"], "call": "eventfd2"}, {"reason": ["file->f_flags"], "call": "swapoff"}, {"reason": ["file->f_flags"], "call": "memfd_create"}, {"reason": ["file->f_flags"], "call": "remap_file_pages"}, {"reason": ["file->f_flags"], "call": "dup3"}, {"reason": ["file->f_flags"], "call": "epoll_create1"}, {"reason": ["file->f_flags"], "call": "epoll_ctl"}, {"reason": ["file->f_flags"], "call": "flock"}, {"reason": ["file->f_flags"], "call": "openat"}, {"reason": ["file->f_flags"], "call": "uselib"}, {"reason": ["file->f_flags"], "call": "accept4"}, {"reason": ["file->f_flags"], "call": "socketpair"}, {"reason": ["file->f_flags"], "call": "shmat"}, {"reason": ["file->f_flags"], "call": "socket"}, {"reason": ["file->f_flags"], "call": "pipe2"}, {"reason": ["file->f_flags"], "call": "perf_event_open"}, {"reason": ["file->f_flags"], "call": "shmdt"}, {"reason": ["file->f_flags"], "call": "acct"}, {"reason": ["file->f_flags"], "call": "open"}, {"reason": ["file->f_flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_flags"], "call": "dup"}, {"reason": ["file->f_flags"], "call": "setns"}, {"reason": ["file->f_flags"], "call": "shmctl"}, {"reason": ["file->f_flags"], "call": "swapon"}, {"reason": ["file->f_flags"], "call": "mmap_pgoff"}, {"reason": ["file->f_flags"], "call": "mq_open"}, {"reason": ["file->f_flags"], "call": "open_by_handle_at"}], "mkdirat": [{"reason": ["super_block->s_flags"], "call": "syncfs"}, {"reason": ["super_block->s_flags"], "call": "ustat"}, {"reason": ["super_block->s_flags"], "call": "umount"}, {"reason": ["super_block->s_flags"], "call": "quotactl"}, {"reason": ["super_block->s_flags"], "call": "swapon"}], "lgetxattr": [{"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["path->dentry"], "call": "swapoff"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["path->dentry"], "call": "epoll_ctl"}, {"reason": ["path->dentry"], "call": "flock"}, {"reason": ["path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["path->dentry"], "call": "uselib"}, {"reason": ["path->dentry"], "call": "accept4"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["path->dentry"], "call": "shmat"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["path->dentry"], "call": "quotactl"}, {"reason": ["path->dentry"], "call": "acct"}, {"reason": ["path->dentry"], "call": "open"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["path->dentry"], "call": "setns"}, {"reason": ["path->dentry"], "call": "shmctl"}, {"reason": ["path->dentry"], "call": "swapon"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["path->dentry"], "call": "mq_open"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}], "linkat": [{"reason": ["path->mnt"], "call": "eventfd2"}, {"reason": ["path->mnt"], "call": "swapoff"}, {"reason": ["path->mnt"], "call": "pivot_root"}, {"reason": ["path->mnt"], "call": "memfd_create"}, {"reason": ["path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->mnt"], "call": "dup3"}, {"reason": ["path->mnt"], "call": "unshare"}, {"reason": ["path->mnt"], "call": "epoll_create1"}, {"reason": ["path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->mnt"], "call": "flock"}, {"reason": ["path->mnt"], "call": "openat"}, {"reason": ["path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->mnt"], "call": "uselib"}, {"reason": ["path->mnt"], "call": "accept4"}, {"reason": ["path->mnt"], "call": "socketpair"}, {"reason": ["path->mnt"], "call": "getcwd"}, {"reason": ["path->mnt"], "call": "shmat"}, {"reason": ["path->mnt"], "call": "socket"}, {"reason": ["path->mnt"], "call": "pipe2"}, {"reason": ["path->mnt"], "call": "perf_event_open"}, {"reason": ["path->mnt"], "call": "shmdt"}, {"reason": ["path->mnt"], "call": "quotactl"}, {"reason": ["path->mnt"], "call": "acct"}, {"reason": ["path->mnt"], "call": "open"}, {"reason": ["path->mnt"], "call": "dup"}, {"reason": ["path->mnt"], "call": "setns"}, {"reason": ["path->mnt"], "call": "shmctl"}, {"reason": ["path->mnt"], "call": "swapon"}, {"reason": ["path->mnt"], "call": "mmap_pgoff"}, {"reason": ["path->mnt"], "call": "mq_open"}, {"reason": ["path->mnt"], "call": "open_by_handle_at"}], "getresuid16": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "newuname": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}], "epoll_create1": [{"reason": ["cred->user", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->user"], "call": "getresuid16"}, {"reason": ["cred->user"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user"], "call": "setgid"}, {"reason": ["cred->user", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->user", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user"], "call": "setfsgid"}, {"reason": ["cred->user"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->user"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user"], "call": "getresuid"}, {"reason": ["eventpoll->ws", "eventpoll->user"], "call": "epoll_ctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->user", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user"], "call": "setresgid"}, {"reason": ["cred->user"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->user", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->user", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["eventpoll->ws", "eventpoll->user"], "call": "epoll_wait"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->user"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->user", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->user"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user"], "call": "getgroups"}, {"reason": ["cred->user", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "olduname": [{"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "kill"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "capget"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "signal"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "umount"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setsid"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getsid"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setns"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "fork"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "vfork"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "prctl"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "clone"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_getparam"}], "tee": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "semctl": [{"reason": ["sem_array->sem_nsems"], "call": "semtimedop"}], "syslog": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "rt_sigqueueinfo": [{"reason": ["siginfo->si_code"], "call": "rt_sigtimedwait"}, {"reason": ["siginfo->si_code"], "call": "kill"}, {"reason": ["siginfo->si_code"], "call": "timer_create"}, {"reason": ["siginfo->si_code"], "call": "tgkill"}, {"reason": ["siginfo->si_code"], "call": "rt_tgsigqueueinfo"}, {"reason": ["siginfo->si_code"], "call": "rt_sigreturn"}, {"reason": ["siginfo->si_code"], "call": "tkill"}], "sync_file_range": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "llseek": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "getgid": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "lsetxattr": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "pwritev": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "llistxattr": [{"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["path->dentry"], "call": "swapoff"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["path->dentry"], "call": "epoll_ctl"}, {"reason": ["path->dentry"], "call": "flock"}, {"reason": ["path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["path->dentry"], "call": "uselib"}, {"reason": ["path->dentry"], "call": "accept4"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["path->dentry"], "call": "shmat"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["path->dentry"], "call": "quotactl"}, {"reason": ["path->dentry"], "call": "acct"}, {"reason": ["path->dentry"], "call": "open"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["path->dentry"], "call": "setns"}, {"reason": ["path->dentry"], "call": "shmctl"}, {"reason": ["path->dentry"], "call": "swapon"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["path->dentry"], "call": "mq_open"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}], "tgkill": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "pselect6": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "uselib": [{"reason": ["super_block->s_iflags"], "call": "syncfs"}, {"reason": ["vfsmount->mnt_flags"], "call": "mq_unlink"}, {"reason": ["vfsmount->mnt_flags"], "call": "pivot_root"}, {"reason": ["super_block->s_iflags"], "call": "ustat"}, {"reason": ["vfsmount->mnt_flags", "super_block->s_iflags"], "call": "umount"}, {"reason": ["vfsmount->mnt_flags"], "call": "getcwd"}, {"reason": ["super_block->s_iflags"], "call": "quotactl"}, {"reason": ["vfsmount->mnt_flags"], "call": "acct"}, {"reason": ["super_block->s_iflags"], "call": "swapon"}, {"reason": ["vfsmount->mnt_flags"], "call": "mq_open"}], "sysfs": [{"reason": ["filename->name"], "call": "mq_unlink"}, {"reason": ["filename->name"], "call": "swapoff"}, {"reason": ["filename->name"], "call": "openat"}, {"reason": ["filename->name"], "call": "uselib"}, {"reason": ["filename->name"], "call": "renameat2"}, {"reason": ["filename->name"], "call": "symlinkat"}, {"reason": ["filename->name"], "call": "quotactl"}, {"reason": ["filename->name"], "call": "acct"}, {"reason": ["filename->name"], "call": "open"}, {"reason": ["filename->name"], "call": "unlink"}, {"reason": ["filename->name"], "call": "rmdir"}, {"reason": ["filename->name"], "call": "swapon"}, {"reason": ["filename->name"], "call": "mq_open"}, {"reason": ["filename->name"], "call": "unlinkat"}], "msgctl": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["ipc_namespace->msg_ctlmnb", "mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "mq_unlink"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "msgget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["ipc_namespace->msg_ctlmnb", "mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "semctl"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "shmget"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "semget"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "shmat"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["ipc_namespace->msg_ctlmnb", "mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "shmctl"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "msgsnd"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "mq_open"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "reboot": [{"reason": ["pid_namespace->user_ns"], "call": "perf_event_open"}, {"reason": ["pid_namespace->user_ns"], "call": "acct"}, {"reason": ["pid_namespace->user_ns"], "call": "setns"}], "fremovexattr": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "setsid": [{"reason": ["signal_struct->leader"], "call": "timer_create"}, {"reason": ["signal_struct->leader"], "call": "exit_group"}], "timerfd_create": [{"reason": ["timerfd_ctx->clockid"], "call": "timerfd_gettime"}, {"reason": ["timerfd_ctx->clockid"], "call": "timerfd_settime"}], "set_trip_temp": [{"reason": ["pkg_device->cpu", "pkg_device->tj_max"], "call": "get_trip_temp"}, {"reason": ["pkg_device->cpu", "pkg_device->tj_max"], "call": "get_curr_temp"}], "sched_setattr": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg", "sched_attr->sched_policy"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "inotify_rm_watch": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_op"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_op"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_op"], "call": "memfd_create"}, {"reason": ["file->f_op"], "call": "remap_file_pages"}, {"reason": ["file->f_op"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_op"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["file->f_op", "fd->flags"], "call": "epoll_ctl"}, {"reason": ["file->f_op", "fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_op"], "call": "openat"}, {"reason": ["file->f_op"], "call": "uselib"}, {"reason": ["file->f_op", "fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["file->f_op"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_op"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_op"], "call": "socket"}, {"reason": ["file->f_op"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["file->f_op", "fd->flags"], "call": "perf_event_open"}, {"reason": ["file->f_op"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_op"], "call": "acct"}, {"reason": ["file->f_op"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_op"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_op"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_op"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_op"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_op"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_op"], "call": "mq_open"}, {"reason": ["file->f_op"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "renameat2": [{"reason": ["filename->refcnt", "filename->name"], "call": "sysfs"}, {"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["dentry->d_inode", "filename->refcnt", "filename->name"], "call": "mq_unlink"}, {"reason": ["filename->refcnt", "filename->name", "path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["dentry->d_inode"], "call": "mkdirat"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["filename->refcnt", "filename->name", "path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["filename->refcnt", "filename->name", "path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["dentry->d_inode"], "call": "ftruncate"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["dentry->d_inode"], "call": "mknodat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["dentry->d_inode", "filename->refcnt", "filename->name"], "call": "symlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["dentry->d_inode"], "call": "linkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["filename->refcnt", "filename->name", "path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["filename->refcnt", "filename->name", "path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["filename->refcnt", "filename->name", "path->dentry", "path->mnt"], "call": "open"}, {"reason": ["dentry->d_inode", "filename->refcnt", "filename->name"], "call": "unlink"}, {"reason": ["dentry->d_inode", "filename->refcnt", "filename->name"], "call": "rmdir"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["filename->refcnt", "filename->name", "path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["dentry->d_inode", "filename->refcnt", "filename->name", "path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["dentry->d_inode", "filename->refcnt", "filename->name"], "call": "unlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "keyctl": [{"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "rt_sigtimedwait"}, {"reason": ["cred->session_keyring"], "call": "setfsuid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "msgrcv"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "kill"}, {"reason": ["cred->session_keyring"], "call": "getresuid16"}, {"reason": ["cred->session_keyring"], "call": "getresgid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sched_getaffinity"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sched_setparam"}, {"reason": ["cred->sgid", "cred->session_keyring", "cred->egid", "cred->gid"], "call": "setgid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "cred->session_keyring", "task_struct->cred", "task_struct->pid"], "call": "ioprio_set"}, {"reason": ["cred->session_keyring"], "call": "capset"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "getppid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "mq_timedreceive"}, {"reason": ["cred->session_keyring"], "call": "getresgid16"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "capget"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "cred->session_keyring", "task_struct->cred", "task_struct->pid"], "call": "sched_setaffinity"}, {"reason": ["cred->session_keyring"], "call": "setfsgid"}, {"reason": ["cred->session_keyring"], "call": "unshare"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "signal"}, {"reason": ["cred->uid", "cred->euid", "cred->suid", "cred->session_keyring"], "call": "setreuid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "semtimedop"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "umount"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sched_rr_get_interval"}, {"reason": ["cred->session_keyring"], "call": "epoll_create1"}, {"reason": ["cred->session_keyring"], "call": "getresuid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "setsid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sigaltstack"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sched_setattr"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "cred->session_keyring", "task_struct->cred", "task_struct->pid"], "call": "migrate_pages"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "getitimer"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "setpgid"}, {"reason": ["cred->sgid", "cred->session_keyring", "cred->egid", "cred->gid"], "call": "setresgid"}, {"reason": ["cred->sgid", "cred->session_keyring", "cred->egid", "cred->gid"], "call": "setregid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "getsid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "cred->session_keyring", "task_struct->cred", "task_struct->pid"], "call": "prlimit64"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "perf_event_open"}, {"reason": ["cred->session_keyring"], "call": "getgroups16"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "rt_sigaction"}, {"reason": ["key_type->read", "key_type->name", "key->quotalen", "key->serial", "key->description", "key->perm"], "call": "request_key"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "getpgid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "cred->session_keyring", "task_struct->cred", "task_struct->pid"], "call": "getpriority"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sigaction"}, {"reason": ["cred->session_keyring"], "call": "faccessat"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "setns"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "fork"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "get_robust_list"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "mq_timedsend"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sched_getscheduler"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "ptrace"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sched_getattr"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "getrusage"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sched_setscheduler"}, {"reason": ["cred->uid", "cred->euid", "cred->suid", "cred->session_keyring"], "call": "setresuid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "setitimer"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "cred->session_keyring", "task_struct->cred", "task_struct->pid"], "call": "ioprio_get"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "vfork"}, {"reason": ["cred->uid", "cred->euid", "cred->suid", "cred->session_keyring"], "call": "setuid"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "prctl"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "move_pages"}, {"reason": ["cred->session_keyring"], "call": "getgroups"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "cred->session_keyring", "task_struct->cred", "task_struct->pid"], "call": "setpriority"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "clone"}, {"reason": ["task_struct->mm", "task_struct->real_cred", "task_struct->cred", "task_struct->pid"], "call": "sched_getparam"}], "settimeofday": [{"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "waitid"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "adjtimex"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "select"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "wait4"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getrusage"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "setitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "clock_adjtime"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "alarm"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "ppoll"}], "utimensat": [{"reason": ["timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_nsec"], "call": "ppoll"}], "fcntl": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "migrate_pages": [{"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "kill"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "capget"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "signal"}, {"reason": ["cred->uid", "cred->euid", "cred->suid"], "call": "setreuid"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "umount"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "setsid"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "getsid"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "setns"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "fork"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->uid", "cred->euid", "cred->suid"], "call": "setresuid"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "vfork"}, {"reason": ["cred->uid", "cred->euid", "cred->suid"], "call": "setuid"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "prctl"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "clone"}, {"reason": ["mm_segment_t->seg", "task_struct->real_cred", "task_struct->cred"], "call": "sched_getparam"}], "getitimer": [{"reason": ["signal_struct->it_real_incr"], "call": "timer_create"}, {"reason": ["signal_struct->it_real_incr"], "call": "exit_group"}, {"reason": ["signal_struct->it_real_incr"], "call": "setitimer"}], "fchmodat": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "lstat": [{"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "stat"}, {"reason": ["kstat->ino", "kstat->nlink", "__old_kernel_stat->st_nlink", "kstat->dev", "__old_kernel_stat->st_ino", "kstat->rdev"], "call": "fstat"}, {"reason": ["kstat->ino", "kstat->nlink", "kstat->rdev", "kstat->dev"], "call": "newfstat"}], "init_module": [{"reason": ["module->args", "module->kp", "module_layout->base", "module_layout->size", "module->num_kp"], "call": "delete_module"}, {"reason": ["module->args", "load_info->num_debug", "module->kp", "load_info->debug", "load_info->hdr", "load_info->len", "module_layout->size", "module_layout->base", "module->num_kp"], "call": "finit_module"}], "setresgid": [{"reason": ["cred->user_ns", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user_ns"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->egid", "cred->gid"], "call": "setgid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user_ns"], "call": "setfsgid"}, {"reason": ["cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->user_ns"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->egid", "cred->gid"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user_ns"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->user_ns"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->user_ns"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user_ns"], "call": "getgroups"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "getcwd": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["dentry->d_parent", "vfsmount->mnt_root"], "call": "mq_unlink"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["dentry->d_parent", "path->dentry", "path->mnt", "vfsmount->mnt_root"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["vfsmount->mnt_root"], "call": "umount"}, {"reason": ["dentry->d_parent"], "call": "mkdirat"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["dentry->d_parent"], "call": "renameat2"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["dentry->d_parent"], "call": "ftruncate"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["dentry->d_parent"], "call": "mknodat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["dentry->d_parent"], "call": "symlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["dentry->d_parent"], "call": "linkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt", "vfsmount->mnt_root"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["dentry->d_parent"], "call": "unlink"}, {"reason": ["dentry->d_parent"], "call": "rmdir"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["dentry->d_parent", "path->dentry", "path->mnt", "vfsmount->mnt_root"], "call": "mq_open"}, {"reason": ["dentry->d_parent"], "call": "unlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "inotify_add_watch": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_op"], "call": "eventfd2"}, {"reason": ["dentry->d_inode"], "call": "mq_unlink"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_op"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["dentry->d_inode"], "call": "pivot_root"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_op"], "call": "memfd_create"}, {"reason": ["file->f_op"], "call": "remap_file_pages"}, {"reason": ["file->f_op"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["dentry->d_inode"], "call": "mkdirat"}, {"reason": ["file->f_op"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["file->f_op", "fd->flags"], "call": "epoll_ctl"}, {"reason": ["file->f_op", "fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_op"], "call": "openat"}, {"reason": ["file->f_op"], "call": "uselib"}, {"reason": ["dentry->d_inode"], "call": "renameat2"}, {"reason": ["file->f_op", "fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_op"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["dentry->d_inode"], "call": "getcwd"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["dentry->d_inode", "fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_op"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["dentry->d_inode"], "call": "mknodat"}, {"reason": ["file->f_op"], "call": "socket"}, {"reason": ["dentry->d_inode"], "call": "symlinkat"}, {"reason": ["file->f_op"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["file->f_op", "fd->flags"], "call": "perf_event_open"}, {"reason": ["dentry->d_inode"], "call": "linkat"}, {"reason": ["file->f_op"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_op"], "call": "acct"}, {"reason": ["file->f_op"], "call": "open"}, {"reason": ["dentry->d_inode"], "call": "unlink"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["dentry->d_inode"], "call": "rmdir"}, {"reason": ["file->f_op"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_op"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_op"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_op"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_op"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["dentry->d_inode", "file->f_op"], "call": "mq_open"}, {"reason": ["dentry->d_inode"], "call": "unlinkat"}, {"reason": ["file->f_op"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "preadv2": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "timer_settime": [{"reason": ["k_clock->timer_set"], "call": "clock_getres"}, {"reason": ["k_clock->timer_set"], "call": "timer_delete"}, {"reason": ["k_clock->timer_set"], "call": "timer_create"}, {"reason": ["k_clock->timer_set"], "call": "clock_gettime"}, {"reason": ["k_clock->timer_set"], "call": "timer_gettime"}, {"reason": ["k_clock->timer_set"], "call": "clock_settime"}, {"reason": ["k_clock->timer_set"], "call": "clock_nanosleep"}, {"reason": ["k_clock->timer_set"], "call": "clock_adjtime"}], "setregid": [{"reason": ["cred->user_ns", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user_ns"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->egid", "cred->gid"], "call": "setgid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user_ns"], "call": "setfsgid"}, {"reason": ["cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->user_ns"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->egid", "cred->gid"], "call": "setresgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user_ns"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->user_ns"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->user_ns"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user_ns"], "call": "getgroups"}, {"reason": ["cred->user_ns", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "fchdir": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["path->dentry"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "path->dentry"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "path->dentry"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["path->dentry"], "call": "uselib"}, {"reason": ["fd->flags", "path->dentry"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["path->dentry"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["path->dentry"], "call": "quotactl"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["path->dentry"], "call": "acct"}, {"reason": ["path->dentry"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["path->dentry"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["path->dentry"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["path->dentry"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["path->dentry"], "call": "mq_open"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "ftruncate": [{"reason": ["file->f_flags", "file->f_mode"], "call": "eventfd2"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "mq_unlink"}, {"reason": ["inode->i_flags", "inode->i_sb", "file->f_flags", "file->f_mode"], "call": "swapoff"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "fchmod"}, {"reason": ["inode->i_flags", "inode->i_sb", "file->f_flags", "file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup3"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "readlinkat"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "fchown"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "mq_timedreceive"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "flock"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "openat"}, {"reason": ["inode->i_flags", "inode->i_sb", "file->f_flags", "file->f_mode"], "call": "uselib"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "accept4"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socketpair"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "fchmodat"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "inotify_add_watch"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socket"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "pipe2"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "ioctl"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "linkat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "acct"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "unlink"}, {"reason": ["inode->i_flags", "inode->i_sb", "file->f_flags"], "call": "mq_getsetattr"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "faccessat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "setns"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "mq_timedsend"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmctl"}, {"reason": ["inode->i_flags", "inode->i_sb", "file->f_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "fchownat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "mq_notify"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "sendfile"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mq_open"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "unlinkat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["inode->i_flags", "inode->i_sb"], "call": "sendfile64"}], "timer_gettime": [{"reason": ["k_clock->timer_get"], "call": "clock_getres"}, {"reason": ["k_clock->timer_get"], "call": "timer_delete"}, {"reason": ["k_clock->timer_get"], "call": "timer_create"}, {"reason": ["k_clock->timer_get"], "call": "clock_gettime"}, {"reason": ["k_clock->timer_get"], "call": "timer_settime"}, {"reason": ["k_clock->timer_get"], "call": "clock_settime"}, {"reason": ["k_clock->timer_get"], "call": "clock_nanosleep"}, {"reason": ["k_clock->timer_get"], "call": "clock_adjtime"}], "msgsnd": [{"reason": ["ipc_namespace->msg_ctlmax"], "call": "msgrcv"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "mq_unlink"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "msgget"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "semtimedop"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "semctl"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "shmget"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "msgctl"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "semget"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "shmat"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "setns"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "shmctl"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "mq_open"}], "sysinfo": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["timespec->tv_nsec"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["timespec->tv_nsec"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_nsec"], "call": "uselib"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_nsec"], "call": "stime"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_nsec"], "call": "unlink"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_nsec"], "call": "ppoll"}], "geteuid16": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "setpgid": [{"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "keyctl"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "msgrcv"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "kill"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sched_getaffinity"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sched_setparam"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "ioprio_set"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "getppid"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "mq_timedreceive"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "capget"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sched_setaffinity"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "semtimedop"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "umount"}, {"reason": ["signal_struct->leader"], "call": "timer_create"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "signal_struct->leader", "task_struct->signal"], "call": "setsid"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sigaltstack"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sched_setattr"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "migrate_pages"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "getitimer"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "getsid"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "prlimit64"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "perf_event_open"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "rt_sigaction"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "getpgid"}, {"reason": ["signal_struct->leader"], "call": "exit_group"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "getpriority"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sigaction"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "setns"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "fork"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "get_robust_list"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "mq_timedsend"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sched_getscheduler"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "ptrace"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sched_getattr"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "getrusage"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "setitimer"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "ioprio_get"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "prctl"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "move_pages"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "setpriority"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "clone"}, {"reason": ["task_struct->exit_signal", "task_struct->real_parent", "task_struct->flags", "task_struct->signal"], "call": "sched_getparam"}], "mknodat": [{"reason": ["super_block->s_flags"], "call": "syncfs"}, {"reason": ["super_block->s_flags"], "call": "ustat"}, {"reason": ["super_block->s_flags"], "call": "umount"}, {"reason": ["super_block->s_flags"], "call": "quotactl"}, {"reason": ["super_block->s_flags"], "call": "swapon"}], "shmat": [{"reason": ["task_struct->mm"], "call": "keyctl"}, {"reason": ["task_struct->mm"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->mm"], "call": "msgrcv"}, {"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["task_struct->mm"], "call": "kill"}, {"reason": ["path->dentry"], "call": "swapoff"}, {"reason": ["task_struct->mm"], "call": "sched_getaffinity"}, {"reason": ["task_struct->mm"], "call": "sched_setparam"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["task_struct->mm"], "call": "ioprio_set"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["task_struct->mm"], "call": "getppid"}, {"reason": ["task_struct->mm"], "call": "mq_timedreceive"}, {"reason": ["task_struct->mm"], "call": "capget"}, {"reason": ["task_struct->mm"], "call": "sched_setaffinity"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["task_struct->mm"], "call": "signal"}, {"reason": ["task_struct->mm"], "call": "semtimedop"}, {"reason": ["task_struct->mm"], "call": "umount"}, {"reason": ["task_struct->mm"], "call": "sched_rr_get_interval"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["path->dentry"], "call": "epoll_ctl"}, {"reason": ["path->dentry"], "call": "flock"}, {"reason": ["path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["path->dentry"], "call": "uselib"}, {"reason": ["task_struct->mm"], "call": "rt_sigprocmask"}, {"reason": ["path->dentry"], "call": "accept4"}, {"reason": ["task_struct->mm"], "call": "setsid"}, {"reason": ["task_struct->mm"], "call": "sigaltstack"}, {"reason": ["task_struct->mm"], "call": "sched_setattr"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["task_struct->mm"], "call": "migrate_pages"}, {"reason": ["task_struct->mm"], "call": "getitimer"}, {"reason": ["task_struct->mm"], "call": "setpgid"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["task_struct->mm"], "call": "getsid"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["task_struct->mm"], "call": "prlimit64"}, {"reason": ["task_struct->mm", "path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["path->dentry"], "call": "quotactl"}, {"reason": ["task_struct->mm"], "call": "rt_sigaction"}, {"reason": ["task_struct->mm"], "call": "getpgid"}, {"reason": ["path->dentry"], "call": "acct"}, {"reason": ["path->dentry"], "call": "open"}, {"reason": ["task_struct->mm"], "call": "getpriority"}, {"reason": ["task_struct->mm"], "call": "sigaction"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["task_struct->mm", "path->dentry"], "call": "setns"}, {"reason": ["task_struct->mm"], "call": "fork"}, {"reason": ["task_struct->mm"], "call": "get_robust_list"}, {"reason": ["task_struct->mm"], "call": "mq_timedsend"}, {"reason": ["task_struct->mm"], "call": "sched_getscheduler"}, {"reason": ["task_struct->mm"], "call": "ptrace"}, {"reason": ["path->dentry", "shmid_kernel->shm_file"], "call": "shmctl"}, {"reason": ["path->dentry"], "call": "swapon"}, {"reason": ["task_struct->mm"], "call": "sched_getattr"}, {"reason": ["task_struct->mm"], "call": "getrusage"}, {"reason": ["task_struct->mm"], "call": "sched_setscheduler"}, {"reason": ["task_struct->mm"], "call": "setitimer"}, {"reason": ["task_struct->mm"], "call": "ioprio_get"}, {"reason": ["task_struct->mm"], "call": "vfork"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["task_struct->mm"], "call": "prctl"}, {"reason": ["task_struct->mm"], "call": "move_pages"}, {"reason": ["task_struct->mm"], "call": "setpriority"}, {"reason": ["task_struct->mm"], "call": "clone"}, {"reason": ["path->dentry"], "call": "mq_open"}, {"reason": ["task_struct->mm"], "call": "sched_getparam"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}], "setsockopt": [{"reason": ["proto_ops->compat_setsockopt"], "call": "accept4"}], "old_getrlimit": [{"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "setrlimit"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "prlimit64"}], "msync": [{"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "remap_file_pages"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "brk"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "madvise"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_flags", "vm_area_struct->vm_file"], "call": "mlockall"}], "getegid16": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "ioctl": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "prlimit64": [{"reason": ["task_struct->sighand", "cred->user_ns", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user_ns"], "call": "setfsuid"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "kill"}, {"reason": ["cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->egid", "cred->gid"], "call": "setgid"}, {"reason": ["task_struct->sighand", "cred->user_ns", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->sighand", "cred->user_ns", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user_ns"], "call": "setfsgid"}, {"reason": ["cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "signal"}, {"reason": ["cred->uid", "cred->user_ns", "cred->suid", "cred->euid"], "call": "setreuid"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sched_setattr"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "setrlimit"}, {"reason": ["task_struct->sighand", "cred->user_ns", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->egid", "cred->gid"], "call": "setresgid"}, {"reason": ["cred->user_ns", "cred->sgid", "cred->egid", "cred->gid"], "call": "setregid"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "getsid"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "old_getrlimit"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->sighand", "cred->user_ns", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user_ns"], "call": "faccessat"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->uid", "cred->user_ns", "cred->suid", "cred->euid"], "call": "setresuid"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->sighand", "cred->user_ns", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "vfork"}, {"reason": ["cred->uid", "cred->user_ns", "cred->suid", "cred->euid"], "call": "setuid"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user_ns"], "call": "getgroups"}, {"reason": ["task_struct->sighand", "cred->user_ns", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->sighand", "task_struct->real_cred", "task_struct->group_leader", "task_struct->cred"], "call": "sched_getparam"}], "set_mempolicy": [{"reason": ["mempolicy->mode"], "call": "get_mempolicy"}, {"reason": ["mempolicy->mode"], "call": "mbind"}], "pwrite64": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "perf_event_open": [{"reason": ["list_head->prev", "fd->flags"], "call": "syncfs"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "keyctl"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["list_head->prev", "fd->flags"], "call": "vmsplice"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "msgrcv"}, {"reason": ["file->f_op", "list_head->prev"], "call": "eventfd2"}, {"reason": ["list_head->prev"], "call": "mq_unlink"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "kill"}, {"reason": ["file->f_op", "list_head->prev"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["list_head->prev", "fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["list_head->prev"], "call": "timer_delete"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sched_setparam"}, {"reason": ["list_head->prev", "fd->flags"], "call": "fchmod"}, {"reason": ["list_head->prev"], "call": "setgid"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["list_head->prev"], "call": "pivot_root"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_op", "list_head->prev"], "call": "memfd_create"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "ioprio_set"}, {"reason": ["list_head->prev"], "call": "delete_module"}, {"reason": ["file->f_op", "list_head->prev"], "call": "remap_file_pages"}, {"reason": ["file->f_op", "list_head->prev"], "call": "dup3"}, {"reason": ["list_head->prev"], "call": "readlinkat"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["list_head->prev"], "call": "io_getevents"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "getppid"}, {"reason": ["list_head->prev", "fd->flags"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["list_head->prev", "fd->flags", "mm_segment_t->seg", "task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "capget"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sched_setaffinity"}, {"reason": ["list_head->prev"], "call": "ustat"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["list_head->prev", "fd->flags"], "call": "bpf"}, {"reason": ["list_head->prev"], "call": "unshare"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "signal"}, {"reason": ["list_head->prev", "task_struct->flags"], "call": "setreuid"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "semtimedop"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["list_head->prev"], "call": "timer_create"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["list_head->prev"], "call": "mkdirat"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["file->f_op", "list_head->prev"], "call": "epoll_create1"}, {"reason": ["list_head->prev"], "call": "timerfd_gettime"}, {"reason": ["list_head->prev", "fd->flags"], "call": "tee"}, {"reason": ["list_head->prev"], "call": "semctl"}, {"reason": ["list_head->prev", "fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["file->f_op", "list_head->prev", "fd->flags"], "call": "epoll_ctl"}, {"reason": ["file->f_op", "list_head->prev", "fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_op", "list_head->prev"], "call": "openat"}, {"reason": ["list_head->prev"], "call": "lookup_dcookie"}, {"reason": ["file->f_op", "list_head->prev"], "call": "uselib"}, {"reason": ["list_head->prev"], "call": "renameat2"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["file->f_op", "list_head->prev", "fd->flags"], "call": "accept4"}, {"reason": ["list_head->prev"], "call": "msgctl"}, {"reason": ["list_head->prev"], "call": "reboot"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "setsid"}, {"reason": ["list_head->prev"], "call": "set_trip_temp"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sigaltstack"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sched_setattr"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["list_head->prev", "fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_op", "list_head->prev"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "migrate_pages"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "getitimer"}, {"reason": ["list_head->prev"], "call": "fchmodat"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "setpgid"}, {"reason": ["list_head->prev"], "call": "init_module"}, {"reason": ["list_head->prev"], "call": "setresgid"}, {"reason": ["list_head->prev"], "call": "getcwd"}, {"reason": ["list_head->prev", "fd->flags"], "call": "inotify_add_watch"}, {"reason": ["list_head->prev"], "call": "get_trip_temp"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["list_head->prev"], "call": "timer_settime"}, {"reason": ["list_head->prev"], "call": "setregid"}, {"reason": ["list_head->prev", "fd->flags"], "call": "splice"}, {"reason": ["list_head->prev", "fd->flags"], "call": "ftruncate"}, {"reason": ["list_head->prev"], "call": "timer_gettime"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "getsid"}, {"reason": ["file->f_op", "list_head->prev"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["list_head->prev"], "call": "mknodat"}, {"reason": ["file->f_op", "list_head->prev"], "call": "socket"}, {"reason": ["list_head->prev"], "call": "symlinkat"}, {"reason": ["file->f_op", "list_head->prev"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["list_head->prev", "fd->flags"], "call": "ioctl"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "prlimit64"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["list_head->prev"], "call": "linkat"}, {"reason": ["list_head->prev"], "call": "getgroups16"}, {"reason": ["file->f_op", "list_head->prev"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["list_head->prev"], "call": "quotactl"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["list_head->prev"], "call": "request_key"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "getpgid"}, {"reason": ["list_head->prev"], "call": "brk"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_op", "list_head->prev"], "call": "acct"}, {"reason": ["file->f_op", "list_head->prev"], "call": "open"}, {"reason": ["list_head->prev"], "call": "unlink"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["list_head->prev"], "call": "exit_group"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "getpriority"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sigaction"}, {"reason": ["list_head->prev", "fd->flags"], "call": "mq_getsetattr"}, {"reason": ["list_head->prev"], "call": "faccessat"}, {"reason": ["list_head->prev"], "call": "rmdir"}, {"reason": ["file->f_op", "list_head->prev"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["list_head->prev"], "call": "setgroups16"}, {"reason": ["file->f_op", "list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "fork"}, {"reason": ["list_head->prev"], "call": "get_mempolicy"}, {"reason": ["list_head->prev"], "call": "io_submit"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "get_robust_list"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["list_head->prev", "fd->flags", "mm_segment_t->seg", "task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["list_head->prev"], "call": "sched_yield"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "ptrace"}, {"reason": ["file->f_op", "list_head->prev"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["list_head->prev"], "call": "munlockall"}, {"reason": ["file->f_op", "list_head->prev"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["list_head->prev"], "call": "pkey_mprotect"}, {"reason": ["list_head->prev"], "call": "madvise"}, {"reason": ["list_head->prev", "fd->flags"], "call": "epoll_wait"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sched_getattr"}, {"reason": ["list_head->prev"], "call": "fchownat"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "getrusage"}, {"reason": ["list_head->prev"], "call": "timerfd_settime"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["list_head->prev", "task_struct->flags"], "call": "setresuid"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "setitimer"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "ioprio_get"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "vfork"}, {"reason": ["list_head->prev", "task_struct->flags"], "call": "setuid"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["list_head->prev"], "call": "io_setup"}, {"reason": ["list_head->prev"], "call": "mprotect"}, {"reason": ["file->f_op", "list_head->prev"], "call": "mmap_pgoff"}, {"reason": ["list_head->prev"], "call": "mremap"}, {"reason": ["list_head->prev"], "call": "io_destroy"}, {"reason": ["list_head->prev"], "call": "mbind"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "prctl"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "move_pages"}, {"reason": ["list_head->prev"], "call": "timerfd_create"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["list_head->prev"], "call": "modify_ldt"}, {"reason": ["list_head->prev"], "call": "getgroups"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["list_head->prev"], "call": "dup2"}, {"reason": ["list_head->prev"], "call": "get_curr_temp"}, {"reason": ["list_head->prev"], "call": "msgsnd"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["list_head->prev"], "call": "munlock"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "setpriority"}, {"reason": ["list_head->prev"], "call": "inotify_init1"}, {"reason": ["list_head->prev"], "call": "mincore"}, {"reason": ["list_head->prev", "fd->flags"], "call": "mq_notify"}, {"reason": ["list_head->prev", "fd->flags"], "call": "sendfile"}, {"reason": ["list_head->prev"], "call": "timer_getoverrun"}, {"reason": ["list_head->prev"], "call": "kexec_load"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "clone"}, {"reason": ["file->f_op", "list_head->prev"], "call": "mq_open"}, {"reason": ["list_head->prev"], "call": "setgroups"}, {"reason": ["list_head->prev"], "call": "unlinkat"}, {"reason": ["list_head->prev", "mm_segment_t->seg", "task_struct->flags"], "call": "sched_getparam"}, {"reason": ["list_head->prev"], "call": "io_cancel"}, {"reason": ["file->f_op", "list_head->prev"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["list_head->prev"], "call": "finit_module"}, {"reason": ["list_head->prev", "fd->flags"], "call": "sendfile64"}, {"reason": ["list_head->prev"], "call": "mlockall"}], "removexattr": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "sendmsg": [{"reason": ["socket->file"], "call": "recvfrom"}, {"reason": ["socket->file"], "call": "sendto"}, {"reason": ["socket->file"], "call": "connect"}, {"reason": ["socket->file"], "call": "getsockname"}, {"reason": ["socket->file"], "call": "accept4"}, {"reason": ["socket->file"], "call": "getpeername"}, {"reason": ["socket->file"], "call": "setsockopt"}, {"reason": ["socket->file"], "call": "shutdown"}, {"reason": ["socket->file"], "call": "getsockopt"}, {"reason": ["socket->file"], "call": "listen"}, {"reason": ["socket->file"], "call": "recvmsg"}, {"reason": ["socket->file"], "call": "sendmmsg"}, {"reason": ["socket->file"], "call": "bind"}, {"reason": ["socket->file"], "call": "recvmmsg"}], "epoll_ctl": [{"reason": ["fd->flags", "list_head->next"], "call": "syncfs"}, {"reason": ["list_head->next"], "call": "keyctl"}, {"reason": ["list_head->next"], "call": "rt_sigtimedwait"}, {"reason": ["fd->flags", "list_head->next"], "call": "vmsplice"}, {"reason": ["list_head->next"], "call": "msgrcv"}, {"reason": ["file->f_op", "list_head->next"], "call": "eventfd2"}, {"reason": ["list_head->next"], "call": "mq_unlink"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["list_head->next"], "call": "kill"}, {"reason": ["file->f_op", "list_head->next"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags", "list_head->next"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["list_head->next"], "call": "timer_delete"}, {"reason": ["list_head->next"], "call": "sched_getaffinity"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["list_head->next"], "call": "sched_setparam"}, {"reason": ["fd->flags", "list_head->next"], "call": "fchmod"}, {"reason": ["list_head->next"], "call": "setgid"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["list_head->next"], "call": "pivot_root"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_op", "list_head->next"], "call": "memfd_create"}, {"reason": ["list_head->next"], "call": "ioprio_set"}, {"reason": ["list_head->next"], "call": "delete_module"}, {"reason": ["file->f_op", "list_head->next"], "call": "remap_file_pages"}, {"reason": ["file->f_op", "list_head->next"], "call": "dup3"}, {"reason": ["list_head->next"], "call": "readlinkat"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["list_head->next"], "call": "io_getevents"}, {"reason": ["list_head->next"], "call": "getppid"}, {"reason": ["fd->flags", "list_head->next"], "call": "fchown"}, {"reason": ["fd->flags", "list_head->next"], "call": "mq_timedreceive"}, {"reason": ["list_head->next"], "call": "capget"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["list_head->next"], "call": "sched_setaffinity"}, {"reason": ["list_head->next"], "call": "ustat"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags", "list_head->next"], "call": "bpf"}, {"reason": ["list_head->next"], "call": "unshare"}, {"reason": ["list_head->next"], "call": "signal"}, {"reason": ["list_head->next"], "call": "setreuid"}, {"reason": ["list_head->next"], "call": "semtimedop"}, {"reason": ["list_head->next"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["list_head->next"], "call": "timer_create"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["list_head->next"], "call": "mkdirat"}, {"reason": ["list_head->next"], "call": "sched_rr_get_interval"}, {"reason": ["file->f_op", "epitem->ws", "epoll_event->events", "list_head->next", "epitem->nwait"], "call": "epoll_create1"}, {"reason": ["list_head->next"], "call": "timerfd_gettime"}, {"reason": ["fd->flags", "list_head->next"], "call": "tee"}, {"reason": ["list_head->next"], "call": "semctl"}, {"reason": ["fd->flags", "list_head->next"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["file->f_op", "fd->flags", "list_head->next"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_op", "list_head->next"], "call": "openat"}, {"reason": ["list_head->next"], "call": "lookup_dcookie"}, {"reason": ["file->f_op", "list_head->next"], "call": "uselib"}, {"reason": ["list_head->next"], "call": "renameat2"}, {"reason": ["list_head->next"], "call": "rt_sigprocmask"}, {"reason": ["file->f_op", "fd->flags", "list_head->next"], "call": "accept4"}, {"reason": ["list_head->next"], "call": "msgctl"}, {"reason": ["list_head->next"], "call": "reboot"}, {"reason": ["list_head->next"], "call": "setsid"}, {"reason": ["list_head->next"], "call": "set_trip_temp"}, {"reason": ["list_head->next"], "call": "sigaltstack"}, {"reason": ["list_head->next"], "call": "sched_setattr"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags", "list_head->next"], "call": "inotify_rm_watch"}, {"reason": ["file->f_op", "list_head->next"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["list_head->next"], "call": "migrate_pages"}, {"reason": ["list_head->next"], "call": "getitimer"}, {"reason": ["list_head->next"], "call": "fchmodat"}, {"reason": ["list_head->next"], "call": "setpgid"}, {"reason": ["list_head->next"], "call": "init_module"}, {"reason": ["list_head->next"], "call": "setresgid"}, {"reason": ["list_head->next"], "call": "getcwd"}, {"reason": ["fd->flags", "list_head->next"], "call": "inotify_add_watch"}, {"reason": ["list_head->next"], "call": "get_trip_temp"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["list_head->next"], "call": "timer_settime"}, {"reason": ["list_head->next"], "call": "setregid"}, {"reason": ["fd->flags", "list_head->next"], "call": "splice"}, {"reason": ["fd->flags", "list_head->next"], "call": "ftruncate"}, {"reason": ["list_head->next"], "call": "timer_gettime"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["list_head->next"], "call": "getsid"}, {"reason": ["file->f_op", "list_head->next"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["list_head->next"], "call": "mknodat"}, {"reason": ["file->f_op", "list_head->next"], "call": "socket"}, {"reason": ["list_head->next"], "call": "symlinkat"}, {"reason": ["file->f_op", "list_head->next"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags", "list_head->next"], "call": "ioctl"}, {"reason": ["list_head->next"], "call": "prlimit64"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["file->f_op", "fd->flags", "list_head->next"], "call": "perf_event_open"}, {"reason": ["list_head->next"], "call": "linkat"}, {"reason": ["list_head->next"], "call": "getgroups16"}, {"reason": ["file->f_op", "list_head->next"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["list_head->next"], "call": "quotactl"}, {"reason": ["list_head->next"], "call": "rt_sigaction"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["list_head->next"], "call": "request_key"}, {"reason": ["list_head->next"], "call": "getpgid"}, {"reason": ["list_head->next"], "call": "brk"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_op", "list_head->next"], "call": "acct"}, {"reason": ["file->f_op", "list_head->next"], "call": "open"}, {"reason": ["list_head->next"], "call": "unlink"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["list_head->next"], "call": "exit_group"}, {"reason": ["list_head->next"], "call": "getpriority"}, {"reason": ["list_head->next"], "call": "sigaction"}, {"reason": ["fd->flags", "list_head->next"], "call": "mq_getsetattr"}, {"reason": ["list_head->next"], "call": "faccessat"}, {"reason": ["list_head->next"], "call": "rmdir"}, {"reason": ["file->f_op", "list_head->next"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["list_head->next"], "call": "setgroups16"}, {"reason": ["file->f_op", "list_head->next"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["list_head->next"], "call": "fork"}, {"reason": ["list_head->next"], "call": "get_mempolicy"}, {"reason": ["list_head->next"], "call": "io_submit"}, {"reason": ["list_head->next"], "call": "get_robust_list"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags", "list_head->next"], "call": "mq_timedsend"}, {"reason": ["list_head->next"], "call": "sched_yield"}, {"reason": ["list_head->next"], "call": "sched_getscheduler"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["list_head->next"], "call": "ptrace"}, {"reason": ["file->f_op", "list_head->next"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["list_head->next"], "call": "munlockall"}, {"reason": ["file->f_op", "list_head->next"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["list_head->next"], "call": "pkey_mprotect"}, {"reason": ["list_head->next"], "call": "madvise"}, {"reason": ["fd->flags", "list_head->next"], "call": "epoll_wait"}, {"reason": ["list_head->next"], "call": "sched_getattr"}, {"reason": ["list_head->next"], "call": "fchownat"}, {"reason": ["list_head->next"], "call": "getrusage"}, {"reason": ["list_head->next"], "call": "timerfd_settime"}, {"reason": ["list_head->next"], "call": "sched_setscheduler"}, {"reason": ["list_head->next"], "call": "setresuid"}, {"reason": ["list_head->next"], "call": "setitimer"}, {"reason": ["list_head->next"], "call": "ioprio_get"}, {"reason": ["list_head->next"], "call": "vfork"}, {"reason": ["list_head->next"], "call": "setuid"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["list_head->next"], "call": "io_setup"}, {"reason": ["list_head->next"], "call": "mprotect"}, {"reason": ["file->f_op", "list_head->next"], "call": "mmap_pgoff"}, {"reason": ["list_head->next"], "call": "mremap"}, {"reason": ["list_head->next"], "call": "io_destroy"}, {"reason": ["list_head->next"], "call": "mbind"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["list_head->next"], "call": "prctl"}, {"reason": ["list_head->next"], "call": "move_pages"}, {"reason": ["list_head->next"], "call": "timerfd_create"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["list_head->next"], "call": "modify_ldt"}, {"reason": ["list_head->next"], "call": "getgroups"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["list_head->next"], "call": "dup2"}, {"reason": ["list_head->next"], "call": "get_curr_temp"}, {"reason": ["list_head->next"], "call": "msgsnd"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["list_head->next"], "call": "munlock"}, {"reason": ["list_head->next"], "call": "setpriority"}, {"reason": ["list_head->next"], "call": "inotify_init1"}, {"reason": ["list_head->next"], "call": "mincore"}, {"reason": ["fd->flags", "list_head->next"], "call": "mq_notify"}, {"reason": ["fd->flags", "list_head->next"], "call": "sendfile"}, {"reason": ["list_head->next"], "call": "timer_getoverrun"}, {"reason": ["list_head->next"], "call": "kexec_load"}, {"reason": ["list_head->next"], "call": "clone"}, {"reason": ["file->f_op", "list_head->next"], "call": "mq_open"}, {"reason": ["list_head->next"], "call": "setgroups"}, {"reason": ["list_head->next"], "call": "unlinkat"}, {"reason": ["list_head->next"], "call": "sched_getparam"}, {"reason": ["list_head->next"], "call": "io_cancel"}, {"reason": ["file->f_op", "list_head->next"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["list_head->next"], "call": "finit_module"}, {"reason": ["fd->flags", "list_head->next"], "call": "sendfile64"}, {"reason": ["list_head->next"], "call": "mlockall"}], "rt_tgsigqueueinfo": [{"reason": ["siginfo->si_code"], "call": "rt_sigtimedwait"}, {"reason": ["siginfo->si_code"], "call": "kill"}, {"reason": ["siginfo->si_code"], "call": "timer_create"}, {"reason": ["siginfo->si_code"], "call": "rt_sigqueueinfo"}, {"reason": ["siginfo->si_code"], "call": "tgkill"}, {"reason": ["siginfo->si_code"], "call": "rt_sigreturn"}, {"reason": ["siginfo->si_code"], "call": "tkill"}], "pwritev64v2": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "splice": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "openat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socket"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "acct"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags", "file->f_flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "setxattr": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "symlinkat": [{"reason": ["filename->refcnt", "filename->name"], "call": "sysfs"}, {"reason": ["filename->refcnt", "filename->name"], "call": "mq_unlink"}, {"reason": ["filename->refcnt", "filename->name"], "call": "swapoff"}, {"reason": ["filename->refcnt", "filename->name"], "call": "openat"}, {"reason": ["filename->refcnt", "filename->name"], "call": "uselib"}, {"reason": ["filename->refcnt", "filename->name"], "call": "renameat2"}, {"reason": ["filename->refcnt", "filename->name"], "call": "quotactl"}, {"reason": ["filename->refcnt", "filename->name"], "call": "acct"}, {"reason": ["filename->refcnt", "filename->name"], "call": "open"}, {"reason": ["filename->refcnt", "filename->name"], "call": "unlink"}, {"reason": ["filename->refcnt", "filename->name"], "call": "rmdir"}, {"reason": ["filename->refcnt", "filename->name"], "call": "swapon"}, {"reason": ["filename->refcnt", "filename->name"], "call": "mq_open"}, {"reason": ["filename->refcnt", "filename->name"], "call": "unlinkat"}], "brk": [{"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "swapoff"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "remap_file_pages"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "io_getevents"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "migrate_pages"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->def_flags"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "madvise"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "getrusage"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "io_setup"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "mremap"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "io_destroy"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "mbind"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "prctl"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "move_pages"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "modify_ldt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "mincore"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "io_cancel"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->def_flags"], "call": "mlockall"}], "fsetxattr": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "acct": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "poll": [{"reason": ["poll_list->len"], "call": "ppoll"}], "clock_settime": [{"reason": ["k_clock->clock_set"], "call": "clock_getres"}, {"reason": ["k_clock->clock_set"], "call": "timer_delete"}, {"reason": ["k_clock->clock_set"], "call": "timer_create"}, {"reason": ["k_clock->clock_set"], "call": "clock_gettime"}, {"reason": ["k_clock->clock_set"], "call": "timer_settime"}, {"reason": ["k_clock->clock_set"], "call": "timer_gettime"}, {"reason": ["k_clock->clock_set"], "call": "clock_nanosleep"}, {"reason": ["k_clock->clock_set"], "call": "clock_adjtime"}], "select": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["files_struct->fdt"], "call": "dup3"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["files_struct->fdt"], "call": "unshare"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["files_struct->fdt"], "call": "dup2"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "unlink": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["dentry->d_inode"], "call": "mq_unlink"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["dentry->d_inode"], "call": "mkdirat"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["dentry->d_inode"], "call": "renameat2"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["dentry->d_inode"], "call": "ftruncate"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["dentry->d_inode"], "call": "mknodat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["dentry->d_inode"], "call": "symlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["dentry->d_inode"], "call": "linkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["dentry->d_inode"], "call": "rmdir"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["dentry->d_inode"], "call": "unlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "getsockopt": [{"reason": ["proto_ops->compat_getsockopt"], "call": "accept4"}], "getpriority": [{"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "signal"}, {"reason": ["cred->uid"], "call": "setreuid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->uid"], "call": "setresuid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "vfork"}, {"reason": ["cred->uid"], "call": "setuid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getparam"}], "listxattr": [{"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["path->dentry"], "call": "swapoff"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["path->dentry"], "call": "epoll_ctl"}, {"reason": ["path->dentry"], "call": "flock"}, {"reason": ["path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["path->dentry"], "call": "uselib"}, {"reason": ["path->dentry"], "call": "accept4"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["path->dentry"], "call": "shmat"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["path->dentry"], "call": "quotactl"}, {"reason": ["path->dentry"], "call": "acct"}, {"reason": ["path->dentry"], "call": "open"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["path->dentry"], "call": "setns"}, {"reason": ["path->dentry"], "call": "shmctl"}, {"reason": ["path->dentry"], "call": "swapon"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["path->dentry"], "call": "mq_open"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}], "sigaction": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "nanosleep": [{"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "quotactl": [{"reason": ["super_block->s_qcop", "super_block->s_quota_types", "super_block->s_flags"], "call": "syncfs"}, {"reason": ["filename->name"], "call": "sysfs"}, {"reason": ["filename->name"], "call": "mq_unlink"}, {"reason": ["filename->name"], "call": "swapoff"}, {"reason": ["super_block->s_qcop", "super_block->s_quota_types", "super_block->s_flags"], "call": "ustat"}, {"reason": ["super_block->s_qcop", "super_block->s_quota_types", "super_block->s_flags"], "call": "umount"}, {"reason": ["filename->name"], "call": "openat"}, {"reason": ["filename->name"], "call": "uselib"}, {"reason": ["filename->name"], "call": "renameat2"}, {"reason": ["filename->name"], "call": "symlinkat"}, {"reason": ["filename->name"], "call": "acct"}, {"reason": ["filename->name"], "call": "open"}, {"reason": ["filename->name"], "call": "unlink"}, {"reason": ["filename->name"], "call": "rmdir"}, {"reason": ["super_block->s_qcop", "filename->name", "super_block->s_quota_types", "super_block->s_flags"], "call": "swapon"}, {"reason": ["filename->name"], "call": "mq_open"}, {"reason": ["filename->name"], "call": "unlinkat"}], "mq_getsetattr": [{"reason": ["file->f_op"], "call": "eventfd2"}, {"reason": ["file->f_op"], "call": "swapoff"}, {"reason": ["file->f_op"], "call": "memfd_create"}, {"reason": ["file->f_op"], "call": "remap_file_pages"}, {"reason": ["file->f_op"], "call": "dup3"}, {"reason": ["mq_attr->mq_flags"], "call": "mq_timedreceive"}, {"reason": ["file->f_op"], "call": "epoll_create1"}, {"reason": ["file->f_op"], "call": "epoll_ctl"}, {"reason": ["file->f_op"], "call": "flock"}, {"reason": ["file->f_op"], "call": "openat"}, {"reason": ["file->f_op"], "call": "uselib"}, {"reason": ["file->f_op"], "call": "accept4"}, {"reason": ["file->f_op"], "call": "socketpair"}, {"reason": ["file->f_op"], "call": "shmat"}, {"reason": ["file->f_op"], "call": "socket"}, {"reason": ["file->f_op"], "call": "pipe2"}, {"reason": ["file->f_op"], "call": "perf_event_open"}, {"reason": ["file->f_op"], "call": "shmdt"}, {"reason": ["file->f_op"], "call": "acct"}, {"reason": ["file->f_op"], "call": "open"}, {"reason": ["file->f_op"], "call": "dup"}, {"reason": ["file->f_op"], "call": "setns"}, {"reason": ["mq_attr->mq_flags"], "call": "mq_timedsend"}, {"reason": ["file->f_op"], "call": "shmctl"}, {"reason": ["file->f_op"], "call": "swapon"}, {"reason": ["file->f_op"], "call": "mmap_pgoff"}, {"reason": ["mq_attr->mq_flags"], "call": "mq_notify"}, {"reason": ["file->f_op", "mq_attr->mq_flags"], "call": "mq_open"}, {"reason": ["file->f_op"], "call": "open_by_handle_at"}], "faccessat": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["path->mnt"], "call": "eventfd2"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["path->mnt"], "call": "swapoff"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["path->mnt"], "call": "pivot_root"}, {"reason": ["path->mnt"], "call": "memfd_create"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->mnt"], "call": "dup3"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["path->mnt"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->uid"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["path->mnt"], "call": "epoll_create1"}, {"reason": ["path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->mnt"], "call": "flock"}, {"reason": ["path->mnt"], "call": "openat"}, {"reason": ["path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->mnt"], "call": "uselib"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["path->mnt"], "call": "accept4"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["path->mnt"], "call": "socketpair"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["path->mnt"], "call": "getcwd"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["path->mnt"], "call": "shmat"}, {"reason": ["path->mnt"], "call": "socket"}, {"reason": ["path->mnt"], "call": "pipe2"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->mnt"], "call": "shmdt"}, {"reason": ["path->mnt"], "call": "quotactl"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["path->mnt"], "call": "acct"}, {"reason": ["path->mnt"], "call": "open"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["path->mnt"], "call": "dup"}, {"reason": ["task_struct->cred", "path->mnt"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["path->mnt"], "call": "shmctl"}, {"reason": ["path->mnt"], "call": "swapon"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->uid"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->uid"], "call": "setuid"}, {"reason": ["path->mnt"], "call": "mmap_pgoff"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["path->mnt"], "call": "mq_open"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}, {"reason": ["path->mnt"], "call": "open_by_handle_at"}], "rmdir": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["dentry->d_inode"], "call": "mq_unlink"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["dentry->d_inode"], "call": "mkdirat"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["dentry->d_inode"], "call": "renameat2"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["dentry->d_inode"], "call": "ftruncate"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["dentry->d_inode"], "call": "mknodat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["dentry->d_inode"], "call": "symlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["dentry->d_inode"], "call": "linkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["dentry->d_inode"], "call": "unlink"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["dentry->d_inode"], "call": "unlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "fallocate": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "setgroups16": [{"reason": ["group_info->ngroups"], "call": "setgroups"}], "getdents64": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "io_cancel": [{"reason": ["mm_struct->ioctx_table"], "call": "swapoff"}, {"reason": ["mm_struct->ioctx_table"], "call": "remap_file_pages"}, {"reason": ["kioctx_table->nr", "kioctx->user_id", "mm_struct->ioctx_table"], "call": "io_getevents"}, {"reason": ["mm_struct->ioctx_table"], "call": "migrate_pages"}, {"reason": ["mm_struct->ioctx_table"], "call": "shmdt"}, {"reason": ["mm_struct->ioctx_table"], "call": "brk"}, {"reason": ["mm_struct->ioctx_table"], "call": "get_mempolicy"}, {"reason": ["kioctx->user_id"], "call": "io_submit"}, {"reason": ["mm_struct->ioctx_table"], "call": "getrusage"}, {"reason": ["kioctx_table->nr", "kioctx->user_id", "mm_struct->ioctx_table"], "call": "io_setup"}, {"reason": ["mm_struct->ioctx_table"], "call": "mremap"}, {"reason": ["kioctx_table->nr", "kioctx->user_id", "mm_struct->ioctx_table"], "call": "io_destroy"}, {"reason": ["mm_struct->ioctx_table"], "call": "mbind"}, {"reason": ["mm_struct->ioctx_table"], "call": "prctl"}, {"reason": ["mm_struct->ioctx_table"], "call": "move_pages"}, {"reason": ["mm_struct->ioctx_table"], "call": "modify_ldt"}, {"reason": ["mm_struct->ioctx_table"], "call": "mincore"}], "get_mempolicy": [{"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "keyctl"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "msgrcv"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "kill"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sched_getaffinity"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sched_setparam"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "ioprio_set"}, {"reason": ["vm_area_struct->vm_ops"], "call": "remap_file_pages"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "getppid"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "mq_timedreceive"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "capget"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sched_setaffinity"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "signal"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "semtimedop"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "umount"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "setsid"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sigaltstack"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sched_setattr"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "migrate_pages"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "getitimer"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "setpgid"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "getsid"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "prlimit64"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev", "mempolicy->mode"], "call": "set_mempolicy"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_ops"], "call": "shmdt"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "rt_sigaction"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_ops"], "call": "brk"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "getpriority"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sigaction"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "setns"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "fork"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "get_robust_list"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "mq_timedsend"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sched_getscheduler"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_ops"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_ops"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_ops"], "call": "madvise"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sched_getattr"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "getrusage"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sched_setscheduler"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "setitimer"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "ioprio_get"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "vfork"}, {"reason": ["vm_area_struct->vm_ops"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_ops"], "call": "mremap"}, {"reason": ["mempolicy->mode"], "call": "mbind"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev", "vm_area_struct->vm_ops"], "call": "prctl"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "move_pages"}, {"reason": ["vm_area_struct->vm_ops"], "call": "munlock"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_ops"], "call": "mincore"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "clone"}, {"reason": ["task_struct->mempolicy", "task_struct->il_prev"], "call": "sched_getparam"}, {"reason": ["vm_area_struct->vm_ops"], "call": "mlockall"}], "io_submit": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "inotify_init1": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["fsnotify_group->overflow_event", "inotify_group_private_data->ucounts"], "call": "inotify_rm_watch"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["fsnotify_group->overflow_event", "inotify_group_private_data->ucounts"], "call": "inotify_add_watch"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "futimesat": [{"reason": ["timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timeval->tv_usec"], "call": "waitid"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timeval->tv_usec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timeval->tv_usec"], "call": "adjtimex"}, {"reason": ["timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timeval->tv_usec"], "call": "getitimer"}, {"reason": ["timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_nsec"], "call": "poll"}, {"reason": ["timeval->tv_usec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timeval->tv_usec"], "call": "wait4"}, {"reason": ["timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timeval->tv_usec"], "call": "getrusage"}, {"reason": ["timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timeval->tv_usec"], "call": "setitimer"}, {"reason": ["timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timeval->tv_usec"], "call": "clock_adjtime"}, {"reason": ["timeval->tv_usec"], "call": "alarm"}, {"reason": ["timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timeval->tv_usec", "timespec->tv_nsec"], "call": "ppoll"}], "mq_timedsend": [{"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "dup3"}, {"reason": ["mqueue_inode_info->node_cache", "mq_attr->mq_curmsgs", "mq_attr->mq_maxmsg", "mq_attr->mq_msgsize"], "call": "mq_timedreceive"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "flock"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "openat"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "uselib"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "accept4"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "shmat"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "socket"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "acct"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "open"}, {"reason": ["mqueue_inode_info->node_cache", "mq_attr->mq_curmsgs", "mq_attr->mq_maxmsg", "file->f_flags", "mq_attr->mq_msgsize"], "call": "mq_getsetattr"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "dup"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "setns"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["mqueue_inode_info->node_cache", "mq_attr->mq_curmsgs", "mq_attr->mq_maxmsg", "mq_attr->mq_msgsize"], "call": "mq_notify"}, {"reason": ["mq_attr->mq_curmsgs", "file->f_op", "mq_attr->mq_maxmsg", "file->f_mode", "file->f_flags", "mq_attr->mq_msgsize"], "call": "mq_open"}, {"reason": ["file->f_op", "file->f_flags", "file->f_mode"], "call": "open_by_handle_at"}], "getresgid16": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "sched_getscheduler": [{"reason": ["task_struct->sched_reset_on_fork"], "call": "keyctl"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "msgrcv"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "kill"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_getaffinity"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_setparam"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "ioprio_set"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getppid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "mq_timedreceive"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "capget"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_setaffinity"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "signal"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "semtimedop"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "umount"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setsid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sigaltstack"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_setattr"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "migrate_pages"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getitimer"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setpgid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getsid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "prlimit64"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "perf_event_open"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "rt_sigaction"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getpgid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getpriority"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sigaction"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setns"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "fork"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "get_robust_list"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "mq_timedsend"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "ptrace"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_getattr"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getrusage"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_setscheduler"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setitimer"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "ioprio_get"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "vfork"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "prctl"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "move_pages"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setpriority"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "clone"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_getparam"}], "fgetxattr": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "ptrace": [{"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "keyctl"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "msgrcv"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "kill"}, {"reason": ["task_struct->state"], "call": "pause"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sched_setparam"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "ioprio_set"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "getppid"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "capget"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sched_setaffinity"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "semtimedop"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "umount"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "setsid"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sigaltstack"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sched_setattr"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "migrate_pages"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "getitimer"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "setpgid"}, {"reason": ["task_struct->state"], "call": "rt_sigsuspend"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "getsid"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "prlimit64"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "perf_event_open"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "getpgid"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "getpriority"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sigaction"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "setns"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "fork"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "get_robust_list"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["task_struct->state"], "call": "epoll_wait"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sched_getattr"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "getrusage"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "setitimer"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "ioprio_get"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "prctl"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "move_pages"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "setpriority"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "clone"}, {"reason": ["task_struct->state"], "call": "sigsuspend"}, {"reason": ["task_struct->exit_state", "task_struct->parent", "task_struct->state", "task_struct->real_parent", "task_struct->ptrace", "task_struct->flags"], "call": "sched_getparam"}], "shmctl": [{"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["kern_ipc_perm->mode", "kern_ipc_perm->deleted", "mm_segment_t->seg", "ipc_namespace->user_ns", "task_struct->cred"], "call": "msgrcv"}, {"reason": ["file->f_op"], "call": "eventfd2"}, {"reason": ["ipc_namespace->user_ns"], "call": "mq_unlink"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "kill"}, {"reason": ["file->f_op"], "call": "swapoff"}, {"reason": ["ipc_namespace->user_ns"], "call": "msgget"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sched_setparam"}, {"reason": ["file->f_op"], "call": "memfd_create"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["file->f_op"], "call": "remap_file_pages"}, {"reason": ["file->f_op"], "call": "dup3"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "capget"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "signal"}, {"reason": ["kern_ipc_perm->mode", "kern_ipc_perm->deleted", "mm_segment_t->seg", "ipc_namespace->user_ns", "task_struct->cred"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "umount"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["file->f_op"], "call": "epoll_create1"}, {"reason": ["kern_ipc_perm->mode", "kern_ipc_perm->deleted", "ipc_namespace->user_ns"], "call": "semctl"}, {"reason": ["file->f_op"], "call": "epoll_ctl"}, {"reason": ["file->f_op"], "call": "flock"}, {"reason": ["file->f_op"], "call": "openat"}, {"reason": ["ipc_namespace->user_ns"], "call": "shmget"}, {"reason": ["file->f_op"], "call": "uselib"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["file->f_op"], "call": "accept4"}, {"reason": ["kern_ipc_perm->mode", "kern_ipc_perm->deleted", "ipc_namespace->user_ns"], "call": "msgctl"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "setsid"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sched_setattr"}, {"reason": ["file->f_op"], "call": "socketpair"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "setpgid"}, {"reason": ["ipc_namespace->user_ns"], "call": "semget"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "getsid"}, {"reason": ["file->f_op", "kern_ipc_perm->deleted", "ipc_namespace->user_ns", "kern_ipc_perm->mode"], "call": "shmat"}, {"reason": ["file->f_op"], "call": "socket"}, {"reason": ["file->f_op"], "call": "pipe2"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["file->f_op", "mm_segment_t->seg", "task_struct->cred"], "call": "perf_event_open"}, {"reason": ["file->f_op"], "call": "shmdt"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "getpgid"}, {"reason": ["file->f_op"], "call": "acct"}, {"reason": ["file->f_op"], "call": "open"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sigaction"}, {"reason": ["file->f_op"], "call": "dup"}, {"reason": ["file->f_op", "mm_segment_t->seg", "task_struct->cred", "ipc_namespace->user_ns"], "call": "setns"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "fork"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "ptrace"}, {"reason": ["file->f_op"], "call": "swapon"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "vfork"}, {"reason": ["file->f_op"], "call": "mmap_pgoff"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "prctl"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "move_pages"}, {"reason": ["kern_ipc_perm->mode", "kern_ipc_perm->deleted", "ipc_namespace->user_ns"], "call": "msgsnd"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "clone"}, {"reason": ["file->f_op", "ipc_namespace->user_ns"], "call": "mq_open"}, {"reason": ["mm_segment_t->seg", "task_struct->cred"], "call": "sched_getparam"}, {"reason": ["file->f_op"], "call": "open_by_handle_at"}], "fcntl64": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags", "flock->l_len", "flock->l_start"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "munlockall": [{"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mlockall"}], "swapon": [{"reason": ["inode->i_flags"], "call": "mq_unlink"}, {"reason": ["inode->i_flags", "swap_info_struct->bdev", "swap_info_struct->type", "swap_info_struct->percpu_cluster", "swap_info_struct->flags"], "call": "swapoff"}, {"reason": ["inode->i_flags"], "call": "fchmod"}, {"reason": ["inode->i_flags"], "call": "memfd_create"}, {"reason": ["inode->i_flags"], "call": "readlinkat"}, {"reason": ["inode->i_flags"], "call": "fchown"}, {"reason": ["inode->i_flags"], "call": "mq_timedreceive"}, {"reason": ["inode->i_flags"], "call": "uselib"}, {"reason": ["inode->i_flags"], "call": "fchmodat"}, {"reason": ["inode->i_flags"], "call": "inotify_add_watch"}, {"reason": ["inode->i_flags"], "call": "ftruncate"}, {"reason": ["inode->i_flags"], "call": "ioctl"}, {"reason": ["inode->i_flags"], "call": "linkat"}, {"reason": ["inode->i_flags"], "call": "unlink"}, {"reason": ["inode->i_flags"], "call": "mq_getsetattr"}, {"reason": ["inode->i_flags"], "call": "faccessat"}, {"reason": ["inode->i_flags"], "call": "mq_timedsend"}, {"reason": ["inode->i_flags"], "call": "fchownat"}, {"reason": ["inode->i_flags"], "call": "mq_notify"}, {"reason": ["inode->i_flags"], "call": "sendfile"}, {"reason": ["inode->i_flags"], "call": "unlinkat"}, {"reason": ["inode->i_flags"], "call": "sendfile64"}], "pkey_mprotect": [{"reason": ["task_struct->personality", "task_struct->mm"], "call": "keyctl"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "msgrcv"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "kill"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_setparam"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getppid"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "capget"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "signal"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "semtimedop"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "umount"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setsid"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sigaltstack"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_setattr"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "migrate_pages"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getitimer"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setpgid"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getsid"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "prlimit64"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getpriority"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sigaction"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setns"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_getattr"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getrusage"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setitimer"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "ioprio_get"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "vfork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["task_struct->personality", "task_struct->mm", "vm_area_struct->vm_flags", "vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "move_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "clone"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_getparam"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mlockall"}], "signalfd4": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_op"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_op"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["file->f_op"], "call": "memfd_create"}, {"reason": ["file->f_op"], "call": "remap_file_pages"}, {"reason": ["file->f_op"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_op"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["file->f_op", "fd->flags"], "call": "epoll_ctl"}, {"reason": ["file->f_op", "fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_op"], "call": "openat"}, {"reason": ["file->f_op"], "call": "uselib"}, {"reason": ["file->f_op", "fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_op"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_op"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_op"], "call": "socket"}, {"reason": ["file->f_op"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["file->f_op", "fd->flags"], "call": "perf_event_open"}, {"reason": ["file->f_op"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_op"], "call": "acct"}, {"reason": ["file->f_op"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_op"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_op"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_op"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_op"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_op"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_op"], "call": "mq_open"}, {"reason": ["file->f_op"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "madvise": [{"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mlockall"}], "getresuid": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "statfs": [{"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "ustat"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs64"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs64"}], "mount": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}], "timerfd_gettime": [{"reason": ["timerfd_ctx->tintv", "timerfd_ctx->expired"], "call": "timerfd_settime"}, {"reason": ["timerfd_ctx->tintv", "timerfd_ctx->expired"], "call": "timerfd_create"}], "fchownat": [{"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["path->dentry"], "call": "swapoff"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["path->dentry"], "call": "epoll_ctl"}, {"reason": ["path->dentry"], "call": "flock"}, {"reason": ["path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["path->dentry"], "call": "uselib"}, {"reason": ["path->dentry"], "call": "accept4"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["path->dentry"], "call": "shmat"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["path->dentry"], "call": "quotactl"}, {"reason": ["path->dentry"], "call": "acct"}, {"reason": ["path->dentry"], "call": "open"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["path->dentry"], "call": "setns"}, {"reason": ["path->dentry"], "call": "shmctl"}, {"reason": ["path->dentry"], "call": "swapon"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["path->dentry"], "call": "mq_open"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}], "getrusage": [{"reason": ["signal_struct->maxrss"], "call": "timer_create"}, {"reason": ["signal_struct->maxrss"], "call": "exit_group"}], "fstat": [{"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "lstat"}, {"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "stat"}, {"reason": ["kstat->ino", "kstat->nlink", "kstat->rdev", "kstat->dev"], "call": "newfstat"}], "timerfd_settime": [{"reason": ["timerfd_ctx->tintv", "timerfd_ctx->expired"], "call": "timerfd_gettime"}, {"reason": ["timerfd_ctx->tintv", "timerfd_ctx->expired"], "call": "timerfd_create"}], "setresuid": [{"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setgid"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user", "cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setfsgid"}, {"reason": ["cred->user", "cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->uid", "cred->user", "cred->suid", "cred->euid", "cred->user_ns"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user", "cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setresgid"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user", "cred->user_ns"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->uid", "cred->user", "cred->suid", "cred->euid", "cred->user_ns"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getgroups"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "ioprio_get": [{"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "keyctl"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "msgrcv"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "kill"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sched_getaffinity"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sched_setparam"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "ioprio_set"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "getppid"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "mq_timedreceive"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "capget"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sched_setaffinity"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "signal"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "semtimedop"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "umount"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "setsid"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sigaltstack"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sched_setattr"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "migrate_pages"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "getitimer"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "setpgid"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "getsid"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "prlimit64"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "perf_event_open"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "rt_sigaction"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "getpgid"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "getpriority"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sigaction"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "setns"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "fork"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "get_robust_list"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "mq_timedsend"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sched_getscheduler"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "ptrace"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sched_getattr"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "getrusage"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sched_setscheduler"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "setitimer"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "vfork"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "prctl"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "move_pages"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "setpriority"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "clone"}, {"reason": ["task_struct->real_cred", "task_struct->cred", "task_struct->io_context"], "call": "sched_getparam"}], "setuid": [{"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresuid16"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setgid"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->user", "cred->user_ns"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setfsgid"}, {"reason": ["cred->user", "cred->user_ns"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->uid", "cred->user_ns", "cred->suid", "cred->user"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->user", "cred->user_ns"], "call": "epoll_create1"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setresgid"}, {"reason": ["cred->user", "cred->user_ns"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->user", "cred->user_ns"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->uid", "cred->user_ns", "cred->suid", "cred->user"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->user", "cred->user_ns"], "call": "getgroups"}, {"reason": ["cred->user", "cred->user_ns", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "io_setup": [{"reason": ["kioctx->cpu", "kioctx->max_reqs", "kioctx->req_batch", "kioctx->mmap_base", "kioctx->mmap_size"], "call": "io_getevents"}, {"reason": ["kioctx->cpu", "kioctx->max_reqs", "kioctx->req_batch", "kioctx->mmap_base", "kioctx->mmap_size"], "call": "io_submit"}, {"reason": ["kioctx->cpu", "kioctx->max_reqs", "kioctx->req_batch", "kioctx->mmap_base", "kioctx->mmap_size"], "call": "io_destroy"}, {"reason": ["kioctx->cpu", "kioctx->max_reqs", "kioctx->req_batch", "kioctx->mmap_base", "kioctx->mmap_size"], "call": "io_cancel"}], "mprotect": [{"reason": ["task_struct->personality", "task_struct->mm"], "call": "keyctl"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "msgrcv"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "kill"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_setparam"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getppid"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "capget"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "signal"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "semtimedop"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "umount"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setsid"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sigaltstack"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_setattr"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "migrate_pages"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getitimer"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setpgid"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getsid"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "prlimit64"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getpriority"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sigaction"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setns"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_getattr"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "getrusage"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setitimer"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "ioprio_get"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "vfork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["task_struct->personality", "task_struct->mm", "vm_area_struct->vm_flags", "vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "move_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "clone"}, {"reason": ["task_struct->personality", "task_struct->mm"], "call": "sched_getparam"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mlockall"}], "mmap_pgoff": [{"reason": ["file->f_op"], "call": "eventfd2"}, {"reason": ["file->f_op"], "call": "swapoff"}, {"reason": ["file->f_op"], "call": "memfd_create"}, {"reason": ["file->f_op"], "call": "remap_file_pages"}, {"reason": ["file->f_op"], "call": "dup3"}, {"reason": ["file->f_op"], "call": "epoll_create1"}, {"reason": ["file->f_op"], "call": "epoll_ctl"}, {"reason": ["file->f_op"], "call": "flock"}, {"reason": ["file->f_op"], "call": "openat"}, {"reason": ["file->f_op"], "call": "uselib"}, {"reason": ["file->f_op"], "call": "accept4"}, {"reason": ["file->f_op"], "call": "socketpair"}, {"reason": ["file->f_op"], "call": "shmat"}, {"reason": ["file->f_op"], "call": "socket"}, {"reason": ["file->f_op"], "call": "pipe2"}, {"reason": ["file->f_op"], "call": "perf_event_open"}, {"reason": ["file->f_op"], "call": "shmdt"}, {"reason": ["file->f_op"], "call": "acct"}, {"reason": ["file->f_op"], "call": "open"}, {"reason": ["file->f_op"], "call": "dup"}, {"reason": ["file->f_op"], "call": "setns"}, {"reason": ["file->f_op"], "call": "shmctl"}, {"reason": ["file->f_op"], "call": "swapon"}, {"reason": ["file->f_op"], "call": "mq_open"}, {"reason": ["file->f_op"], "call": "open_by_handle_at"}], "mremap": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["mm_struct->map_count"], "call": "swapoff"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["mm_struct->map_count"], "call": "io_getevents"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality", "mm_struct->map_count"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality", "mm_struct->map_count"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["mm_struct->map_count"], "call": "io_setup"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["mm_struct->map_count"], "call": "io_destroy"}, {"reason": ["mm_struct->map_count"], "call": "mbind"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "task_struct->personality", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["task_struct->personality", "mm_struct->map_count"], "call": "move_pages"}, {"reason": ["mm_struct->map_count"], "call": "modify_ldt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["mm_struct->map_count"], "call": "io_cancel"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_next", "vm_area_struct->vm_file", "vm_area_struct->vm_ops", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "mlockall"}], "geteuid": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "io_destroy": [{"reason": ["mm_struct->ioctx_table"], "call": "swapoff"}, {"reason": ["mm_struct->ioctx_table"], "call": "remap_file_pages"}, {"reason": ["kioctx->max_reqs", "kioctx_table->nr", "kioctx->mmap_size", "kioctx->mmap_base", "mm_struct->ioctx_table", "kioctx->user_id"], "call": "io_getevents"}, {"reason": ["mm_struct->ioctx_table"], "call": "migrate_pages"}, {"reason": ["mm_struct->ioctx_table"], "call": "shmdt"}, {"reason": ["mm_struct->ioctx_table"], "call": "brk"}, {"reason": ["mm_struct->ioctx_table"], "call": "get_mempolicy"}, {"reason": ["kioctx->max_reqs", "kioctx->user_id", "kioctx->mmap_base", "kioctx->mmap_size"], "call": "io_submit"}, {"reason": ["mm_struct->ioctx_table"], "call": "getrusage"}, {"reason": ["kioctx->max_reqs", "kioctx_table->nr", "kioctx->mmap_size", "kioctx->mmap_base", "mm_struct->ioctx_table", "kioctx->user_id"], "call": "io_setup"}, {"reason": ["mm_struct->ioctx_table"], "call": "mremap"}, {"reason": ["mm_struct->ioctx_table"], "call": "mbind"}, {"reason": ["mm_struct->ioctx_table"], "call": "prctl"}, {"reason": ["mm_struct->ioctx_table"], "call": "move_pages"}, {"reason": ["mm_struct->ioctx_table"], "call": "modify_ldt"}, {"reason": ["mm_struct->ioctx_table"], "call": "mincore"}, {"reason": ["kioctx->max_reqs", "kioctx_table->nr", "kioctx->mmap_size", "kioctx->mmap_base", "mm_struct->ioctx_table", "kioctx->user_id"], "call": "io_cancel"}], "pread64": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "preadv64v2": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "prctl": [{"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "keyctl"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "msgrcv"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "kill"}, {"reason": ["mm_struct->flags"], "call": "swapoff"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_setparam"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["mm_struct->flags"], "call": "remap_file_pages"}, {"reason": ["mm_struct->flags"], "call": "io_getevents"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getppid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "capget"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "semtimedop"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "umount"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setsid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sigaltstack"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_setattr"}, {"reason": ["mm_struct->flags", "task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "migrate_pages"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getitimer"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setpgid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getsid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "prlimit64"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "perf_event_open"}, {"reason": ["mm_struct->flags"], "call": "shmdt"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getpgid"}, {"reason": ["mm_struct->flags"], "call": "brk"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getpriority"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sigaction"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setns"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "fork"}, {"reason": ["mm_struct->flags"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "ptrace"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_getattr"}, {"reason": ["mm_struct->flags", "task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getrusage"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setitimer"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "ioprio_get"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["mm_struct->flags"], "call": "io_setup"}, {"reason": ["mm_struct->flags"], "call": "mremap"}, {"reason": ["mm_struct->flags"], "call": "io_destroy"}, {"reason": ["mm_struct->flags"], "call": "mbind"}, {"reason": ["mm_struct->flags", "task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "move_pages"}, {"reason": ["mm_struct->flags"], "call": "modify_ldt"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setpriority"}, {"reason": ["mm_struct->flags"], "call": "mincore"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "clone"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_getparam"}, {"reason": ["mm_struct->flags"], "call": "io_cancel"}], "copy_file_range": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "flock": [{"reason": ["fd->flags", "super_block->s_flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["super_block->s_flags"], "call": "ustat"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["super_block->s_flags"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["super_block->s_flags"], "call": "quotactl"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["super_block->s_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "fstatfs": [{"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "ustat"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs64"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs64"}], "modify_ldt": [{"reason": ["mm_context_t->ldt"], "call": "swapoff"}, {"reason": ["mm_context_t->ldt"], "call": "remap_file_pages"}, {"reason": ["mm_context_t->ldt"], "call": "io_getevents"}, {"reason": ["user_desc->limit_in_pages", "user_desc->read_exec_only", "user_desc->limit", "user_desc->useable", "user_desc->contents", "user_desc->seg_32bit", "user_desc->seg_not_present", "user_desc->entry_number", "user_desc->base_addr"], "call": "get_thread_area"}, {"reason": ["mm_context_t->ldt"], "call": "migrate_pages"}, {"reason": ["mm_context_t->ldt"], "call": "shmdt"}, {"reason": ["mm_context_t->ldt"], "call": "brk"}, {"reason": ["mm_context_t->ldt"], "call": "get_mempolicy"}, {"reason": ["mm_context_t->ldt"], "call": "getrusage"}, {"reason": ["mm_context_t->ldt"], "call": "io_setup"}, {"reason": ["mm_context_t->ldt"], "call": "mremap"}, {"reason": ["mm_context_t->ldt"], "call": "io_destroy"}, {"reason": ["mm_context_t->ldt"], "call": "mbind"}, {"reason": ["mm_context_t->ldt"], "call": "prctl"}, {"reason": ["mm_context_t->ldt"], "call": "move_pages"}, {"reason": ["mm_context_t->ldt"], "call": "mincore"}, {"reason": ["user_desc->limit_in_pages", "user_desc->read_exec_only", "user_desc->limit", "user_desc->useable", "user_desc->contents", "user_desc->seg_32bit", "user_desc->base_addr", "user_desc->entry_number", "user_desc->seg_not_present"], "call": "set_thread_area"}, {"reason": ["mm_context_t->ldt"], "call": "io_cancel"}], "sched_getattr": [{"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "kill"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "capget"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "signal"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "umount"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setsid"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg", "sched_attr->size"], "call": "sched_setattr"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getsid"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setns"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "fork"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "vfork"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "prctl"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "clone"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_getparam"}], "sched_getparam": [{"reason": ["task_struct->policy"], "call": "keyctl"}, {"reason": ["task_struct->policy"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->policy"], "call": "msgrcv"}, {"reason": ["task_struct->policy"], "call": "kill"}, {"reason": ["task_struct->policy"], "call": "sched_getaffinity"}, {"reason": ["task_struct->policy"], "call": "sched_setparam"}, {"reason": ["task_struct->policy"], "call": "ioprio_set"}, {"reason": ["task_struct->policy"], "call": "getppid"}, {"reason": ["task_struct->policy"], "call": "mq_timedreceive"}, {"reason": ["task_struct->policy"], "call": "capget"}, {"reason": ["task_struct->policy"], "call": "sched_setaffinity"}, {"reason": ["task_struct->policy"], "call": "signal"}, {"reason": ["task_struct->policy"], "call": "semtimedop"}, {"reason": ["task_struct->policy"], "call": "umount"}, {"reason": ["task_struct->policy"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->policy"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->policy"], "call": "setsid"}, {"reason": ["task_struct->policy"], "call": "sigaltstack"}, {"reason": ["task_struct->policy"], "call": "sched_setattr"}, {"reason": ["task_struct->policy"], "call": "migrate_pages"}, {"reason": ["task_struct->policy"], "call": "getitimer"}, {"reason": ["task_struct->policy"], "call": "setpgid"}, {"reason": ["task_struct->policy"], "call": "getsid"}, {"reason": ["task_struct->policy"], "call": "prlimit64"}, {"reason": ["task_struct->policy"], "call": "perf_event_open"}, {"reason": ["task_struct->policy"], "call": "rt_sigaction"}, {"reason": ["task_struct->policy"], "call": "getpgid"}, {"reason": ["task_struct->policy"], "call": "getpriority"}, {"reason": ["task_struct->policy"], "call": "sigaction"}, {"reason": ["task_struct->policy"], "call": "setns"}, {"reason": ["task_struct->policy"], "call": "fork"}, {"reason": ["task_struct->policy"], "call": "get_robust_list"}, {"reason": ["task_struct->policy"], "call": "mq_timedsend"}, {"reason": ["task_struct->policy"], "call": "sched_getscheduler"}, {"reason": ["task_struct->policy"], "call": "ptrace"}, {"reason": ["task_struct->policy"], "call": "sched_getattr"}, {"reason": ["task_struct->policy"], "call": "getrusage"}, {"reason": ["task_struct->policy"], "call": "sched_setscheduler"}, {"reason": ["task_struct->policy"], "call": "setitimer"}, {"reason": ["task_struct->policy"], "call": "ioprio_get"}, {"reason": ["task_struct->policy"], "call": "vfork"}, {"reason": ["task_struct->policy"], "call": "prctl"}, {"reason": ["task_struct->policy"], "call": "move_pages"}, {"reason": ["task_struct->policy"], "call": "setpriority"}, {"reason": ["task_struct->policy"], "call": "clone"}], "fstatfs64": [{"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "ustat"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs64"}], "rt_sigreturn": [{"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "kill"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getppid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "capget"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "signal"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "umount"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setsid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getsid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setns"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "fork"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "vfork"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "prctl"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "clone"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_getparam"}], "write": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "tkill": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "munlock": [{"reason": ["task_struct->mm"], "call": "keyctl"}, {"reason": ["task_struct->mm"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->mm"], "call": "msgrcv"}, {"reason": ["task_struct->mm"], "call": "kill"}, {"reason": ["task_struct->mm"], "call": "sched_getaffinity"}, {"reason": ["task_struct->mm"], "call": "sched_setparam"}, {"reason": ["task_struct->mm"], "call": "ioprio_set"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["task_struct->mm"], "call": "getppid"}, {"reason": ["task_struct->mm"], "call": "mq_timedreceive"}, {"reason": ["task_struct->mm"], "call": "capget"}, {"reason": ["task_struct->mm"], "call": "sched_setaffinity"}, {"reason": ["task_struct->mm"], "call": "signal"}, {"reason": ["task_struct->mm"], "call": "semtimedop"}, {"reason": ["task_struct->mm"], "call": "umount"}, {"reason": ["task_struct->mm"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->mm"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->mm"], "call": "setsid"}, {"reason": ["task_struct->mm"], "call": "sigaltstack"}, {"reason": ["task_struct->mm"], "call": "sched_setattr"}, {"reason": ["task_struct->mm"], "call": "migrate_pages"}, {"reason": ["task_struct->mm"], "call": "getitimer"}, {"reason": ["task_struct->mm"], "call": "setpgid"}, {"reason": ["task_struct->mm"], "call": "getsid"}, {"reason": ["task_struct->mm"], "call": "prlimit64"}, {"reason": ["task_struct->mm"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["task_struct->mm"], "call": "rt_sigaction"}, {"reason": ["task_struct->mm"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["task_struct->mm"], "call": "getpriority"}, {"reason": ["task_struct->mm"], "call": "sigaction"}, {"reason": ["task_struct->mm"], "call": "setns"}, {"reason": ["task_struct->mm"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["task_struct->mm"], "call": "get_robust_list"}, {"reason": ["task_struct->mm"], "call": "mq_timedsend"}, {"reason": ["task_struct->mm"], "call": "sched_getscheduler"}, {"reason": ["task_struct->mm"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["task_struct->mm"], "call": "sched_getattr"}, {"reason": ["task_struct->mm"], "call": "getrusage"}, {"reason": ["task_struct->mm"], "call": "sched_setscheduler"}, {"reason": ["task_struct->mm"], "call": "setitimer"}, {"reason": ["task_struct->mm"], "call": "ioprio_get"}, {"reason": ["task_struct->mm"], "call": "vfork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "task_struct->mm", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["task_struct->mm"], "call": "move_pages"}, {"reason": ["task_struct->mm"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["task_struct->mm"], "call": "clone"}, {"reason": ["task_struct->mm"], "call": "sched_getparam"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mlockall"}], "setpriority": [{"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "signal"}, {"reason": ["cred->uid"], "call": "setreuid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->uid"], "call": "setresuid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "vfork"}, {"reason": ["cred->uid"], "call": "setuid"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->real_cred", "task_struct->cred"], "call": "sched_getparam"}], "recvmsg": [{"reason": ["socket->file"], "call": "recvfrom"}, {"reason": ["socket->file"], "call": "sendto"}, {"reason": ["socket->file"], "call": "connect"}, {"reason": ["socket->file"], "call": "getsockname"}, {"reason": ["socket->file"], "call": "accept4"}, {"reason": ["socket->file"], "call": "getpeername"}, {"reason": ["socket->file"], "call": "setsockopt"}, {"reason": ["socket->file"], "call": "sendmsg"}, {"reason": ["socket->file"], "call": "shutdown"}, {"reason": ["socket->file"], "call": "getsockopt"}, {"reason": ["socket->file"], "call": "listen"}, {"reason": ["socket->file"], "call": "sendmmsg"}, {"reason": ["socket->file"], "call": "bind"}, {"reason": ["socket->file"], "call": "recvmmsg"}], "shmdt": [{"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "remap_file_pages"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "brk"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "madvise"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_pgoff", "vm_area_struct->vm_ops", "vm_area_struct->vm_file"], "call": "mlockall"}], "getrlimit": [{"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "setrlimit"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "old_getrlimit"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "prlimit64"}], "mincore": [{"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "kill"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["vm_area_struct->vm_start"], "call": "remap_file_pages"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "capget"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "signal"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "umount"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "setsid"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "getsid"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start"], "call": "shmdt"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start"], "call": "brk"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "setns"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start"], "call": "get_mempolicy"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start"], "call": "madvise"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "vfork"}, {"reason": ["vm_area_struct->vm_start"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "task_struct->mm", "mm_segment_t->seg"], "call": "prctl"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["vm_area_struct->vm_start"], "call": "munlock"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "clone"}, {"reason": ["task_struct->mm", "mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["vm_area_struct->vm_start"], "call": "mlockall"}], "mq_notify": [{"reason": ["sigval->sival_ptr"], "call": "rt_sigtimedwait"}, {"reason": ["file->f_op"], "call": "eventfd2"}, {"reason": ["file->f_op"], "call": "swapoff"}, {"reason": ["file->f_op"], "call": "memfd_create"}, {"reason": ["file->f_op"], "call": "remap_file_pages"}, {"reason": ["file->f_op"], "call": "dup3"}, {"reason": ["sigval->sival_ptr", "sigevent->sigev_signo", "mqueue_inode_info->notify_owner", "sigevent->sigev_notify"], "call": "mq_timedreceive"}, {"reason": ["sigval->sival_ptr", "sigevent->sigev_signo", "sigevent->sigev_notify"], "call": "timer_create"}, {"reason": ["file->f_op"], "call": "epoll_create1"}, {"reason": ["sigval->sival_ptr"], "call": "rt_sigqueueinfo"}, {"reason": ["file->f_op"], "call": "epoll_ctl"}, {"reason": ["file->f_op"], "call": "flock"}, {"reason": ["sigval->sival_ptr"], "call": "tgkill"}, {"reason": ["file->f_op"], "call": "openat"}, {"reason": ["file->f_op"], "call": "uselib"}, {"reason": ["file->f_op"], "call": "accept4"}, {"reason": ["file->f_op"], "call": "socketpair"}, {"reason": ["file->f_op"], "call": "shmat"}, {"reason": ["file->f_op"], "call": "socket"}, {"reason": ["file->f_op"], "call": "pipe2"}, {"reason": ["file->f_op"], "call": "perf_event_open"}, {"reason": ["file->f_op"], "call": "shmdt"}, {"reason": ["file->f_op"], "call": "acct"}, {"reason": ["file->f_op"], "call": "open"}, {"reason": ["sigval->sival_ptr"], "call": "rt_tgsigqueueinfo"}, {"reason": ["sigval->sival_ptr", "sigevent->sigev_signo", "mqueue_inode_info->notify_owner", "sigevent->sigev_notify"], "call": "mq_getsetattr"}, {"reason": ["file->f_op"], "call": "dup"}, {"reason": ["file->f_op"], "call": "setns"}, {"reason": ["sigval->sival_ptr", "sigevent->sigev_signo", "mqueue_inode_info->notify_owner", "sigevent->sigev_notify"], "call": "mq_timedsend"}, {"reason": ["file->f_op"], "call": "shmctl"}, {"reason": ["file->f_op"], "call": "swapon"}, {"reason": ["file->f_op"], "call": "mmap_pgoff"}, {"reason": ["sigval->sival_ptr"], "call": "rt_sigreturn"}, {"reason": ["sigval->sival_ptr"], "call": "tkill"}, {"reason": ["file->f_op"], "call": "mq_open"}, {"reason": ["file->f_op"], "call": "open_by_handle_at"}], "sendfile": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "sendmmsg": [{"reason": ["socket->file"], "call": "recvfrom"}, {"reason": ["socket->file"], "call": "sendto"}, {"reason": ["socket->file"], "call": "connect"}, {"reason": ["socket->file"], "call": "getsockname"}, {"reason": ["socket->file"], "call": "accept4"}, {"reason": ["socket->file"], "call": "getpeername"}, {"reason": ["socket->file"], "call": "setsockopt"}, {"reason": ["socket->file"], "call": "sendmsg"}, {"reason": ["socket->file"], "call": "shutdown"}, {"reason": ["socket->file"], "call": "getsockopt"}, {"reason": ["socket->file"], "call": "listen"}, {"reason": ["socket->file"], "call": "recvmsg"}, {"reason": ["socket->file"], "call": "bind"}, {"reason": ["socket->file"], "call": "recvmmsg"}], "timer_getoverrun": [{"reason": ["task_struct->signal"], "call": "keyctl"}, {"reason": ["task_struct->signal"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->signal"], "call": "msgrcv"}, {"reason": ["task_struct->signal"], "call": "kill"}, {"reason": ["k_itimer->it_signal"], "call": "timer_delete"}, {"reason": ["task_struct->signal"], "call": "sched_getaffinity"}, {"reason": ["task_struct->signal"], "call": "sched_setparam"}, {"reason": ["task_struct->signal"], "call": "ioprio_set"}, {"reason": ["task_struct->signal"], "call": "getppid"}, {"reason": ["task_struct->signal"], "call": "mq_timedreceive"}, {"reason": ["task_struct->signal"], "call": "capget"}, {"reason": ["task_struct->signal"], "call": "sched_setaffinity"}, {"reason": ["task_struct->signal"], "call": "signal"}, {"reason": ["task_struct->signal"], "call": "semtimedop"}, {"reason": ["task_struct->signal"], "call": "umount"}, {"reason": ["k_itimer->it_signal"], "call": "timer_create"}, {"reason": ["task_struct->signal"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->signal"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->signal"], "call": "setsid"}, {"reason": ["task_struct->signal"], "call": "sigaltstack"}, {"reason": ["task_struct->signal"], "call": "sched_setattr"}, {"reason": ["task_struct->signal"], "call": "migrate_pages"}, {"reason": ["task_struct->signal"], "call": "getitimer"}, {"reason": ["task_struct->signal"], "call": "setpgid"}, {"reason": ["k_itimer->it_signal"], "call": "timer_settime"}, {"reason": ["k_itimer->it_signal"], "call": "timer_gettime"}, {"reason": ["task_struct->signal"], "call": "getsid"}, {"reason": ["task_struct->signal"], "call": "prlimit64"}, {"reason": ["task_struct->signal"], "call": "perf_event_open"}, {"reason": ["task_struct->signal"], "call": "rt_sigaction"}, {"reason": ["task_struct->signal"], "call": "getpgid"}, {"reason": ["task_struct->signal"], "call": "getpriority"}, {"reason": ["task_struct->signal"], "call": "sigaction"}, {"reason": ["task_struct->signal"], "call": "setns"}, {"reason": ["task_struct->signal"], "call": "fork"}, {"reason": ["task_struct->signal"], "call": "get_robust_list"}, {"reason": ["task_struct->signal"], "call": "mq_timedsend"}, {"reason": ["task_struct->signal"], "call": "sched_getscheduler"}, {"reason": ["task_struct->signal"], "call": "ptrace"}, {"reason": ["task_struct->signal"], "call": "sched_getattr"}, {"reason": ["task_struct->signal"], "call": "getrusage"}, {"reason": ["task_struct->signal"], "call": "sched_setscheduler"}, {"reason": ["task_struct->signal"], "call": "setitimer"}, {"reason": ["task_struct->signal"], "call": "ioprio_get"}, {"reason": ["task_struct->signal"], "call": "vfork"}, {"reason": ["task_struct->signal"], "call": "prctl"}, {"reason": ["task_struct->signal"], "call": "move_pages"}, {"reason": ["task_struct->signal"], "call": "setpriority"}, {"reason": ["task_struct->signal"], "call": "clone"}, {"reason": ["task_struct->signal"], "call": "sched_getparam"}], "mlock2": [{"reason": ["task_struct->mm"], "call": "keyctl"}, {"reason": ["task_struct->mm"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->mm"], "call": "msgrcv"}, {"reason": ["task_struct->mm"], "call": "kill"}, {"reason": ["task_struct->mm"], "call": "sched_getaffinity"}, {"reason": ["task_struct->mm"], "call": "sched_setparam"}, {"reason": ["task_struct->mm"], "call": "ioprio_set"}, {"reason": ["task_struct->mm"], "call": "getppid"}, {"reason": ["task_struct->mm"], "call": "mq_timedreceive"}, {"reason": ["task_struct->mm"], "call": "capget"}, {"reason": ["task_struct->mm"], "call": "sched_setaffinity"}, {"reason": ["task_struct->mm"], "call": "signal"}, {"reason": ["task_struct->mm"], "call": "semtimedop"}, {"reason": ["task_struct->mm"], "call": "umount"}, {"reason": ["task_struct->mm"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->mm"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->mm"], "call": "setsid"}, {"reason": ["task_struct->mm"], "call": "sigaltstack"}, {"reason": ["task_struct->mm"], "call": "sched_setattr"}, {"reason": ["task_struct->mm"], "call": "migrate_pages"}, {"reason": ["task_struct->mm"], "call": "getitimer"}, {"reason": ["task_struct->mm"], "call": "setpgid"}, {"reason": ["task_struct->mm"], "call": "getsid"}, {"reason": ["task_struct->mm"], "call": "prlimit64"}, {"reason": ["task_struct->mm"], "call": "perf_event_open"}, {"reason": ["task_struct->mm"], "call": "rt_sigaction"}, {"reason": ["task_struct->mm"], "call": "getpgid"}, {"reason": ["task_struct->mm"], "call": "getpriority"}, {"reason": ["task_struct->mm"], "call": "sigaction"}, {"reason": ["task_struct->mm"], "call": "setns"}, {"reason": ["task_struct->mm"], "call": "fork"}, {"reason": ["task_struct->mm"], "call": "get_robust_list"}, {"reason": ["task_struct->mm"], "call": "mq_timedsend"}, {"reason": ["task_struct->mm"], "call": "sched_getscheduler"}, {"reason": ["task_struct->mm"], "call": "ptrace"}, {"reason": ["task_struct->mm"], "call": "sched_getattr"}, {"reason": ["task_struct->mm"], "call": "getrusage"}, {"reason": ["task_struct->mm"], "call": "sched_setscheduler"}, {"reason": ["task_struct->mm"], "call": "setitimer"}, {"reason": ["task_struct->mm"], "call": "ioprio_get"}, {"reason": ["task_struct->mm"], "call": "vfork"}, {"reason": ["task_struct->mm"], "call": "prctl"}, {"reason": ["task_struct->mm"], "call": "move_pages"}, {"reason": ["task_struct->mm"], "call": "setpriority"}, {"reason": ["task_struct->mm"], "call": "clone"}, {"reason": ["task_struct->mm"], "call": "sched_getparam"}], "newfstat": [{"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newlstat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newfstatat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newstat"}, {"reason": ["kstat->size", "kstat->nlink", "kstat->ino", "kstat->rdev", "kstat->dev"], "call": "fstat"}], "lremovexattr": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "preadv64": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "pwritev64": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "getxattr": [{"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["path->dentry"], "call": "swapoff"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["path->dentry"], "call": "epoll_ctl"}, {"reason": ["path->dentry"], "call": "flock"}, {"reason": ["path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["path->dentry"], "call": "uselib"}, {"reason": ["path->dentry"], "call": "accept4"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["path->dentry"], "call": "shmat"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["path->dentry"], "call": "quotactl"}, {"reason": ["path->dentry"], "call": "acct"}, {"reason": ["path->dentry"], "call": "open"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["path->dentry"], "call": "setns"}, {"reason": ["path->dentry"], "call": "shmctl"}, {"reason": ["path->dentry"], "call": "swapon"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["path->dentry"], "call": "mq_open"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}], "mq_open": [{"reason": ["filename->name"], "call": "sysfs"}, {"reason": ["path->dentry"], "call": "eventfd2"}, {"reason": ["filename->name"], "call": "mq_unlink"}, {"reason": ["filename->name", "path->dentry"], "call": "swapoff"}, {"reason": ["path->dentry"], "call": "pivot_root"}, {"reason": ["path->dentry"], "call": "memfd_create"}, {"reason": ["path->dentry"], "call": "remap_file_pages"}, {"reason": ["path->dentry"], "call": "dup3"}, {"reason": ["path->dentry"], "call": "unshare"}, {"reason": ["path->dentry"], "call": "epoll_create1"}, {"reason": ["path->dentry"], "call": "epoll_ctl"}, {"reason": ["path->dentry"], "call": "flock"}, {"reason": ["filename->name", "path->dentry"], "call": "openat"}, {"reason": ["path->dentry"], "call": "lookup_dcookie"}, {"reason": ["filename->name", "path->dentry"], "call": "uselib"}, {"reason": ["filename->name"], "call": "renameat2"}, {"reason": ["path->dentry"], "call": "accept4"}, {"reason": ["path->dentry"], "call": "socketpair"}, {"reason": ["path->dentry"], "call": "getcwd"}, {"reason": ["path->dentry"], "call": "shmat"}, {"reason": ["path->dentry"], "call": "socket"}, {"reason": ["filename->name"], "call": "symlinkat"}, {"reason": ["path->dentry"], "call": "pipe2"}, {"reason": ["path->dentry"], "call": "perf_event_open"}, {"reason": ["path->dentry"], "call": "shmdt"}, {"reason": ["filename->name", "path->dentry"], "call": "quotactl"}, {"reason": ["filename->name", "path->dentry"], "call": "acct"}, {"reason": ["filename->name", "path->dentry"], "call": "open"}, {"reason": ["filename->name"], "call": "unlink"}, {"reason": ["filename->name"], "call": "rmdir"}, {"reason": ["path->dentry"], "call": "dup"}, {"reason": ["path->dentry"], "call": "setns"}, {"reason": ["path->dentry"], "call": "shmctl"}, {"reason": ["filename->name", "path->dentry"], "call": "swapon"}, {"reason": ["path->dentry"], "call": "mmap_pgoff"}, {"reason": ["filename->name"], "call": "unlinkat"}, {"reason": ["path->dentry"], "call": "open_by_handle_at"}], "statfs64": [{"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "ustat"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs64"}], "getgid16": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "set_thread_area": [{"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "keyctl"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "rt_sigtimedwait"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "msgrcv"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "kill"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_getaffinity"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "arch_prctl"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_setparam"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "ioprio_set"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getppid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "ioperm"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "mq_timedreceive"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "capget"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_setaffinity"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "signal"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "semtimedop"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "umount"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_rr_get_interval"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "rt_sigprocmask"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setsid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sigaltstack"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_setattr"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "migrate_pages"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getitimer"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setpgid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getsid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "prlimit64"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "perf_event_open"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "rt_sigaction"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getpgid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getpriority"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sigaction"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setns"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "fork"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "get_robust_list"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "mq_timedsend"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_getscheduler"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "ptrace"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_getattr"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getrusage"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_setscheduler"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setitimer"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "ioprio_get"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "vfork"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "prctl"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "move_pages"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setpriority"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "clone"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_getparam"}], "getegid": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "clock_nanosleep": [{"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["k_clock->nsleep"], "call": "clock_getres"}, {"reason": ["k_clock->nsleep"], "call": "timer_delete"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["k_clock->nsleep"], "call": "timer_create"}, {"reason": ["k_clock->nsleep"], "call": "clock_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec", "k_clock->nsleep"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec", "k_clock->nsleep"], "call": "timer_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["k_clock->nsleep"], "call": "clock_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["k_clock->nsleep"], "call": "clock_adjtime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "unlinkat": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["dentry->d_inode"], "call": "mq_unlink"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["dentry->d_inode"], "call": "mkdirat"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["dentry->d_inode"], "call": "renameat2"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["dentry->d_inode"], "call": "ftruncate"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["dentry->d_inode"], "call": "mknodat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["dentry->d_inode"], "call": "symlinkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["dentry->d_inode"], "call": "linkat"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["dentry->d_inode"], "call": "unlink"}, {"reason": ["dentry->d_inode"], "call": "rmdir"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["dentry->d_inode", "path->dentry", "path->mnt"], "call": "mq_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "open_by_handle_at"}], "getgroups": [{"reason": ["cred->group_info", "task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["cred->group_info"], "call": "setfsuid"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["cred->group_info"], "call": "getresuid16"}, {"reason": ["cred->group_info"], "call": "getresgid"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["cred->group_info"], "call": "setgid"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "ioprio_set"}, {"reason": ["cred->group_info"], "call": "capset"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["cred->group_info"], "call": "getresgid16"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["cred->group_info"], "call": "setfsgid"}, {"reason": ["cred->group_info"], "call": "unshare"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["cred->group_info"], "call": "setreuid"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["cred->group_info"], "call": "epoll_create1"}, {"reason": ["cred->group_info"], "call": "getresuid"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["cred->group_info"], "call": "setresgid"}, {"reason": ["cred->group_info"], "call": "setregid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["cred->group_info"], "call": "getgroups16"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["cred->group_info"], "call": "faccessat"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["cred->group_info"], "call": "setresuid"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["cred->group_info"], "call": "setuid"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["cred->group_info", "task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "clock_adjtime": [{"reason": ["k_clock->clock_adj"], "call": "clock_getres"}, {"reason": ["k_clock->clock_adj"], "call": "timer_delete"}, {"reason": ["k_clock->clock_adj"], "call": "timer_create"}, {"reason": ["k_clock->clock_adj"], "call": "clock_gettime"}, {"reason": ["k_clock->clock_adj"], "call": "timer_settime"}, {"reason": ["k_clock->clock_adj"], "call": "timer_gettime"}, {"reason": ["k_clock->clock_adj"], "call": "clock_settime"}, {"reason": ["k_clock->clock_adj"], "call": "clock_nanosleep"}], "getuid": [{"reason": ["task_struct->cred"], "call": "keyctl"}, {"reason": ["task_struct->cred"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->cred"], "call": "msgrcv"}, {"reason": ["task_struct->cred"], "call": "kill"}, {"reason": ["task_struct->cred"], "call": "sched_getaffinity"}, {"reason": ["task_struct->cred"], "call": "sched_setparam"}, {"reason": ["task_struct->cred"], "call": "ioprio_set"}, {"reason": ["task_struct->cred"], "call": "getppid"}, {"reason": ["task_struct->cred"], "call": "mq_timedreceive"}, {"reason": ["task_struct->cred"], "call": "capget"}, {"reason": ["task_struct->cred"], "call": "sched_setaffinity"}, {"reason": ["task_struct->cred"], "call": "signal"}, {"reason": ["task_struct->cred"], "call": "semtimedop"}, {"reason": ["task_struct->cred"], "call": "umount"}, {"reason": ["task_struct->cred"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->cred"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->cred"], "call": "setsid"}, {"reason": ["task_struct->cred"], "call": "sigaltstack"}, {"reason": ["task_struct->cred"], "call": "sched_setattr"}, {"reason": ["task_struct->cred"], "call": "migrate_pages"}, {"reason": ["task_struct->cred"], "call": "getitimer"}, {"reason": ["task_struct->cred"], "call": "setpgid"}, {"reason": ["task_struct->cred"], "call": "getsid"}, {"reason": ["task_struct->cred"], "call": "prlimit64"}, {"reason": ["task_struct->cred"], "call": "perf_event_open"}, {"reason": ["task_struct->cred"], "call": "rt_sigaction"}, {"reason": ["task_struct->cred"], "call": "getpgid"}, {"reason": ["task_struct->cred"], "call": "getpriority"}, {"reason": ["task_struct->cred"], "call": "sigaction"}, {"reason": ["task_struct->cred"], "call": "setns"}, {"reason": ["task_struct->cred"], "call": "fork"}, {"reason": ["task_struct->cred"], "call": "get_robust_list"}, {"reason": ["task_struct->cred"], "call": "mq_timedsend"}, {"reason": ["task_struct->cred"], "call": "sched_getscheduler"}, {"reason": ["task_struct->cred"], "call": "ptrace"}, {"reason": ["task_struct->cred"], "call": "sched_getattr"}, {"reason": ["task_struct->cred"], "call": "getrusage"}, {"reason": ["task_struct->cred"], "call": "sched_setscheduler"}, {"reason": ["task_struct->cred"], "call": "setitimer"}, {"reason": ["task_struct->cred"], "call": "ioprio_get"}, {"reason": ["task_struct->cred"], "call": "vfork"}, {"reason": ["task_struct->cred"], "call": "prctl"}, {"reason": ["task_struct->cred"], "call": "move_pages"}, {"reason": ["task_struct->cred"], "call": "setpriority"}, {"reason": ["task_struct->cred"], "call": "clone"}, {"reason": ["task_struct->cred"], "call": "sched_getparam"}], "open_by_handle_at": [{"reason": ["path->dentry", "path->mnt"], "call": "eventfd2"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "pivot_root"}, {"reason": ["path->dentry", "path->mnt"], "call": "memfd_create"}, {"reason": ["path->dentry", "path->mnt"], "call": "remap_file_pages"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup3"}, {"reason": ["path->dentry", "path->mnt"], "call": "unshare"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_create1"}, {"reason": ["path->dentry", "path->mnt"], "call": "epoll_ctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "flock"}, {"reason": ["path->dentry", "path->mnt"], "call": "openat"}, {"reason": ["path->dentry", "path->mnt"], "call": "lookup_dcookie"}, {"reason": ["path->dentry", "path->mnt"], "call": "uselib"}, {"reason": ["path->dentry", "path->mnt"], "call": "accept4"}, {"reason": ["path->dentry", "path->mnt"], "call": "socketpair"}, {"reason": ["path->dentry", "path->mnt"], "call": "getcwd"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmat"}, {"reason": ["path->dentry", "path->mnt"], "call": "socket"}, {"reason": ["path->dentry", "path->mnt"], "call": "pipe2"}, {"reason": ["path->dentry", "path->mnt"], "call": "perf_event_open"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmdt"}, {"reason": ["path->dentry", "path->mnt"], "call": "quotactl"}, {"reason": ["path->dentry", "path->mnt"], "call": "acct"}, {"reason": ["path->dentry", "path->mnt"], "call": "open"}, {"reason": ["path->dentry", "path->mnt"], "call": "dup"}, {"reason": ["path->dentry", "path->mnt"], "call": "setns"}, {"reason": ["path->dentry", "path->mnt"], "call": "shmctl"}, {"reason": ["path->dentry", "path->mnt"], "call": "swapon"}, {"reason": ["path->dentry", "path->mnt"], "call": "mmap_pgoff"}, {"reason": ["path->dentry", "path->mnt"], "call": "mq_open"}], "setitimer": [{"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "waitid"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "settimeofday"}, {"reason": ["signal_struct->it_real_incr"], "call": "timer_create"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "adjtimex"}, {"reason": ["itimerval->it_value", "itimerval->it_interval", "timeval->tv_usec", "timeval->tv_sec"], "call": "getitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "select"}, {"reason": ["signal_struct->it_real_incr"], "call": "exit_group"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "wait4"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getrusage"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "clock_adjtime"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "alarm"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "ppoll"}], "alarm": [{"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "waitid"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "settimeofday"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "adjtimex"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "select"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "wait4"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getrusage"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "setitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "clock_adjtime"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "ppoll"}], "flistxattr": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "futex": [{"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "recvmmsg": [{"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["socket->file", "msghdr->msg_flags", "socket->sk"], "call": "recvfrom"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["socket->file", "msghdr->msg_flags", "socket->sk"], "call": "sendto"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["socket->file", "socket->sk"], "call": "connect"}, {"reason": ["socket->file", "socket->sk"], "call": "getsockname"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["socket->file", "socket->sk"], "call": "accept4"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["socket->file", "socket->sk"], "call": "getpeername"}, {"reason": ["socket->file", "socket->sk"], "call": "setsockopt"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["socket->file", "socket->sk"], "call": "sendmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["socket->file", "socket->sk"], "call": "shutdown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["socket->file", "socket->sk"], "call": "getsockopt"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["socket->file", "socket->sk"], "call": "listen"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["socket->file", "socket->sk"], "call": "recvmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["socket->file", "socket->sk"], "call": "sendmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["socket->file", "socket->sk"], "call": "bind"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "finit_module": [{"reason": ["module->args", "module->kp", "module_layout->base", "module_layout->size", "module->num_kp"], "call": "delete_module"}, {"reason": ["module->args", "load_info->num_debug", "module->kp", "load_info->debug", "module_layout->size", "module_layout->base", "module->num_kp"], "call": "init_module"}], "sendfile64": [{"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "mlockall": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["mm_struct->total_vm"], "call": "swapoff"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["mm_struct->total_vm"], "call": "io_getevents"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality", "mm_struct->total_vm"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality", "mm_struct->total_vm"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["mm_struct->total_vm"], "call": "io_setup"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["mm_struct->total_vm"], "call": "io_destroy"}, {"reason": ["mm_struct->total_vm"], "call": "mbind"}, {"reason": ["vm_area_struct->vm_start", "task_struct->personality", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["task_struct->personality", "mm_struct->total_vm"], "call": "move_pages"}, {"reason": ["mm_struct->total_vm"], "call": "modify_ldt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["mm_struct->total_vm"], "call": "io_cancel"}], "ppoll": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["poll_list->len", "timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fstat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "newfstat"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}], "mlock": [{"reason": ["task_struct->mm"], "call": "keyctl"}, {"reason": ["task_struct->mm"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->mm"], "call": "msgrcv"}, {"reason": ["task_struct->mm"], "call": "kill"}, {"reason": ["task_struct->mm"], "call": "sched_getaffinity"}, {"reason": ["task_struct->mm"], "call": "sched_setparam"}, {"reason": ["task_struct->mm"], "call": "ioprio_set"}, {"reason": ["task_struct->mm"], "call": "getppid"}, {"reason": ["task_struct->mm"], "call": "mq_timedreceive"}, {"reason": ["task_struct->mm"], "call": "capget"}, {"reason": ["task_struct->mm"], "call": "sched_setaffinity"}, {"reason": ["task_struct->mm"], "call": "signal"}, {"reason": ["task_struct->mm"], "call": "semtimedop"}, {"reason": ["task_struct->mm"], "call": "umount"}, {"reason": ["task_struct->mm"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->mm"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->mm"], "call": "setsid"}, {"reason": ["task_struct->mm"], "call": "sigaltstack"}, {"reason": ["task_struct->mm"], "call": "sched_setattr"}, {"reason": ["task_struct->mm"], "call": "migrate_pages"}, {"reason": ["task_struct->mm"], "call": "getitimer"}, {"reason": ["task_struct->mm"], "call": "setpgid"}, {"reason": ["task_struct->mm"], "call": "getsid"}, {"reason": ["task_struct->mm"], "call": "prlimit64"}, {"reason": ["task_struct->mm"], "call": "perf_event_open"}, {"reason": ["task_struct->mm"], "call": "rt_sigaction"}, {"reason": ["task_struct->mm"], "call": "getpgid"}, {"reason": ["task_struct->mm"], "call": "getpriority"}, {"reason": ["task_struct->mm"], "call": "sigaction"}, {"reason": ["task_struct->mm"], "call": "setns"}, {"reason": ["task_struct->mm"], "call": "fork"}, {"reason": ["task_struct->mm"], "call": "get_robust_list"}, {"reason": ["task_struct->mm"], "call": "mq_timedsend"}, {"reason": ["task_struct->mm"], "call": "sched_getscheduler"}, {"reason": ["task_struct->mm"], "call": "ptrace"}, {"reason": ["task_struct->mm"], "call": "sched_getattr"}, {"reason": ["task_struct->mm"], "call": "getrusage"}, {"reason": ["task_struct->mm"], "call": "sched_setscheduler"}, {"reason": ["task_struct->mm"], "call": "setitimer"}, {"reason": ["task_struct->mm"], "call": "ioprio_get"}, {"reason": ["task_struct->mm"], "call": "vfork"}, {"reason": ["task_struct->mm"], "call": "prctl"}, {"reason": ["task_struct->mm"], "call": "move_pages"}, {"reason": ["task_struct->mm"], "call": "setpriority"}, {"reason": ["task_struct->mm"], "call": "clone"}, {"reason": ["task_struct->mm"], "call": "sched_getparam"}]}
\ No newline at end of file
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies_verbose.pretty b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies_verbose.pretty
new file mode 100644
index 0000000000..aebd99c205
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/with_structs/implicit_dependencies_verbose.pretty
@@ -0,0 +1,18235 @@
+{'acct': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+          {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+          {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+          {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+          {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+          {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+          {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+          {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+          {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+          {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+          {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+          {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+          {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+          {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+          {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+          {'call': 'perf_event_open', 'reason': set([('file', 'f_mode')])},
+          {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+          {'call': 'open', 'reason': set([('file', 'f_mode')])},
+          {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+          {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+          {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+          {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+          {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+          {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+          {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])}],
+ 'alarm': [{'call': 'waitid',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'settimeofday',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'adjtimex',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'getitimer',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'select',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'wait4',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'getrusage',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'setitimer',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'clock_adjtime',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'ppoll',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])}],
+ 'bpf': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'rt_sigtimedwait',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'eventfd2',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'swapoff',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'sched_getaffinity',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setparam', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'memfd_create',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'remap_file_pages',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'dup3',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_timedreceive',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setaffinity',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'semtimedop', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_rr_get_interval',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'epoll_create1',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'epoll_ctl',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'flock',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'openat',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'uselib',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'rt_sigprocmask', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'accept4',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setattr', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'socketpair',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'migrate_pages', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'shmat',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'socket',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'pipe2',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'perf_event_open',
+          'reason': set([('bpf_prog', 'aux'),
+                         ('file', 'f_op'),
+                         ('file', 'private_data'),
+                         ('mm_segment_t', 'seg')])},
+         {'call': 'shmdt',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'rt_sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'acct',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'open',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'dup',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'setns',
+          'reason': set([('file', 'f_op'),
+                         ('file', 'private_data'),
+                         ('mm_segment_t', 'seg')])},
+         {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'get_robust_list',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_timedsend', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_getscheduler',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'shmctl',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'swapon',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'sched_getattr', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setscheduler',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mmap_pgoff',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_open',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])},
+         {'call': 'sched_getparam', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'open_by_handle_at',
+          'reason': set([('file', 'f_op'), ('file', 'private_data')])}],
+ 'brk': [{'call': 'swapoff',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'remap_file_pages',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'io_getevents',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'migrate_pages',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'shmdt',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'get_mempolicy',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'munlockall',
+          'reason': set([('mm_struct', 'def_flags'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'pkey_mprotect',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'madvise',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'getrusage',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'io_setup',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'mprotect',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'mremap',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'io_destroy',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'mbind',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'prctl',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'move_pages',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'modify_ldt',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'munlock',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'mincore',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'io_cancel',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'mlockall',
+          'reason': set([('mm_struct', 'def_flags'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])}],
+ 'capset': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'clock_adjtime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'clock_adj')])}],
+ 'clock_nanosleep': [{'call': 'rt_sigtimedwait',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_unlink',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'swapoff',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_getres',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'timer_delete',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'fchmod',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'memfd_create',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'readlinkat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'io_getevents',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fchown',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'utime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'settimeofday',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timer_create',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'clock_gettime',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timerfd_gettime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'pselect6',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'uselib',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fchmodat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timer_settime',
+                      'reason': set([('k_clock', 'nsleep'),
+                                     ('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'ftruncate',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timer_gettime',
+                      'reason': set([('k_clock', 'nsleep'),
+                                     ('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'ioctl',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'linkat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'stime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'futimesat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'poll',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_settime',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'select',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'unlink',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'nanosleep',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'faccessat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'swapon',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'epoll_wait',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fchownat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fstat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timerfd_settime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'sendfile',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'newfstat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'unlinkat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_adjtime',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'futex',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'recvmmsg',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'sendfile64',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'ppoll',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])}],
+ 'clock_settime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'clock_set')])}],
+ 'copy_file_range': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                     {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'read', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                     {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                     {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sync_file_range',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockname',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                     {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'old_readdir',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getpeername',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64v2',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                     {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'write', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'delete_module': [{'call': 'init_module',
+                    'reason': set([('module', 'exit'),
+                                   ('module', 'init'),
+                                   ('module', 'state')])},
+                   {'call': 'finit_module',
+                    'reason': set([('module', 'exit'),
+                                   ('module', 'init'),
+                                   ('module', 'state')])}],
+ 'dup3': [{'call': 'unshare',
+           'reason': set([('fdtable', 'max_fds'),
+                          ('files_struct', 'fdt'),
+                          ('files_struct', 'resize_in_progress')])},
+          {'call': 'select', 'reason': set([('fdtable', 'max_fds')])},
+          {'call': 'dup2',
+           'reason': set([('fdtable', 'max_fds'),
+                          ('files_struct', 'fdt'),
+                          ('files_struct', 'resize_in_progress')])}],
+ 'epoll_create1': [{'call': 'keyctl',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setfsuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getresuid16', 'reason': set([('cred', 'user')])},
+                   {'call': 'getresgid', 'reason': set([('cred', 'user')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setgid', 'reason': set([('cred', 'user')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'capset', 'reason': set([('cred', 'user')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getresgid16', 'reason': set([('cred', 'user')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'setfsgid', 'reason': set([('cred', 'user')])},
+                   {'call': 'unshare', 'reason': set([('cred', 'user')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setreuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getresuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'epoll_ctl',
+                    'reason': set([('eventpoll', 'user'),
+                                   ('eventpoll', 'ws')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setresgid', 'reason': set([('cred', 'user')])},
+                   {'call': 'setregid', 'reason': set([('cred', 'user')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getgroups16', 'reason': set([('cred', 'user')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getpriority',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'faccessat', 'reason': set([('cred', 'user')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'epoll_wait',
+                    'reason': set([('eventpoll', 'user'),
+                                   ('eventpoll', 'ws')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setresuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setuid', 'reason': set([('cred', 'user')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getgroups', 'reason': set([('cred', 'user')])},
+                   {'call': 'setpriority',
+                    'reason': set([('cred', 'user'),
+                                   ('task_struct', 'cred')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'cred')])}],
+ 'epoll_ctl': [{'call': 'syncfs',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'keyctl', 'reason': set([('list_head', 'next')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'vmsplice',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'msgrcv', 'reason': set([('list_head', 'next')])},
+               {'call': 'eventfd2',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'mq_unlink', 'reason': set([('list_head', 'next')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'kill', 'reason': set([('list_head', 'next')])},
+               {'call': 'swapoff',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'timer_delete',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'sched_setparam',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'fchmod',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'setgid', 'reason': set([('list_head', 'next')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'pivot_root', 'reason': set([('list_head', 'next')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'memfd_create',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'ioprio_set', 'reason': set([('list_head', 'next')])},
+               {'call': 'delete_module',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'dup3',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'readlinkat', 'reason': set([('list_head', 'next')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'io_getevents',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'getppid', 'reason': set([('list_head', 'next')])},
+               {'call': 'fchown',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'capget', 'reason': set([('list_head', 'next')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'ustat', 'reason': set([('list_head', 'next')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'unshare', 'reason': set([('list_head', 'next')])},
+               {'call': 'signal', 'reason': set([('list_head', 'next')])},
+               {'call': 'setreuid', 'reason': set([('list_head', 'next')])},
+               {'call': 'semtimedop', 'reason': set([('list_head', 'next')])},
+               {'call': 'umount', 'reason': set([('list_head', 'next')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'timer_create',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'mkdirat', 'reason': set([('list_head', 'next')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'epoll_create1',
+                'reason': set([('epitem', 'nwait'),
+                               ('epitem', 'ws'),
+                               ('epoll_event', 'events'),
+                               ('file', 'f_op'),
+                               ('list_head', 'next')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'tee',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'semctl', 'reason': set([('list_head', 'next')])},
+               {'call': 'sync_file_range',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'flags'),
+                               ('file', 'f_op'),
+                               ('list_head', 'next')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'openat',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'uselib',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'renameat2', 'reason': set([('list_head', 'next')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'flags'),
+                               ('file', 'f_op'),
+                               ('list_head', 'next')])},
+               {'call': 'msgctl', 'reason': set([('list_head', 'next')])},
+               {'call': 'reboot', 'reason': set([('list_head', 'next')])},
+               {'call': 'setsid', 'reason': set([('list_head', 'next')])},
+               {'call': 'set_trip_temp',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sigaltstack',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sched_setattr',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'socketpair',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'migrate_pages',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'getitimer', 'reason': set([('list_head', 'next')])},
+               {'call': 'fchmodat', 'reason': set([('list_head', 'next')])},
+               {'call': 'setpgid', 'reason': set([('list_head', 'next')])},
+               {'call': 'init_module',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'setresgid', 'reason': set([('list_head', 'next')])},
+               {'call': 'getcwd', 'reason': set([('list_head', 'next')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'get_trip_temp',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'timer_settime',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'setregid', 'reason': set([('list_head', 'next')])},
+               {'call': 'splice',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'ftruncate',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'timer_gettime',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsid', 'reason': set([('list_head', 'next')])},
+               {'call': 'shmat',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mknodat', 'reason': set([('list_head', 'next')])},
+               {'call': 'socket',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'symlinkat', 'reason': set([('list_head', 'next')])},
+               {'call': 'pipe2',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'prlimit64', 'reason': set([('list_head', 'next')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'flags'),
+                               ('file', 'f_op'),
+                               ('list_head', 'next')])},
+               {'call': 'linkat', 'reason': set([('list_head', 'next')])},
+               {'call': 'getgroups16',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'shmdt',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'quotactl', 'reason': set([('list_head', 'next')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'request_key',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'getpgid', 'reason': set([('list_head', 'next')])},
+               {'call': 'brk', 'reason': set([('list_head', 'next')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'acct',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'open',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'unlink', 'reason': set([('list_head', 'next')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'exit_group', 'reason': set([('list_head', 'next')])},
+               {'call': 'getpriority',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sigaction', 'reason': set([('list_head', 'next')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'faccessat', 'reason': set([('list_head', 'next')])},
+               {'call': 'rmdir', 'reason': set([('list_head', 'next')])},
+               {'call': 'dup',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'setgroups16',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'setns',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'fork', 'reason': set([('list_head', 'next')])},
+               {'call': 'get_mempolicy',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'io_submit', 'reason': set([('list_head', 'next')])},
+               {'call': 'get_robust_list',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'sched_yield',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'ptrace', 'reason': set([('list_head', 'next')])},
+               {'call': 'shmctl',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'munlockall', 'reason': set([('list_head', 'next')])},
+               {'call': 'swapon',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'pkey_mprotect',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'madvise', 'reason': set([('list_head', 'next')])},
+               {'call': 'epoll_wait',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'sched_getattr',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'fchownat', 'reason': set([('list_head', 'next')])},
+               {'call': 'getrusage', 'reason': set([('list_head', 'next')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'setresuid', 'reason': set([('list_head', 'next')])},
+               {'call': 'setitimer', 'reason': set([('list_head', 'next')])},
+               {'call': 'ioprio_get', 'reason': set([('list_head', 'next')])},
+               {'call': 'vfork', 'reason': set([('list_head', 'next')])},
+               {'call': 'setuid', 'reason': set([('list_head', 'next')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'io_setup', 'reason': set([('list_head', 'next')])},
+               {'call': 'mprotect', 'reason': set([('list_head', 'next')])},
+               {'call': 'mmap_pgoff',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'mremap', 'reason': set([('list_head', 'next')])},
+               {'call': 'io_destroy', 'reason': set([('list_head', 'next')])},
+               {'call': 'mbind', 'reason': set([('list_head', 'next')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'prctl', 'reason': set([('list_head', 'next')])},
+               {'call': 'move_pages', 'reason': set([('list_head', 'next')])},
+               {'call': 'timerfd_create',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'modify_ldt', 'reason': set([('list_head', 'next')])},
+               {'call': 'getgroups', 'reason': set([('list_head', 'next')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'dup2', 'reason': set([('list_head', 'next')])},
+               {'call': 'get_curr_temp',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'msgsnd', 'reason': set([('list_head', 'next')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'munlock', 'reason': set([('list_head', 'next')])},
+               {'call': 'setpriority',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'inotify_init1',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'mincore', 'reason': set([('list_head', 'next')])},
+               {'call': 'mq_notify',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'sendfile',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'timer_getoverrun',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'kexec_load', 'reason': set([('list_head', 'next')])},
+               {'call': 'clone', 'reason': set([('list_head', 'next')])},
+               {'call': 'mq_open',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'setgroups', 'reason': set([('list_head', 'next')])},
+               {'call': 'unlinkat', 'reason': set([('list_head', 'next')])},
+               {'call': 'sched_getparam',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'io_cancel', 'reason': set([('list_head', 'next')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_op'), ('list_head', 'next')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'finit_module',
+                'reason': set([('list_head', 'next')])},
+               {'call': 'sendfile64',
+                'reason': set([('fd', 'flags'), ('list_head', 'next')])},
+               {'call': 'mlockall', 'reason': set([('list_head', 'next')])}],
+ 'epoll_wait': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_op')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                {'call': 'read', 'reason': set([('fd', 'flags')])},
+                {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'semtimedop',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+                {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_ctl',
+                 'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                {'call': 'flock',
+                 'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'accept4',
+                 'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'prlimit64',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('fd', 'flags'),
+                                ('file', 'f_op'),
+                                ('mm_segment_t', 'seg')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                {'call': 'open', 'reason': set([('file', 'f_op')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                {'call': 'setns',
+                 'reason': set([('file', 'f_op'), ('mm_segment_t', 'seg')])},
+                {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                {'call': 'write', 'reason': set([('fd', 'flags')])},
+                {'call': 'setpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_op')])},
+                {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'faccessat': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'eventfd2', 'reason': set([('path', 'mnt')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'swapoff', 'reason': set([('path', 'mnt')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'pivot_root', 'reason': set([('path', 'mnt')])},
+               {'call': 'memfd_create', 'reason': set([('path', 'mnt')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'remap_file_pages', 'reason': set([('path', 'mnt')])},
+               {'call': 'dup3', 'reason': set([('path', 'mnt')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'unshare', 'reason': set([('path', 'mnt')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setreuid', 'reason': set([('cred', 'uid')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'epoll_create1', 'reason': set([('path', 'mnt')])},
+               {'call': 'epoll_ctl', 'reason': set([('path', 'mnt')])},
+               {'call': 'flock', 'reason': set([('path', 'mnt')])},
+               {'call': 'openat', 'reason': set([('path', 'mnt')])},
+               {'call': 'lookup_dcookie', 'reason': set([('path', 'mnt')])},
+               {'call': 'uselib', 'reason': set([('path', 'mnt')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'accept4', 'reason': set([('path', 'mnt')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'socketpair', 'reason': set([('path', 'mnt')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getcwd', 'reason': set([('path', 'mnt')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'shmat', 'reason': set([('path', 'mnt')])},
+               {'call': 'socket', 'reason': set([('path', 'mnt')])},
+               {'call': 'pipe2', 'reason': set([('path', 'mnt')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'mnt'), ('task_struct', 'cred')])},
+               {'call': 'shmdt', 'reason': set([('path', 'mnt')])},
+               {'call': 'quotactl', 'reason': set([('path', 'mnt')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'acct', 'reason': set([('path', 'mnt')])},
+               {'call': 'open', 'reason': set([('path', 'mnt')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'dup', 'reason': set([('path', 'mnt')])},
+               {'call': 'setns',
+                'reason': set([('path', 'mnt'), ('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'shmctl', 'reason': set([('path', 'mnt')])},
+               {'call': 'swapon', 'reason': set([('path', 'mnt')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresuid', 'reason': set([('cred', 'uid')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setuid', 'reason': set([('cred', 'uid')])},
+               {'call': 'mmap_pgoff', 'reason': set([('path', 'mnt')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_open', 'reason': set([('path', 'mnt')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'mnt')])}],
+ 'fallocate': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'flock', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fchdir': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+            {'call': 'remap_file_pages', 'reason': set([('path', 'dentry')])},
+            {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'flags'), ('path', 'dentry')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'flags'), ('path', 'dentry')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'openat', 'reason': set([('path', 'dentry')])},
+            {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+            {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'flags'), ('path', 'dentry')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'socket', 'reason': set([('path', 'dentry')])},
+            {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'flags'), ('path', 'dentry')])},
+            {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'acct', 'reason': set([('path', 'dentry')])},
+            {'call': 'open', 'reason': set([('path', 'dentry')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'dup', 'reason': set([('path', 'dentry')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'setns', 'reason': set([('path', 'dentry')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fchmod': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'eventfd2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pivot_root',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'memfd_create',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'dup3',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'unshare',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_create1',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'flags'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'flags'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'openat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'lookup_dcookie',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'uselib',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'flags'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'socketpair',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'getcwd',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'socket',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pipe2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'flags'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'shmdt',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'quotactl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'acct',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'dup',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'setns',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapon',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fchmodat': [{'call': 'eventfd2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pivot_root',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'memfd_create',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup3',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'unshare',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_create1',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'flock',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'openat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'lookup_dcookie',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'uselib',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'accept4',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socketpair',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'getcwd',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socket',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pipe2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmdt',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'quotactl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'acct',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'setns',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapon',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mmap_pgoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mq_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'fchown': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+            {'call': 'remap_file_pages', 'reason': set([('path', 'dentry')])},
+            {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'flags'), ('path', 'dentry')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'flags'), ('path', 'dentry')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'openat', 'reason': set([('path', 'dentry')])},
+            {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+            {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'flags'), ('path', 'dentry')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'socket', 'reason': set([('path', 'dentry')])},
+            {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'flags'), ('path', 'dentry')])},
+            {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'acct', 'reason': set([('path', 'dentry')])},
+            {'call': 'open', 'reason': set([('path', 'dentry')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'dup', 'reason': set([('path', 'dentry')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'setns', 'reason': set([('path', 'dentry')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fchownat': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+              {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+              {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+              {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry')])},
+              {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+              {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+              {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+              {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+              {'call': 'flock', 'reason': set([('path', 'dentry')])},
+              {'call': 'openat', 'reason': set([('path', 'dentry')])},
+              {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+              {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+              {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+              {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+              {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+              {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+              {'call': 'socket', 'reason': set([('path', 'dentry')])},
+              {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry')])},
+              {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+              {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+              {'call': 'acct', 'reason': set([('path', 'dentry')])},
+              {'call': 'open', 'reason': set([('path', 'dentry')])},
+              {'call': 'dup', 'reason': set([('path', 'dentry')])},
+              {'call': 'setns', 'reason': set([('path', 'dentry')])},
+              {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+              {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+              {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+              {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry')])}],
+ 'fcntl': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+           {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+           {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'flock',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+           {'call': 'accept4',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'write', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fcntl64': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+             {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+             {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+             {'call': 'writev', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+             {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+             {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'read', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+             {'call': 'utime', 'reason': set([('fd', 'flags')])},
+             {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+             {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+             {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+             {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'tee', 'reason': set([('fd', 'flags')])},
+             {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+             {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+             {'call': 'connect', 'reason': set([('fd', 'flags')])},
+             {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_ctl',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'flock',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+             {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+             {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+             {'call': 'splice', 'reason': set([('fd', 'flags')])},
+             {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+             {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl',
+              'reason': set([('fd', 'flags'),
+                             ('flock', 'l_len'),
+                             ('flock', 'l_start')])},
+             {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+             {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+             {'call': 'perf_event_open',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+             {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+             {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+             {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+             {'call': 'listen', 'reason': set([('fd', 'flags')])},
+             {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+             {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+             {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+             {'call': 'readv', 'reason': set([('fd', 'flags')])},
+             {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+             {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+             {'call': 'write', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'bind', 'reason': set([('fd', 'flags')])},
+             {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fgetxattr': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'flock', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'finit_module': [{'call': 'delete_module',
+                   'reason': set([('module', 'args'),
+                                  ('module', 'kp'),
+                                  ('module', 'num_kp'),
+                                  ('module_layout', 'base'),
+                                  ('module_layout', 'size')])},
+                  {'call': 'init_module',
+                   'reason': set([('load_info', 'debug'),
+                                  ('load_info', 'num_debug'),
+                                  ('module', 'args'),
+                                  ('module', 'kp'),
+                                  ('module', 'num_kp'),
+                                  ('module_layout', 'base'),
+                                  ('module_layout', 'size')])}],
+ 'flistxattr': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                {'call': 'read', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+                {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                {'call': 'write', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'flock': [{'call': 'syncfs',
+            'reason': set([('fd', 'flags'), ('super_block', 's_flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+           {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+           {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'umount', 'reason': set([('super_block', 's_flags')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+           {'call': 'accept4',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'quotactl', 'reason': set([('super_block', 's_flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'swapon',
+            'reason': set([('file', 'f_mode'), ('super_block', 's_flags')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'write', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fremovexattr': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                  {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                  {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                  {'call': 'read', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                  {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                  {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                  {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sync_file_range',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                  {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                  {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                  {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                  {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                  {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+                  {'call': 'inotify_rm_watch',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                  {'call': 'inotify_add_watch',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                  {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                  {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                  {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                  {'call': 'copy_file_range',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                  {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                  {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'write', 'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                  {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                  {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fsetxattr': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'flock', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fstat': [{'call': 'lstat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])},
+           {'call': 'stat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])},
+           {'call': 'newfstat',
+            'reason': set([('kstat', 'dev'),
+                           ('kstat', 'ino'),
+                           ('kstat', 'nlink'),
+                           ('kstat', 'rdev')])}],
+ 'fstatfs': [{'call': 'ustat',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'statfs',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'fstatfs64',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'statfs64',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])}],
+ 'fstatfs64': [{'call': 'ustat',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'fstatfs',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'statfs',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'statfs64',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])}],
+ 'ftruncate': [{'call': 'eventfd2',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'mq_unlink',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'swapoff',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'fchmod',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'memfd_create',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'dup3',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'readlinkat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'fchown',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'epoll_create1',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'flock',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'openat',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'uselib',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'accept4',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'socketpair',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'fchmodat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'shmat',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'socket',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'pipe2',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'ioctl',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'perf_event_open',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'linkat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'shmdt',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'acct',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'open',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'unlink',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('file', 'f_flags'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'faccessat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'dup',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'setns',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'shmctl',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'swapon',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags'),
+                               ('inode', 'i_sb')])},
+               {'call': 'fchownat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'mmap_pgoff',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'mq_notify',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'sendfile',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'mq_open',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'unlinkat',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'sendfile64',
+                'reason': set([('inode', 'i_flags'), ('inode', 'i_sb')])}],
+ 'futex': [{'call': 'rt_sigtimedwait',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'swapoff',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchmod',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'memfd_create',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'readlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'io_getevents',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchown',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'utime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'semtimedop',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'settimeofday',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'pselect6',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'uselib',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchmodat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ftruncate',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ioctl',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'linkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'stime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'futimesat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'poll',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'select',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'nanosleep',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'faccessat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'swapon',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'epoll_wait',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchownat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fstat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_notify',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'newfstat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'clock_nanosleep',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'unlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'recvmmsg',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile64',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ppoll',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])}],
+ 'futimesat': [{'call': 'rt_sigtimedwait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_unlink',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchmod', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'memfd_create',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'readlinkat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'io_getevents',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchown', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'waitid', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'utime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'semtimedop',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'settimeofday',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'adjtimex', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'getitimer', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timer_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ftruncate',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timer_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ioctl', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'select',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'faccessat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'wait4', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'epoll_wait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'getrusage', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'fstat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'setitimer', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'mq_notify',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'newfstat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'clock_nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'clock_adjtime',
+                'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'alarm', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile64',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ppoll',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timeval', 'tv_usec')])}],
+ 'get_mempolicy': [{'call': 'keyctl',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'kill',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'remap_file_pages',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'set_mempolicy',
+                    'reason': set([('mempolicy', 'mode'),
+                                   ('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'shmdt',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'brk',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'getpriority',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'fork',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'munlockall',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'pkey_mprotect',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'madvise',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mprotect',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'mremap',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'mbind', 'reason': set([('mempolicy', 'mode')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy'),
+                                   ('vm_area_struct', 'vm_ops')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'munlock',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'setpriority',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mincore',
+                    'reason': set([('vm_area_struct', 'vm_ops')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'il_prev'),
+                                   ('task_struct', 'mempolicy')])},
+                   {'call': 'mlockall',
+                    'reason': set([('vm_area_struct', 'vm_ops')])}],
+ 'getcwd': [{'call': 'eventfd2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_unlink',
+             'reason': set([('dentry', 'd_parent'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'swapoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pivot_root',
+             'reason': set([('dentry', 'd_parent'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'memfd_create',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'dup3',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'unshare',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'umount', 'reason': set([('vfsmount', 'mnt_root')])},
+            {'call': 'mkdirat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'epoll_create1',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'flock',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'openat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'lookup_dcookie',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'uselib',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'renameat2', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'accept4',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'socketpair',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'ftruncate', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'shmat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mknodat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'socket',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'symlinkat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'pipe2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'perf_event_open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'linkat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'shmdt',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'quotactl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'acct',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'unlink', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'rmdir', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'dup',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setns',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'shmctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'swapon',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_open',
+             'reason': set([('dentry', 'd_parent'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'unlinkat', 'reason': set([('dentry', 'd_parent')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'getdents': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+              {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+              {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'writev', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_setparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+              {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioprio_set',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'read', 'reason': set([('fd', 'flags')])},
+              {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+              {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'utime', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+              {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+              {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'semtimedop',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'tee', 'reason': set([('fd', 'flags')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'connect', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+              {'call': 'flock', 'reason': set([('fd', 'flags')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+              {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaltstack',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+              {'call': 'splice', 'reason': set([('fd', 'flags')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+              {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+              {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+              {'call': 'listen', 'reason': set([('fd', 'flags')])},
+              {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'get_robust_list',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_getattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ioprio_get',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'readv', 'reason': set([('fd', 'flags')])},
+              {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+              {'call': 'write', 'reason': set([('fd', 'flags')])},
+              {'call': 'setpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+              {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_getparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'bind', 'reason': set([('fd', 'flags')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'getdents64': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'read', 'reason': set([('fd', 'flags')])},
+                {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'semtimedop',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'prlimit64',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                {'call': 'write', 'reason': set([('fd', 'flags')])},
+                {'call': 'setpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'getegid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sigaltstack',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getpriority',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setpriority',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'cred')])}],
+ 'getegid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'geteuid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sigaltstack',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'getpriority',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'setpriority',
+              'reason': set([('task_struct', 'cred')])},
+             {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'cred')])}],
+ 'geteuid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'getgid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'getgid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'getgroups': [{'call': 'keyctl',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setfsuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresuid16',
+                'reason': set([('cred', 'group_info')])},
+               {'call': 'getresgid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setgid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'ioprio_set',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'capset', 'reason': set([('cred', 'group_info')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresgid16',
+                'reason': set([('cred', 'group_info')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'setfsgid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'unshare', 'reason': set([('cred', 'group_info')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setreuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'epoll_create1',
+                'reason': set([('cred', 'group_info')])},
+               {'call': 'getresuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresgid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'setregid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups16',
+                'reason': set([('cred', 'group_info')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'faccessat', 'reason': set([('cred', 'group_info')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setuid', 'reason': set([('cred', 'group_info')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('cred', 'group_info'),
+                               ('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'getgroups16': [{'call': 'keyctl',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setfsuid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getresuid16',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'getresgid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setgid', 'reason': set([('cred', 'group_info')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'capset', 'reason': set([('cred', 'group_info')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getresgid16',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'setfsgid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'unshare', 'reason': set([('cred', 'group_info')])},
+                 {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setreuid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'epoll_create1',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'getresuid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setresgid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'setregid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpriority',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'faccessat',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'setgroups16',
+                  'reason': set([('group_info', 'ngroups')])},
+                 {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setresuid',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setuid', 'reason': set([('cred', 'group_info')])},
+                 {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getgroups',
+                  'reason': set([('cred', 'group_info')])},
+                 {'call': 'setpriority',
+                  'reason': set([('cred', 'group_info'),
+                                 ('task_struct', 'cred')])},
+                 {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setgroups',
+                  'reason': set([('group_info', 'ngroups')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred')])}],
+ 'getitimer': [{'call': 'timer_create',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'exit_group',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'setitimer',
+                'reason': set([('signal_struct', 'it_real_incr')])}],
+ 'getppid': [{'call': 'keyctl',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'msgrcv',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'kill',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'ioprio_set',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'capget',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'signal',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'semtimedop',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'umount',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setsid',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sigaltstack',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getitimer',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setpgid',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getsid',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'prlimit64',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getpgid',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getpriority',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sigaction',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setns',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'fork',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'ptrace',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'getrusage',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setitimer',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'ioprio_get',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'vfork',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'prctl',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'move_pages',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'setpriority',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'clone',
+              'reason': set([('task_struct', 'real_parent')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'real_parent')])}],
+ 'getpriority': [{'call': 'keyctl',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'msgrcv',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'kill',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'capget',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'signal',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setreuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'umount',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setsid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getsid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setns',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'fork',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ptrace',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setresuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'vfork',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'prctl',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setpriority',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'clone',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])}],
+ 'getresgid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'getresgid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpriority',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpriority',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred')])}],
+ 'getresuid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'getresuid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getpriority',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'setpriority',
+                  'reason': set([('task_struct', 'cred')])},
+                 {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred')])}],
+ 'getrlimit': [{'call': 'setrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'old_getrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'prlimit64',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])}],
+ 'getrusage': [{'call': 'timer_create',
+                'reason': set([('signal_struct', 'maxrss')])},
+               {'call': 'exit_group',
+                'reason': set([('signal_struct', 'maxrss')])}],
+ 'getsockopt': [{'call': 'accept4',
+                 'reason': set([('proto_ops', 'compat_getsockopt')])}],
+ 'getuid': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'getuid16': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'getxattr': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+              {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+              {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+              {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry')])},
+              {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+              {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+              {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+              {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+              {'call': 'flock', 'reason': set([('path', 'dentry')])},
+              {'call': 'openat', 'reason': set([('path', 'dentry')])},
+              {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+              {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+              {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+              {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+              {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+              {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+              {'call': 'socket', 'reason': set([('path', 'dentry')])},
+              {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry')])},
+              {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+              {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+              {'call': 'acct', 'reason': set([('path', 'dentry')])},
+              {'call': 'open', 'reason': set([('path', 'dentry')])},
+              {'call': 'dup', 'reason': set([('path', 'dentry')])},
+              {'call': 'setns', 'reason': set([('path', 'dentry')])},
+              {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+              {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+              {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+              {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry')])}],
+ 'init_module': [{'call': 'delete_module',
+                  'reason': set([('module', 'args'),
+                                 ('module', 'kp'),
+                                 ('module', 'num_kp'),
+                                 ('module_layout', 'base'),
+                                 ('module_layout', 'size')])},
+                 {'call': 'finit_module',
+                  'reason': set([('load_info', 'debug'),
+                                 ('load_info', 'hdr'),
+                                 ('load_info', 'len'),
+                                 ('load_info', 'num_debug'),
+                                 ('module', 'args'),
+                                 ('module', 'kp'),
+                                 ('module', 'num_kp'),
+                                 ('module_layout', 'base'),
+                                 ('module_layout', 'size')])}],
+ 'inotify_add_watch': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                       {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                       {'call': 'eventfd2',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'mq_unlink',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'pwritev64',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fremovexattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'readahead',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                       {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                       {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                       {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                       {'call': 'pivot_root',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'signalfd4',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'memfd_create',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'remap_file_pages',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                       {'call': 'read', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                       {'call': 'mq_timedreceive',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                       {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                       {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fsetxattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                       {'call': 'mkdirat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'epoll_create1',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                       {'call': 'sync_file_range',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                       {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                       {'call': 'getsockname',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'epoll_ctl',
+                        'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                       {'call': 'flock',
+                        'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                       {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                       {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                       {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                       {'call': 'renameat2',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'accept4',
+                        'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                       {'call': 'old_readdir',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'inotify_rm_watch',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'socketpair',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'utimensat',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'getcwd',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                       {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                       {'call': 'ftruncate',
+                        'reason': set([('dentry', 'd_inode'),
+                                       ('fd', 'flags')])},
+                       {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                       {'call': 'getpeername',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                       {'call': 'setsockopt',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'mknodat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                       {'call': 'symlinkat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                       {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                       {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                       {'call': 'linkat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                       {'call': 'pwritev64v2',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'futimesat',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                       {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                       {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                       {'call': 'open', 'reason': set([('file', 'f_op')])},
+                       {'call': 'unlink',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'getsockopt',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'mq_getsetattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'rmdir',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fdatasync',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'setns', 'reason': set([('file', 'f_op')])},
+                       {'call': 'getdents64',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                       {'call': 'copy_file_range',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'mq_timedsend',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'fgetxattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                       {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                       {'call': 'fallocate',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'epoll_wait',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                       {'call': 'mmap_pgoff',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'preadv64v2',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fstatfs64',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'write', 'reason': set([('fd', 'flags')])},
+                       {'call': 'mq_notify',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                       {'call': 'mq_open',
+                        'reason': set([('dentry', 'd_inode'),
+                                       ('file', 'f_op')])},
+                       {'call': 'unlinkat',
+                        'reason': set([('dentry', 'd_inode')])},
+                       {'call': 'open_by_handle_at',
+                        'reason': set([('file', 'f_op')])},
+                       {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                       {'call': 'flistxattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'sendfile64',
+                        'reason': set([('fd', 'flags')])}],
+ 'inotify_init1': [{'call': 'keyctl',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'inotify_rm_watch',
+                    'reason': set([('fsnotify_group', 'overflow_event'),
+                                   ('inotify_group_private_data',
+                                    'ucounts')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'inotify_add_watch',
+                    'reason': set([('fsnotify_group', 'overflow_event'),
+                                   ('inotify_group_private_data',
+                                    'ucounts')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getpriority',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'setpriority',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'cred')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'cred')])}],
+ 'inotify_rm_watch': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                      {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                      {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+                      {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fremovexattr',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                      {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                      {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                      {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                      {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                      {'call': 'memfd_create',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'remap_file_pages',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                      {'call': 'read', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                      {'call': 'mq_timedreceive',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                      {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                      {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                      {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                      {'call': 'epoll_create1',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                      {'call': 'sync_file_range',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                      {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                      {'call': 'getsockname',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'epoll_ctl',
+                       'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                      {'call': 'flock',
+                       'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                      {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                      {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                      {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                      {'call': 'accept4',
+                       'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                      {'call': 'old_readdir',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'socketpair',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                      {'call': 'inotify_add_watch',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                      {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                      {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                      {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                      {'call': 'getpeername',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                      {'call': 'setsockopt',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                      {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                      {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                      {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'perf_event_open',
+                       'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+                      {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                      {'call': 'pwritev64v2',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                      {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                      {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                      {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                      {'call': 'open', 'reason': set([('file', 'f_op')])},
+                      {'call': 'getsockopt',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'mq_getsetattr',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                      {'call': 'setns', 'reason': set([('file', 'f_op')])},
+                      {'call': 'getdents64',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                      {'call': 'copy_file_range',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'mq_timedsend',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                      {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                      {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                      {'call': 'epoll_wait',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                      {'call': 'mmap_pgoff',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'preadv64v2',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'write', 'reason': set([('fd', 'flags')])},
+                      {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                      {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                      {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+                      {'call': 'open_by_handle_at',
+                       'reason': set([('file', 'f_op')])},
+                      {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                      {'call': 'flistxattr',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'sendfile64',
+                       'reason': set([('fd', 'flags')])}],
+ 'io_cancel': [{'call': 'swapoff',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'io_getevents',
+                'reason': set([('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr'),
+                               ('mm_struct', 'ioctx_table')])},
+               {'call': 'migrate_pages',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'shmdt',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'brk', 'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'get_mempolicy',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'io_submit', 'reason': set([('kioctx', 'user_id')])},
+               {'call': 'getrusage',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'io_setup',
+                'reason': set([('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr'),
+                               ('mm_struct', 'ioctx_table')])},
+               {'call': 'mremap',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'io_destroy',
+                'reason': set([('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr'),
+                               ('mm_struct', 'ioctx_table')])},
+               {'call': 'mbind',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'prctl',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'move_pages',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'modify_ldt',
+                'reason': set([('mm_struct', 'ioctx_table')])},
+               {'call': 'mincore',
+                'reason': set([('mm_struct', 'ioctx_table')])}],
+ 'io_destroy': [{'call': 'swapoff',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'io_getevents',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr'),
+                                ('mm_struct', 'ioctx_table')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'shmdt',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'brk',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'io_submit',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'io_setup',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr'),
+                                ('mm_struct', 'ioctx_table')])},
+                {'call': 'mremap',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'mbind',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'prctl',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'modify_ldt',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'mincore',
+                 'reason': set([('mm_struct', 'ioctx_table')])},
+                {'call': 'io_cancel',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr'),
+                                ('mm_struct', 'ioctx_table')])}],
+ 'io_getevents': [{'call': 'keyctl',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'rt_sigtimedwait',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'msgrcv',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'kill',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'swapoff',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'sched_getaffinity',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setparam',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'ioprio_set',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'remap_file_pages',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'getppid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'capget',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setaffinity',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'signal',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'semtimedop',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'umount',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_rr_get_interval',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'rt_sigprocmask',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setsid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sigaltstack',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setattr',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'migrate_pages',
+                   'reason': set([('mm_struct', 'ioctx_table'),
+                                  ('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getitimer',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setpgid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getsid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'prlimit64',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'shmdt',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'rt_sigaction',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getpgid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'brk',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'getpriority',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sigaction',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setns',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'fork',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'get_mempolicy',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'io_submit',
+                   'reason': set([('kioctx', 'user_id')])},
+                  {'call': 'get_robust_list',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getscheduler',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'ptrace',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getattr',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getrusage',
+                   'reason': set([('mm_struct', 'ioctx_table'),
+                                  ('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setscheduler',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setitimer',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'ioprio_get',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'vfork',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'io_setup',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr'),
+                                  ('mm_struct', 'ioctx_table')])},
+                  {'call': 'mremap',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'io_destroy',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr'),
+                                  ('mm_struct', 'ioctx_table')])},
+                  {'call': 'mbind',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'prctl',
+                   'reason': set([('mm_struct', 'ioctx_table'),
+                                  ('task_struct', 'timer_slack_ns')])},
+                  {'call': 'move_pages',
+                   'reason': set([('mm_struct', 'ioctx_table'),
+                                  ('task_struct', 'timer_slack_ns')])},
+                  {'call': 'modify_ldt',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'setpriority',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'mincore',
+                   'reason': set([('mm_struct', 'ioctx_table')])},
+                  {'call': 'clone',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getparam',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'io_cancel',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr'),
+                                  ('mm_struct', 'ioctx_table')])}],
+ 'io_setup': [{'call': 'io_getevents',
+               'reason': set([('kioctx', 'cpu'),
+                              ('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_submit',
+               'reason': set([('kioctx', 'cpu'),
+                              ('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_destroy',
+               'reason': set([('kioctx', 'cpu'),
+                              ('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_cancel',
+               'reason': set([('kioctx', 'cpu'),
+                              ('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])}],
+ 'io_submit': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setparam',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_set',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'semtimedop',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaltstack',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'migrate_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prlimit64',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'perf_event_open',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'get_robust_list',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getrusage',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_get',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'move_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getparam',
+                'reason': set([('mm_segment_t', 'seg')])}],
+ 'ioctl': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'flock', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'write', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'ioperm': [{'call': 'keyctl',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'msgrcv',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'kill',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setparam',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ioprio_set',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getppid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'capget',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'signal',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'semtimedop',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'umount',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setsid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sigaltstack',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setattr',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'migrate_pages',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getitimer',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setpgid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getsid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'prlimit64',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'perf_event_open',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getpgid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getpriority',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sigaction',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setns',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'fork',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'get_robust_list',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ptrace',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getattr',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getrusage',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setitimer',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ioprio_get',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'vfork',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'prctl',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'move_pages',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setpriority',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'clone',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getparam',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])}],
+ 'ioprio_get': [{'call': 'keyctl',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'msgrcv',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'kill',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getppid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'capget',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'signal',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'semtimedop',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'umount',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setsid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getitimer',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setpgid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getsid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'prlimit64',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getpgid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getpriority',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sigaction',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setns',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'fork',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ptrace',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getrusage',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setitimer',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'vfork',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'prctl',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'move_pages',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setpriority',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'clone',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'io_context'),
+                                ('task_struct', 'real_cred')])}],
+ 'ioprio_set': [{'call': 'keyctl',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'msgrcv',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'kill',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getppid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'capget',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'signal',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'semtimedop',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'umount',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setsid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getitimer',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setpgid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getsid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'prlimit64',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getpgid',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getpriority',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sigaction',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setns',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'fork',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ptrace',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'getrusage',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setitimer',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'vfork',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'prctl',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'move_pages',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'setpriority',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'clone',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('task_struct', 'cred'),
+                                ('task_struct', 'real_cred')])}],
+ 'keyctl': [{'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setfsuid',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'kill',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getresuid16',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'getresgid',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setgid',
+             'reason': set([('cred', 'egid'),
+                            ('cred', 'gid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'sgid')])},
+            {'call': 'ioprio_set',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'capset', 'reason': set([('cred', 'session_keyring')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getresgid16',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setfsgid',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'unshare', 'reason': set([('cred', 'session_keyring')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setreuid',
+             'reason': set([('cred', 'euid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'suid'),
+                            ('cred', 'uid')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'epoll_create1',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'getresuid',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setresgid',
+             'reason': set([('cred', 'egid'),
+                            ('cred', 'gid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'sgid')])},
+            {'call': 'setregid',
+             'reason': set([('cred', 'egid'),
+                            ('cred', 'gid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'sgid')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'prlimit64',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getgroups16',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'request_key',
+             'reason': set([('key', 'description'),
+                            ('key', 'perm'),
+                            ('key', 'quotalen'),
+                            ('key', 'serial'),
+                            ('key_type', 'name'),
+                            ('key_type', 'read')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getpriority',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'faccessat',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'fork',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'ptrace',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getrusage',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setresuid',
+             'reason': set([('cred', 'euid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'suid'),
+                            ('cred', 'uid')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'ioprio_get',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'setuid',
+             'reason': set([('cred', 'euid'),
+                            ('cred', 'session_keyring'),
+                            ('cred', 'suid'),
+                            ('cred', 'uid')])},
+            {'call': 'prctl',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'move_pages',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'getgroups',
+             'reason': set([('cred', 'session_keyring')])},
+            {'call': 'setpriority',
+             'reason': set([('cred', 'session_keyring'),
+                            ('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred'),
+                            ('task_struct', 'mm'),
+                            ('task_struct', 'pid'),
+                            ('task_struct', 'real_cred')])}],
+ 'kill': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'rt_sigtimedwait',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_getaffinity',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_setparam',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'mq_timedreceive',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_setaffinity',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_rr_get_interval',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'rt_sigprocmask',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_setattr', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'migrate_pages', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'perf_event_open',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'rt_sigaction', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'get_robust_list',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'mq_timedsend', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_getscheduler',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_getattr', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_setscheduler',
+           'reason': set([('task_struct', 'cred')])},
+          {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+          {'call': 'sched_getparam',
+           'reason': set([('task_struct', 'cred')])}],
+ 'lgetxattr': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+               {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+               {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+               {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+               {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+               {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+               {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+               {'call': 'flock', 'reason': set([('path', 'dentry')])},
+               {'call': 'openat', 'reason': set([('path', 'dentry')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+               {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+               {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+               {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+               {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+               {'call': 'socket', 'reason': set([('path', 'dentry')])},
+               {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+               {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+               {'call': 'acct', 'reason': set([('path', 'dentry')])},
+               {'call': 'open', 'reason': set([('path', 'dentry')])},
+               {'call': 'dup', 'reason': set([('path', 'dentry')])},
+               {'call': 'setns', 'reason': set([('path', 'dentry')])},
+               {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+               {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+               {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+               {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'dentry')])}],
+ 'linkat': [{'call': 'eventfd2', 'reason': set([('path', 'mnt')])},
+            {'call': 'swapoff', 'reason': set([('path', 'mnt')])},
+            {'call': 'pivot_root', 'reason': set([('path', 'mnt')])},
+            {'call': 'memfd_create', 'reason': set([('path', 'mnt')])},
+            {'call': 'remap_file_pages', 'reason': set([('path', 'mnt')])},
+            {'call': 'dup3', 'reason': set([('path', 'mnt')])},
+            {'call': 'unshare', 'reason': set([('path', 'mnt')])},
+            {'call': 'epoll_create1', 'reason': set([('path', 'mnt')])},
+            {'call': 'epoll_ctl', 'reason': set([('path', 'mnt')])},
+            {'call': 'flock', 'reason': set([('path', 'mnt')])},
+            {'call': 'openat', 'reason': set([('path', 'mnt')])},
+            {'call': 'lookup_dcookie', 'reason': set([('path', 'mnt')])},
+            {'call': 'uselib', 'reason': set([('path', 'mnt')])},
+            {'call': 'accept4', 'reason': set([('path', 'mnt')])},
+            {'call': 'socketpair', 'reason': set([('path', 'mnt')])},
+            {'call': 'getcwd', 'reason': set([('path', 'mnt')])},
+            {'call': 'shmat', 'reason': set([('path', 'mnt')])},
+            {'call': 'socket', 'reason': set([('path', 'mnt')])},
+            {'call': 'pipe2', 'reason': set([('path', 'mnt')])},
+            {'call': 'perf_event_open', 'reason': set([('path', 'mnt')])},
+            {'call': 'shmdt', 'reason': set([('path', 'mnt')])},
+            {'call': 'quotactl', 'reason': set([('path', 'mnt')])},
+            {'call': 'acct', 'reason': set([('path', 'mnt')])},
+            {'call': 'open', 'reason': set([('path', 'mnt')])},
+            {'call': 'dup', 'reason': set([('path', 'mnt')])},
+            {'call': 'setns', 'reason': set([('path', 'mnt')])},
+            {'call': 'shmctl', 'reason': set([('path', 'mnt')])},
+            {'call': 'swapon', 'reason': set([('path', 'mnt')])},
+            {'call': 'mmap_pgoff', 'reason': set([('path', 'mnt')])},
+            {'call': 'mq_open', 'reason': set([('path', 'mnt')])},
+            {'call': 'open_by_handle_at', 'reason': set([('path', 'mnt')])}],
+ 'listxattr': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+               {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+               {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+               {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+               {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+               {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+               {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+               {'call': 'flock', 'reason': set([('path', 'dentry')])},
+               {'call': 'openat', 'reason': set([('path', 'dentry')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+               {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+               {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+               {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+               {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+               {'call': 'socket', 'reason': set([('path', 'dentry')])},
+               {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'dentry')])},
+               {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+               {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+               {'call': 'acct', 'reason': set([('path', 'dentry')])},
+               {'call': 'open', 'reason': set([('path', 'dentry')])},
+               {'call': 'dup', 'reason': set([('path', 'dentry')])},
+               {'call': 'setns', 'reason': set([('path', 'dentry')])},
+               {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+               {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+               {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+               {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'dentry')])}],
+ 'llistxattr': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+                {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+                {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+                {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+                {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+                {'call': 'flock', 'reason': set([('path', 'dentry')])},
+                {'call': 'openat', 'reason': set([('path', 'dentry')])},
+                {'call': 'lookup_dcookie',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+                {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+                {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+                {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+                {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+                {'call': 'socket', 'reason': set([('path', 'dentry')])},
+                {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+                {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+                {'call': 'acct', 'reason': set([('path', 'dentry')])},
+                {'call': 'open', 'reason': set([('path', 'dentry')])},
+                {'call': 'dup', 'reason': set([('path', 'dentry')])},
+                {'call': 'setns', 'reason': set([('path', 'dentry')])},
+                {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+                {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+                {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+                {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('path', 'dentry')])}],
+ 'llseek': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'flock', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'lremovexattr': [{'call': 'eventfd2',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'swapoff',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'pivot_root',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'memfd_create',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'remap_file_pages',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'dup3',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'unshare',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'epoll_create1',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'epoll_ctl',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'flock',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'openat',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'lookup_dcookie',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'uselib',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'accept4',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'socketpair',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'getcwd',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'shmat',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'socket',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'pipe2',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'shmdt',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'quotactl',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'acct',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'open',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'dup',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'setns',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'shmctl',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'swapon',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'mmap_pgoff',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'mq_open',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                  {'call': 'open_by_handle_at',
+                   'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'lseek': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'flock', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'write', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'lsetxattr': [{'call': 'eventfd2',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'swapoff',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'pivot_root',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'memfd_create',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'dup3',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'unshare',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'epoll_create1',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'flock',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'openat',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'uselib',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'accept4',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'socketpair',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'getcwd',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'shmat',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'socket',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'pipe2',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'shmdt',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'quotactl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'acct',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'open',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'dup',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'setns',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'shmctl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'swapon',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mmap_pgoff',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mq_open',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'lstat': [{'call': 'stat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])},
+           {'call': 'fstat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink'),
+                           ('kstat', 'dev'),
+                           ('kstat', 'ino'),
+                           ('kstat', 'nlink'),
+                           ('kstat', 'rdev')])},
+           {'call': 'newfstat',
+            'reason': set([('kstat', 'dev'),
+                           ('kstat', 'ino'),
+                           ('kstat', 'nlink'),
+                           ('kstat', 'rdev')])}],
+ 'madvise': [{'call': 'remap_file_pages',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'shmdt',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'brk',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'get_mempolicy',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'munlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'pkey_mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mremap',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'prctl',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'munlock',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mincore',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])}],
+ 'migrate_pages': [{'call': 'keyctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'kill',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getppid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'ioperm',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'capget',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'signal',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setreuid',
+                    'reason': set([('cred', 'euid'),
+                                   ('cred', 'suid'),
+                                   ('cred', 'uid')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'umount',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setns',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'fork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'ptrace',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'getrusage',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setresuid',
+                    'reason': set([('cred', 'euid'),
+                                   ('cred', 'suid'),
+                                   ('cred', 'uid')])},
+                   {'call': 'setitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'vfork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setuid',
+                    'reason': set([('cred', 'euid'),
+                                   ('cred', 'suid'),
+                                   ('cred', 'uid')])},
+                   {'call': 'prctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'move_pages',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'setpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'clone',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'cred'),
+                                   ('task_struct', 'real_cred')])}],
+ 'mincore': [{'call': 'keyctl',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'msgrcv',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'kill',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_setparam',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'ioprio_set',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'getppid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'capget',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'signal',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'semtimedop',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'umount',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'setsid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sigaltstack',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_setattr',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'migrate_pages',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'getitimer',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'setpgid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'getsid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'prlimit64',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'perf_event_open',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'shmdt',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'getpgid',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'brk', 'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'getpriority',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sigaction',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'setns',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'fork',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'get_mempolicy',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'get_robust_list',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'ptrace',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'munlockall',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'pkey_mprotect',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'madvise',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'sched_getattr',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'getrusage',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'setitimer',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'ioprio_get',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'vfork',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'mprotect',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'mremap',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'prctl',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'move_pages',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'munlock',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'setpriority',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'clone',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'sched_getparam',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('task_struct', 'mm')])},
+             {'call': 'mlockall',
+              'reason': set([('vm_area_struct', 'vm_start')])}],
+ 'mkdirat': [{'call': 'syncfs', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'umount', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'quotactl',
+              'reason': set([('super_block', 's_flags')])},
+             {'call': 'swapon', 'reason': set([('super_block', 's_flags')])}],
+ 'mknodat': [{'call': 'syncfs', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'umount', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'quotactl',
+              'reason': set([('super_block', 's_flags')])},
+             {'call': 'swapon', 'reason': set([('super_block', 's_flags')])}],
+ 'mlock': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setparam', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'rt_sigprocmask', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setattr', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'migrate_pages', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getattr', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getparam', 'reason': set([('task_struct', 'mm')])}],
+ 'mlock2': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_setattr', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'migrate_pages', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_getattr', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'mm')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'mm')])}],
+ 'mlockall': [{'call': 'keyctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'swapoff', 'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'io_getevents',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'getppid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'shmdt',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'brk',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'get_mempolicy',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'munlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'pkey_mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'madvise',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'io_setup',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'mremap',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'io_destroy',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'mbind', 'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'prctl',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'modify_ldt',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'munlock',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mincore',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'clone',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'io_cancel',
+               'reason': set([('mm_struct', 'total_vm')])}],
+ 'mmap_pgoff': [{'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_op')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+                {'call': 'epoll_ctl', 'reason': set([('file', 'f_op')])},
+                {'call': 'flock', 'reason': set([('file', 'f_op')])},
+                {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                {'call': 'accept4', 'reason': set([('file', 'f_op')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('file', 'f_op')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                {'call': 'open', 'reason': set([('file', 'f_op')])},
+                {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                {'call': 'setns', 'reason': set([('file', 'f_op')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_op')])}],
+ 'modify_ldt': [{'call': 'swapoff', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'io_getevents',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'get_thread_area',
+                 'reason': set([('user_desc', 'base_addr'),
+                                ('user_desc', 'contents'),
+                                ('user_desc', 'entry_number'),
+                                ('user_desc', 'limit'),
+                                ('user_desc', 'limit_in_pages'),
+                                ('user_desc', 'read_exec_only'),
+                                ('user_desc', 'seg_32bit'),
+                                ('user_desc', 'seg_not_present'),
+                                ('user_desc', 'useable')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'shmdt', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'brk', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'io_setup',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'mremap', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'io_destroy',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'mbind', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'prctl', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'mincore', 'reason': set([('mm_context_t', 'ldt')])},
+                {'call': 'set_thread_area',
+                 'reason': set([('user_desc', 'base_addr'),
+                                ('user_desc', 'contents'),
+                                ('user_desc', 'entry_number'),
+                                ('user_desc', 'limit'),
+                                ('user_desc', 'limit_in_pages'),
+                                ('user_desc', 'read_exec_only'),
+                                ('user_desc', 'seg_32bit'),
+                                ('user_desc', 'seg_not_present'),
+                                ('user_desc', 'useable')])},
+                {'call': 'io_cancel',
+                 'reason': set([('mm_context_t', 'ldt')])}],
+ 'mount': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getrusage',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'move_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'personality')])}],
+ 'mprotect': [{'call': 'keyctl',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'getppid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'shmdt',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'brk',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'get_mempolicy',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'munlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'pkey_mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'madvise',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mremap',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'prctl',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'munlock',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mincore',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'clone',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'mm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])}],
+ 'mq_getsetattr': [{'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+                   {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+                   {'call': 'memfd_create',
+                    'reason': set([('file', 'f_op')])},
+                   {'call': 'remap_file_pages',
+                    'reason': set([('file', 'f_op')])},
+                   {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mq_attr', 'mq_flags')])},
+                   {'call': 'epoll_create1',
+                    'reason': set([('file', 'f_op')])},
+                   {'call': 'epoll_ctl', 'reason': set([('file', 'f_op')])},
+                   {'call': 'flock', 'reason': set([('file', 'f_op')])},
+                   {'call': 'openat', 'reason': set([('file', 'f_op')])},
+                   {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+                   {'call': 'accept4', 'reason': set([('file', 'f_op')])},
+                   {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+                   {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+                   {'call': 'socket', 'reason': set([('file', 'f_op')])},
+                   {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('file', 'f_op')])},
+                   {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+                   {'call': 'acct', 'reason': set([('file', 'f_op')])},
+                   {'call': 'open', 'reason': set([('file', 'f_op')])},
+                   {'call': 'dup', 'reason': set([('file', 'f_op')])},
+                   {'call': 'setns', 'reason': set([('file', 'f_op')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mq_attr', 'mq_flags')])},
+                   {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+                   {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+                   {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+                   {'call': 'mq_notify',
+                    'reason': set([('mq_attr', 'mq_flags')])},
+                   {'call': 'mq_open',
+                    'reason': set([('file', 'f_op'),
+                                   ('mq_attr', 'mq_flags')])},
+                   {'call': 'open_by_handle_at',
+                    'reason': set([('file', 'f_op')])}],
+ 'mq_notify': [{'call': 'rt_sigtimedwait',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+               {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+               {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_op')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('mqueue_inode_info', 'notify_owner'),
+                               ('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'timer_create',
+                'reason': set([('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+               {'call': 'rt_sigqueueinfo',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'epoll_ctl', 'reason': set([('file', 'f_op')])},
+               {'call': 'flock', 'reason': set([('file', 'f_op')])},
+               {'call': 'tgkill', 'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'openat', 'reason': set([('file', 'f_op')])},
+               {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+               {'call': 'accept4', 'reason': set([('file', 'f_op')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+               {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+               {'call': 'socket', 'reason': set([('file', 'f_op')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+               {'call': 'perf_event_open', 'reason': set([('file', 'f_op')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+               {'call': 'acct', 'reason': set([('file', 'f_op')])},
+               {'call': 'open', 'reason': set([('file', 'f_op')])},
+               {'call': 'rt_tgsigqueueinfo',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('mqueue_inode_info', 'notify_owner'),
+                               ('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'dup', 'reason': set([('file', 'f_op')])},
+               {'call': 'setns', 'reason': set([('file', 'f_op')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('mqueue_inode_info', 'notify_owner'),
+                               ('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+               {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+               {'call': 'rt_sigreturn',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'tkill', 'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_op')])}],
+ 'mq_open': [{'call': 'sysfs', 'reason': set([('filename', 'name')])},
+             {'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+             {'call': 'mq_unlink', 'reason': set([('filename', 'name')])},
+             {'call': 'swapoff',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+             {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('path', 'dentry')])},
+             {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+             {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+             {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+             {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+             {'call': 'flock', 'reason': set([('path', 'dentry')])},
+             {'call': 'openat',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+             {'call': 'uselib',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'renameat2', 'reason': set([('filename', 'name')])},
+             {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+             {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+             {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+             {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+             {'call': 'socket', 'reason': set([('path', 'dentry')])},
+             {'call': 'symlinkat', 'reason': set([('filename', 'name')])},
+             {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+             {'call': 'perf_event_open', 'reason': set([('path', 'dentry')])},
+             {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+             {'call': 'quotactl',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'acct',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'open',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'unlink', 'reason': set([('filename', 'name')])},
+             {'call': 'rmdir', 'reason': set([('filename', 'name')])},
+             {'call': 'dup', 'reason': set([('path', 'dentry')])},
+             {'call': 'setns', 'reason': set([('path', 'dentry')])},
+             {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+             {'call': 'swapon',
+              'reason': set([('filename', 'name'), ('path', 'dentry')])},
+             {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+             {'call': 'unlinkat', 'reason': set([('filename', 'name')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('path', 'dentry')])}],
+ 'mq_timedreceive': [{'call': 'msgrcv', 'reason': set([('msg_msg', 'm_ts')])},
+                     {'call': 'eventfd2',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'swapoff',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'memfd_create',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'remap_file_pages',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'dup3',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'epoll_create1',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'epoll_ctl',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'flock',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'openat',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'uselib',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'accept4',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'socketpair',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'shmat',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'socket',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'pipe2',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'shmdt',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'acct',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'open',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('file', 'f_flags'),
+                                     ('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize'),
+                                     ('mqueue_inode_info', 'node_cache')])},
+                     {'call': 'dup',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'setns',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize'),
+                                     ('mqueue_inode_info', 'node_cache'),
+                                     ('msg_msg', 'm_ts')])},
+                     {'call': 'shmctl',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'swapon',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'mmap_pgoff',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])},
+                     {'call': 'msgsnd', 'reason': set([('msg_msg', 'm_ts')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize'),
+                                     ('mqueue_inode_info', 'node_cache')])},
+                     {'call': 'mq_open',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op'),
+                                     ('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize')])},
+                     {'call': 'open_by_handle_at',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('file', 'f_op')])}],
+ 'mq_timedsend': [{'call': 'eventfd2',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'swapoff',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'memfd_create',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'remap_file_pages',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'dup3',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize'),
+                                  ('mqueue_inode_info', 'node_cache')])},
+                  {'call': 'epoll_create1',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'epoll_ctl',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'flock',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'openat',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'uselib',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'accept4',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'socketpair',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'shmat',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'socket',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'pipe2',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'shmdt',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'acct',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'open',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'mq_getsetattr',
+                   'reason': set([('file', 'f_flags'),
+                                  ('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize'),
+                                  ('mqueue_inode_info', 'node_cache')])},
+                  {'call': 'dup',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'setns',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'shmctl',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'swapon',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'mmap_pgoff',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])},
+                  {'call': 'mq_notify',
+                   'reason': set([('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize'),
+                                  ('mqueue_inode_info', 'node_cache')])},
+                  {'call': 'mq_open',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op'),
+                                  ('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize')])},
+                  {'call': 'open_by_handle_at',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('file', 'f_op')])}],
+ 'mremap': [{'call': 'keyctl',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'swapoff', 'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioprio_set',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'personality',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'io_getevents',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'prlimit64',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'shmdt',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'brk',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'get_mempolicy',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ptrace',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'munlockall',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'pkey_mprotect',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'madvise',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getrusage',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioprio_get',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'io_setup', 'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'mprotect',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'io_destroy',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'mbind', 'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'prctl',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'move_pages',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality')])},
+            {'call': 'modify_ldt',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'munlock',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mincore',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'io_cancel',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'mlockall',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_file'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_next'),
+                            ('vm_area_struct', 'vm_ops'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])}],
+ 'msgctl': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgrcv',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'mq_unlink',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgget',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setparam',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semtimedop',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'shmget',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semget',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'shmat',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'perf_event_open',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setns',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'get_robust_list',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'shmctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'sched_getattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgsnd',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_open',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'sched_getparam',
+             'reason': set([('mm_segment_t', 'seg')])}],
+ 'msgrcv': [{'call': 'mq_timedreceive', 'reason': set([('msg_msg', 'm_ts')])},
+            {'call': 'mq_timedsend', 'reason': set([('msg_msg', 'm_ts')])},
+            {'call': 'msgsnd', 'reason': set([('msg_msg', 'm_ts')])}],
+ 'msgsnd': [{'call': 'msgrcv',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'mq_unlink',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'msgget',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'semtimedop',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'semctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'shmget',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'msgctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'semget',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'shmat',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'setns',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'shmctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'mq_open',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])}],
+ 'msync': [{'call': 'remap_file_pages',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'shmdt',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'brk',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'get_mempolicy',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'munlockall',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'pkey_mprotect',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'madvise',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'mprotect',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'mremap',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'prctl',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'munlock',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'mincore',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])},
+           {'call': 'mlockall',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_flags')])}],
+ 'munlock': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'shmdt',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'brk',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'setns', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'get_mempolicy',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'munlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'pkey_mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'madvise',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mremap',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'prctl',
+              'reason': set([('task_struct', 'mm'),
+                             ('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mincore',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'mlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])}],
+ 'munlockall': [{'call': 'remap_file_pages',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'shmdt',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'brk',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'pkey_mprotect',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'madvise',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mprotect',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mremap',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'prctl',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'munlock',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mincore',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mlockall',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])}],
+ 'name_to_handle_at': [{'call': 'syncfs',
+                        'reason': set([('super_block', 's_export_op')])},
+                       {'call': 'eventfd2',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'swapoff',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'pivot_root',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'memfd_create',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'remap_file_pages',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'dup3',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'ustat',
+                        'reason': set([('super_block', 's_export_op')])},
+                       {'call': 'unshare',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'umount',
+                        'reason': set([('super_block', 's_export_op')])},
+                       {'call': 'epoll_create1',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'epoll_ctl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'flock',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'openat',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'lookup_dcookie',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'uselib',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'accept4',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'socketpair',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'getcwd',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmat',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'socket',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'pipe2',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmdt',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'quotactl',
+                        'reason': set([('path', 'dentry'),
+                                       ('path', 'mnt'),
+                                       ('super_block', 's_export_op')])},
+                       {'call': 'acct',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'dup',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'setns',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmctl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'swapon',
+                        'reason': set([('path', 'dentry'),
+                                       ('path', 'mnt'),
+                                       ('super_block', 's_export_op')])},
+                       {'call': 'mmap_pgoff',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'mq_open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'open_by_handle_at',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'nanosleep': [{'call': 'rt_sigtimedwait',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_unlink',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'swapoff',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchmod',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'memfd_create',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'readlinkat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'io_getevents',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchown',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'utime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'semtimedop',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'settimeofday',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'pselect6',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'uselib',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchmodat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timer_settime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'ftruncate',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timer_gettime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'ioctl',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'linkat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'stime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'futimesat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'poll',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'select',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'unlink',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'faccessat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'swapon',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'epoll_wait',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchownat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fstat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_notify',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'sendfile',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'newfstat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'clock_nanosleep',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'unlinkat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'futex',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'recvmmsg',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'sendfile64',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'ppoll',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])}],
+ 'newfstat': [{'call': 'newlstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newfstatat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'fstat',
+               'reason': set([('kstat', 'dev'),
+                              ('kstat', 'ino'),
+                              ('kstat', 'nlink'),
+                              ('kstat', 'rdev'),
+                              ('kstat', 'size')])}],
+ 'newfstatat': [{'call': 'newlstat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])},
+                {'call': 'newstat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])},
+                {'call': 'fstat',
+                 'reason': set([('kstat', 'dev'),
+                                ('kstat', 'ino'),
+                                ('kstat', 'nlink'),
+                                ('kstat', 'rdev'),
+                                ('kstat', 'size')])},
+                {'call': 'newfstat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('kstat', 'dev'),
+                                ('kstat', 'ino'),
+                                ('kstat', 'nlink'),
+                                ('kstat', 'rdev'),
+                                ('kstat', 'size'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])}],
+ 'newlstat': [{'call': 'newfstatat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'fstat',
+               'reason': set([('kstat', 'dev'),
+                              ('kstat', 'ino'),
+                              ('kstat', 'nlink'),
+                              ('kstat', 'rdev'),
+                              ('kstat', 'size')])},
+              {'call': 'newfstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('kstat', 'dev'),
+                              ('kstat', 'ino'),
+                              ('kstat', 'nlink'),
+                              ('kstat', 'rdev'),
+                              ('kstat', 'size'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])}],
+ 'newstat': [{'call': 'newlstat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])},
+             {'call': 'newfstatat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])},
+             {'call': 'fstat',
+              'reason': set([('kstat', 'dev'),
+                             ('kstat', 'ino'),
+                             ('kstat', 'nlink'),
+                             ('kstat', 'rdev'),
+                             ('kstat', 'size')])},
+             {'call': 'newfstat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('kstat', 'dev'),
+                             ('kstat', 'ino'),
+                             ('kstat', 'nlink'),
+                             ('kstat', 'rdev'),
+                             ('kstat', 'size'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])}],
+ 'newuname': [{'call': 'keyctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getppid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'clone',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'personality')])}],
+ 'old_getrlimit': [{'call': 'setrlimit',
+                    'reason': set([('rlimit', 'rlim_cur'),
+                                   ('rlimit', 'rlim_max')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('rlimit', 'rlim_cur'),
+                                   ('rlimit', 'rlim_max')])}],
+ 'old_readdir': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                 {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                 {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                 {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                 {'call': 'read', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                 {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                 {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                 {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                 {'call': 'sync_file_range',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                 {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                 {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                 {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                 {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                 {'call': 'inotify_rm_watch',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                 {'call': 'inotify_add_watch',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                 {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                 {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                 {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                 {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                 {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                 {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                 {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                 {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                 {'call': 'copy_file_range',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                 {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                 {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                 {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                 {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'write', 'reason': set([('fd', 'flags')])},
+                 {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                 {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                 {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                 {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'olduname': [{'call': 'keyctl',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getppid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getpriority',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'get_robust_list',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getattr',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'prctl',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setpriority',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'clone',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])}],
+ 'open_by_handle_at': [{'call': 'eventfd2',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'swapoff',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'pivot_root',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'memfd_create',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'remap_file_pages',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'dup3',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'unshare',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'epoll_create1',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'epoll_ctl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'flock',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'openat',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'lookup_dcookie',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'uselib',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'accept4',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'socketpair',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'getcwd',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmat',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'socket',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'pipe2',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmdt',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'quotactl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'acct',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'dup',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'setns',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'shmctl',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'swapon',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'mmap_pgoff',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                       {'call': 'mq_open',
+                        'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'perf_event_open': [{'call': 'syncfs',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'keyctl',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'rt_sigtimedwait',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'vmsplice',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'msgrcv',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'eventfd2',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'mq_unlink',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'kill',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'swapoff',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'readahead',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                     {'call': 'timer_delete',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_getaffinity',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sched_setparam',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchmod',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'setgid',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pivot_root',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'memfd_create',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'ioprio_set',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'delete_module',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'remap_file_pages',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'dup3',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'readlinkat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'read', 'reason': set([('fd', 'flags')])},
+                     {'call': 'io_getevents',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getppid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchown',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'ioperm',
+                      'reason': set([('mm_segment_t', 'seg')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'capget',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sched_setaffinity',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'ustat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bpf',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'unshare',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'signal',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setreuid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'umount',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'timer_create',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mkdirat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'epoll_create1',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'timerfd_gettime',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'tee',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'semctl',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sync_file_range',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockname',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_ctl',
+                      'reason': set([('fd', 'flags'),
+                                     ('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'flock',
+                      'reason': set([('fd', 'flags'),
+                                     ('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                     {'call': 'openat',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'lookup_dcookie',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'uselib',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'renameat2',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'rt_sigprocmask',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'accept4',
+                      'reason': set([('fd', 'flags'),
+                                     ('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'msgctl',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'reboot',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setsid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'set_trip_temp',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sigaltstack',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sched_setattr',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'old_readdir',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'socketpair',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'migrate_pages',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'getitimer',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchmodat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setpgid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'init_module',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setresgid',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getcwd',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'get_trip_temp',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'timer_settime',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setregid',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'splice',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'ftruncate',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'timer_gettime',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getpeername',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'getsid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'shmat',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mknodat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'socket',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'symlinkat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'pipe2',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ioctl',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'prlimit64',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'linkat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getgroups16',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'shmdt',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'pwritev64v2',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'quotactl',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'rt_sigaction',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'request_key',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getpgid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'brk', 'reason': set([('list_head', 'prev')])},
+                     {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'acct',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'open',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'unlink',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'exit_group',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getpriority',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sigaction',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'faccessat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'rmdir',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'dup',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'setgroups16',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setns',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fork',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'get_mempolicy',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'io_submit',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'get_robust_list',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'copy_file_range',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sched_yield',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_getscheduler',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ptrace',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'shmctl',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'munlockall',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'swapon',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pkey_mprotect',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'madvise',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'epoll_wait',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'sched_getattr',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchownat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getrusage',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'timerfd_settime',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_setscheduler',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setresuid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setitimer',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'ioprio_get',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'vfork',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setuid',
+                      'reason': set([('list_head', 'prev'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'io_setup',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mprotect',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mmap_pgoff',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'mremap',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'io_destroy',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mbind',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'prctl',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'move_pages',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'timerfd_create',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'modify_ldt',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'getgroups',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'dup2', 'reason': set([('list_head', 'prev')])},
+                     {'call': 'get_curr_temp',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'msgsnd',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'write', 'reason': set([('fd', 'flags')])},
+                     {'call': 'munlock',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'setpriority',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'inotify_init1',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mincore',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'sendfile',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'timer_getoverrun',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'kexec_load',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'clone',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'mq_open',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'setgroups',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'unlinkat',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sched_getparam',
+                      'reason': set([('list_head', 'prev'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'io_cancel',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'open_by_handle_at',
+                      'reason': set([('file', 'f_op'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'finit_module',
+                      'reason': set([('list_head', 'prev')])},
+                     {'call': 'sendfile64',
+                      'reason': set([('fd', 'flags'),
+                                     ('list_head', 'prev')])},
+                     {'call': 'mlockall',
+                      'reason': set([('list_head', 'prev')])}],
+ 'pivot_root': [{'call': 'eventfd2',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'mq_unlink',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'swapoff',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'memfd_create',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'dup3',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'unshare',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'umount',
+                 'reason': set([('mount', 'mnt_ns'),
+                                ('mount', 'mnt_parent'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'mkdirat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'epoll_ctl',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'flock',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'openat',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'lookup_dcookie',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'uselib',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'renameat2',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'accept4',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'socketpair',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'getcwd',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent'),
+                                ('mount', 'mnt_ns'),
+                                ('mount', 'mnt_parent'),
+                                ('path', 'dentry'),
+                                ('path', 'mnt'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'ftruncate',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'shmat',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'mknodat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'socket',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'symlinkat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'pipe2',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'linkat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'shmdt',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'quotactl',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'acct',
+                 'reason': set([('path', 'dentry'),
+                                ('path', 'mnt'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'open',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'unlink',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'rmdir',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'dup',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'setns',
+                 'reason': set([('nsproxy', 'mnt_ns'),
+                                ('path', 'dentry'),
+                                ('path', 'mnt')])},
+                {'call': 'shmctl',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'swapon',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'mmap_pgoff',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                {'call': 'mq_open',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent'),
+                                ('path', 'dentry'),
+                                ('path', 'mnt'),
+                                ('vfsmount', 'mnt_flags'),
+                                ('vfsmount', 'mnt_root')])},
+                {'call': 'unlinkat',
+                 'reason': set([('dentry', 'd_inode'),
+                                ('dentry', 'd_parent')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'pkey_alloc': [{'call': 'swapoff',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_getevents',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'pkey_free',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'shmdt',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'brk',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_setup',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'mremap',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_destroy',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'mbind',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'prctl',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'modify_ldt',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'mincore',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_cancel',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])}],
+ 'pkey_mprotect': [{'call': 'keyctl',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'kill',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'personality',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'remap_file_pages',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'shmdt',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'brk',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'getpriority',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'fork',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'get_mempolicy',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'munlockall',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'madvise',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mprotect',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'mremap',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality'),
+                                   ('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'munlock',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'setpriority',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mincore',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'mm'),
+                                   ('task_struct', 'personality')])},
+                   {'call': 'mlockall',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])}],
+ 'poll': [{'call': 'ppoll', 'reason': set([('poll_list', 'len')])}],
+ 'ppoll': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'swapoff',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchmod',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'memfd_create',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'readlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'io_getevents',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchown',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'utime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'settimeofday',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'pselect6',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'uselib',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchmodat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ftruncate',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioctl',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'linkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'stime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'futimesat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'poll',
+            'reason': set([('poll_list', 'len'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'select',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'nanosleep',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'faccessat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'swapon',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'epoll_wait',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchownat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getrusage',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fstat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'move_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_notify',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'newfstat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'clock_nanosleep',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'unlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'futex',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'recvmmsg',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile64',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])}],
+ 'prctl': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'kill',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'swapoff', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'remap_file_pages',
+            'reason': set([('mm_struct', 'flags')])},
+           {'call': 'io_getevents', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'migrate_pages',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'shmdt', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'brk', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setns',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'fork',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'get_mempolicy', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getrusage',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'vfork',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+           {'call': 'io_setup', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'mremap', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'io_destroy', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'mbind', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'move_pages',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'modify_ldt', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'mincore', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'clone',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'io_cancel', 'reason': set([('mm_struct', 'flags')])}],
+ 'pread64': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+             {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+             {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+             {'call': 'writev', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+             {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'read', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+             {'call': 'utime', 'reason': set([('fd', 'flags')])},
+             {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+             {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+             {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+             {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'tee', 'reason': set([('fd', 'flags')])},
+             {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+             {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+             {'call': 'connect', 'reason': set([('fd', 'flags')])},
+             {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_ctl',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'flock',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+             {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+             {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+             {'call': 'splice', 'reason': set([('fd', 'flags')])},
+             {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+             {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+             {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+             {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+             {'call': 'perf_event_open',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+             {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+             {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+             {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+             {'call': 'listen', 'reason': set([('fd', 'flags')])},
+             {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+             {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+             {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+             {'call': 'readv', 'reason': set([('fd', 'flags')])},
+             {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+             {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+             {'call': 'write', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'bind', 'reason': set([('fd', 'flags')])},
+             {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'preadv': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+            {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+            {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+            {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+            {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+            {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+            {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+            {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+            {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+            {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+            {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+            {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+            {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+            {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+            {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+            {'call': 'perf_event_open', 'reason': set([('file', 'f_mode')])},
+            {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+            {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+            {'call': 'open', 'reason': set([('file', 'f_mode')])},
+            {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+            {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+            {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+            {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+            {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+            {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('file', 'f_mode')])}],
+ 'preadv2': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'perf_event_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])}],
+ 'preadv64': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'perf_event_open',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])}],
+ 'preadv64v2': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+                {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+                {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+                {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+                {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+                {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_mode')])}],
+ 'prlimit64': [{'call': 'keyctl',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'msgrcv',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'kill',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setgid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'ioprio_set',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'getppid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'capget',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'signal',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setreuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'umount',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'epoll_create1',
+                'reason': set([('cred', 'user_ns')])},
+               {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setsid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'migrate_pages',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setpgid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setresgid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'setregid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'getsid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'old_getrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getpgid',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getpriority',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'faccessat', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setns',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'fork',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ptrace',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setresuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ioprio_get',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'vfork',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'prctl',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setpriority',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'clone',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'real_cred'),
+                               ('task_struct', 'sighand')])}],
+ 'pselect6': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'swapoff',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchmod',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'memfd_create',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ioprio_set',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'readlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'io_getevents',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchown',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'utime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'semtimedop',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'settimeofday',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'uselib',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaltstack',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchmodat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'inotify_add_watch',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ftruncate',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ioctl',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'perf_event_open',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'linkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'stime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'futimesat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'poll',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'select',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'nanosleep',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'faccessat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'get_robust_list',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'swapon',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'epoll_wait',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchownat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fstat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ioprio_get',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_notify',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'newfstat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'clock_nanosleep',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'futex',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'recvmmsg',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile64',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ppoll',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])}],
+ 'ptrace': [{'call': 'keyctl',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'kill',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'pause', 'reason': set([('task_struct', 'state')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'ioprio_set',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigsuspend',
+             'reason': set([('task_struct', 'state')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'prlimit64',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'fork',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'epoll_wait', 'reason': set([('task_struct', 'state')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'getrusage',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'ioprio_get',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'prctl',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'move_pages',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])},
+            {'call': 'sigsuspend', 'reason': set([('task_struct', 'state')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'parent'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'real_parent'),
+                            ('task_struct', 'state')])}],
+ 'pwrite64': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+              {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+              {'call': 'writev', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+              {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'read', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+              {'call': 'utime', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+              {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'tee', 'reason': set([('fd', 'flags')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'connect', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+              {'call': 'splice', 'reason': set([('fd', 'flags')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+              {'call': 'listen', 'reason': set([('fd', 'flags')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+              {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'readv', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+              {'call': 'write', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'bind', 'reason': set([('fd', 'flags')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'pwritev': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'perf_event_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])}],
+ 'pwritev2': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'perf_event_open',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])}],
+ 'pwritev64': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+               {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+               {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+               {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+               {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+               {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'perf_event_open',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+               {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+               {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+               {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_mode')])}],
+ 'pwritev64v2': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'memfd_create',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'remap_file_pages',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'epoll_create1',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'open', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'open_by_handle_at',
+                  'reason': set([('file', 'f_mode')])}],
+ 'quotactl': [{'call': 'syncfs',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_qcop'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'sysfs', 'reason': set([('filename', 'name')])},
+              {'call': 'mq_unlink', 'reason': set([('filename', 'name')])},
+              {'call': 'swapoff', 'reason': set([('filename', 'name')])},
+              {'call': 'ustat',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_qcop'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'umount',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_qcop'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'openat', 'reason': set([('filename', 'name')])},
+              {'call': 'uselib', 'reason': set([('filename', 'name')])},
+              {'call': 'renameat2', 'reason': set([('filename', 'name')])},
+              {'call': 'symlinkat', 'reason': set([('filename', 'name')])},
+              {'call': 'acct', 'reason': set([('filename', 'name')])},
+              {'call': 'open', 'reason': set([('filename', 'name')])},
+              {'call': 'unlink', 'reason': set([('filename', 'name')])},
+              {'call': 'rmdir', 'reason': set([('filename', 'name')])},
+              {'call': 'swapon',
+               'reason': set([('filename', 'name'),
+                              ('super_block', 's_flags'),
+                              ('super_block', 's_qcop'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'mq_open', 'reason': set([('filename', 'name')])},
+              {'call': 'unlinkat', 'reason': set([('filename', 'name')])}],
+ 'read': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+          {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+          {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+          {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+          {'call': 'writev', 'reason': set([('fd', 'flags')])},
+          {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+          {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+          {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+          {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+          {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+          {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+          {'call': 'utime', 'reason': set([('fd', 'flags')])},
+          {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+          {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+          {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+          {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+          {'call': 'tee', 'reason': set([('fd', 'flags')])},
+          {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+          {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+          {'call': 'connect', 'reason': set([('fd', 'flags')])},
+          {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+          {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+          {'call': 'flock', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+          {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+          {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+          {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+          {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+          {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+          {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+          {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+          {'call': 'splice', 'reason': set([('fd', 'flags')])},
+          {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+          {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+          {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+          {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+          {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+          {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+          {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+          {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+          {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+          {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+          {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+          {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+          {'call': 'listen', 'reason': set([('fd', 'flags')])},
+          {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+          {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+          {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+          {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+          {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+          {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+          {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+          {'call': 'readv', 'reason': set([('fd', 'flags')])},
+          {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+          {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+          {'call': 'write', 'reason': set([('fd', 'flags')])},
+          {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+          {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+          {'call': 'bind', 'reason': set([('fd', 'flags')])},
+          {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'readahead': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'mq_unlink',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'swapoff',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'memfd_create',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+               {'call': 'readlinkat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'uselib',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmodat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'shmat',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+               {'call': 'linkat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'unlink',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'faccessat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'swapon',
+                'reason': set([('address_space', 'a_ops'),
+                               ('file', 'f_mode')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchownat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'sendfile',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'unlinkat',
+                'reason': set([('address_space', 'a_ops')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64',
+                'reason': set([('address_space', 'a_ops'), ('fd', 'flags')])}],
+ 'readlinkat': [{'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+                {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+                {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+                {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+                {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+                {'call': 'flock', 'reason': set([('path', 'dentry')])},
+                {'call': 'openat', 'reason': set([('path', 'dentry')])},
+                {'call': 'lookup_dcookie',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+                {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+                {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+                {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+                {'call': 'shmat', 'reason': set([('path', 'dentry')])},
+                {'call': 'socket', 'reason': set([('path', 'dentry')])},
+                {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('path', 'dentry')])},
+                {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+                {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+                {'call': 'acct', 'reason': set([('path', 'dentry')])},
+                {'call': 'open', 'reason': set([('path', 'dentry')])},
+                {'call': 'dup', 'reason': set([('path', 'dentry')])},
+                {'call': 'setns', 'reason': set([('path', 'dentry')])},
+                {'call': 'shmctl', 'reason': set([('path', 'dentry')])},
+                {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+                {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+                {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('path', 'dentry')])}],
+ 'reboot': [{'call': 'perf_event_open',
+             'reason': set([('pid_namespace', 'user_ns')])},
+            {'call': 'acct', 'reason': set([('pid_namespace', 'user_ns')])},
+            {'call': 'setns', 'reason': set([('pid_namespace', 'user_ns')])}],
+ 'recvfrom': [{'call': 'eventfd2', 'reason': set([('file', 'f_flags')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_flags')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_flags')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_flags')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_flags')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_flags')])},
+              {'call': 'epoll_ctl', 'reason': set([('file', 'f_flags')])},
+              {'call': 'flock', 'reason': set([('file', 'f_flags')])},
+              {'call': 'openat', 'reason': set([('file', 'f_flags')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_flags')])},
+              {'call': 'accept4', 'reason': set([('file', 'f_flags')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_flags')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_flags')])},
+              {'call': 'socket', 'reason': set([('file', 'f_flags')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('file', 'f_flags')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_flags')])},
+              {'call': 'acct', 'reason': set([('file', 'f_flags')])},
+              {'call': 'open', 'reason': set([('file', 'f_flags')])},
+              {'call': 'mq_getsetattr', 'reason': set([('file', 'f_flags')])},
+              {'call': 'dup', 'reason': set([('file', 'f_flags')])},
+              {'call': 'setns', 'reason': set([('file', 'f_flags')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_flags')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_flags')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_flags')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_flags')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_flags')])}],
+ 'recvmmsg': [{'call': 'rt_sigtimedwait',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'swapoff',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchmod',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'memfd_create',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'readlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'io_getevents',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchown',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'utime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'semtimedop',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'recvfrom',
+               'reason': set([('msghdr', 'msg_flags'),
+                              ('socket', 'file'),
+                              ('socket', 'sk')])},
+              {'call': 'settimeofday',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendto',
+               'reason': set([('msghdr', 'msg_flags'),
+                              ('socket', 'file'),
+                              ('socket', 'sk')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'connect',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'getsockname',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'pselect6',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'uselib',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'accept4',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'fchmodat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'inotify_add_watch',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ftruncate',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getpeername',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'setsockopt',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'ioctl',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'linkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendmsg',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'stime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'futimesat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'shutdown',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'poll',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'select',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getsockopt',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'nanosleep',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'faccessat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'listen',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'swapon',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'epoll_wait',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchownat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fstat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'recvmsg',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'mq_notify',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendmmsg',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'newfstat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'clock_nanosleep',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'bind',
+               'reason': set([('socket', 'file'), ('socket', 'sk')])},
+              {'call': 'futex',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile64',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ppoll',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])}],
+ 'recvmsg': [{'call': 'recvfrom', 'reason': set([('socket', 'file')])},
+             {'call': 'sendto', 'reason': set([('socket', 'file')])},
+             {'call': 'connect', 'reason': set([('socket', 'file')])},
+             {'call': 'getsockname', 'reason': set([('socket', 'file')])},
+             {'call': 'accept4', 'reason': set([('socket', 'file')])},
+             {'call': 'getpeername', 'reason': set([('socket', 'file')])},
+             {'call': 'setsockopt', 'reason': set([('socket', 'file')])},
+             {'call': 'sendmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'shutdown', 'reason': set([('socket', 'file')])},
+             {'call': 'getsockopt', 'reason': set([('socket', 'file')])},
+             {'call': 'listen', 'reason': set([('socket', 'file')])},
+             {'call': 'sendmmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'bind', 'reason': set([('socket', 'file')])},
+             {'call': 'recvmmsg', 'reason': set([('socket', 'file')])}],
+ 'remap_file_pages': [{'call': 'shmdt',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'brk',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'get_mempolicy',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'munlockall',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'pkey_mprotect',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'madvise',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mprotect',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mremap',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'prctl',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'munlock',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mincore',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mlockall',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_file'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])}],
+ 'removexattr': [{'call': 'eventfd2',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'swapoff',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'pivot_root',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'memfd_create',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'remap_file_pages',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'dup3',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'unshare',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'epoll_create1',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'epoll_ctl',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'flock',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'openat',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'lookup_dcookie',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'uselib',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'accept4',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'socketpair',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'getcwd',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'shmat',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'socket',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'pipe2',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'shmdt',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'quotactl',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'acct',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'open',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'dup',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'setns',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'shmctl',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'swapon',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'mmap_pgoff',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'mq_open',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+                 {'call': 'open_by_handle_at',
+                  'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'renameat2': [{'call': 'sysfs',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'eventfd2',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mq_unlink',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapoff',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'pivot_root',
+                'reason': set([('dentry', 'd_inode'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'memfd_create',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'dup3',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'unshare',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mkdirat', 'reason': set([('dentry', 'd_inode')])},
+               {'call': 'epoll_create1',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'flock',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'openat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'lookup_dcookie',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'uselib',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'accept4',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'socketpair',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'getcwd',
+                'reason': set([('dentry', 'd_inode'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'ftruncate', 'reason': set([('dentry', 'd_inode')])},
+               {'call': 'shmat',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mknodat', 'reason': set([('dentry', 'd_inode')])},
+               {'call': 'socket',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'symlinkat',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'pipe2',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'perf_event_open',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'linkat', 'reason': set([('dentry', 'd_inode')])},
+               {'call': 'shmdt',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'quotactl',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'acct',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'unlink',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'rmdir',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'dup',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'setns',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'shmctl',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'swapon',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'mmap_pgoff',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+               {'call': 'mq_open',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt'),
+                               ('path', 'dentry'),
+                               ('path', 'mnt')])},
+               {'call': 'unlinkat',
+                'reason': set([('dentry', 'd_inode'),
+                               ('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'rmdir': [{'call': 'eventfd2',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mq_unlink', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'swapoff',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'pivot_root',
+            'reason': set([('dentry', 'd_inode'),
+                           ('path', 'dentry'),
+                           ('path', 'mnt')])},
+           {'call': 'memfd_create',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'remap_file_pages',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'dup3',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'unshare',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mkdirat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'epoll_create1',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'flock',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'openat',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'lookup_dcookie',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'uselib',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'renameat2', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'accept4',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'socketpair',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'getcwd',
+            'reason': set([('dentry', 'd_inode'),
+                           ('path', 'dentry'),
+                           ('path', 'mnt')])},
+           {'call': 'ftruncate', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'shmat',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mknodat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'socket',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'symlinkat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'pipe2',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'perf_event_open',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'linkat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'shmdt',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'quotactl',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'acct',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'open',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'unlink', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'dup',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'setns',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'shmctl',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'swapon',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mmap_pgoff',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+           {'call': 'mq_open',
+            'reason': set([('dentry', 'd_inode'),
+                           ('path', 'dentry'),
+                           ('path', 'mnt')])},
+           {'call': 'unlinkat', 'reason': set([('dentry', 'd_inode')])},
+           {'call': 'open_by_handle_at',
+            'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'rt_sigqueueinfo': [{'call': 'rt_sigtimedwait',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'kill',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'timer_create',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'tgkill',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'rt_tgsigqueueinfo',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'rt_sigreturn',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'tkill',
+                      'reason': set([('siginfo', 'si_code')])}],
+ 'rt_sigreturn': [{'call': 'keyctl',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigtimedwait',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'msgrcv',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'kill',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getaffinity',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setparam',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ioprio_set',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getppid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ioperm',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'capget',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setaffinity',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'signal',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'semtimedop',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'umount',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_rr_get_interval',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigprocmask',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setsid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sigaltstack',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setattr',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'migrate_pages',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getitimer',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setpgid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getsid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'prlimit64',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigaction',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getpgid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getpriority',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sigaction',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setns',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'fork',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'get_robust_list',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getscheduler',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ptrace',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getattr',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getrusage',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setscheduler',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setitimer',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ioprio_get',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'vfork',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'prctl',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'move_pages',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setpriority',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'clone',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getparam',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])}],
+ 'rt_sigtimedwait': [{'call': 'keyctl',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'msgrcv',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'kill',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getaffinity',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setparam',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ioprio_set',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getppid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ioperm',
+                      'reason': set([('mm_segment_t', 'seg')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'capget',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setaffinity',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'signal',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'umount',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'timer_create',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigqueueinfo',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'tgkill',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'rt_sigprocmask',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'setsid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sigaltstack',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setattr',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'migrate_pages',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getitimer',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'setpgid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getsid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'prlimit64',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigaction',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getpgid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getpriority',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sigaction',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_tgsigqueueinfo',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'setns',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'fork',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'get_robust_list',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getscheduler',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ptrace',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getattr',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getrusage',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setscheduler',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'setitimer',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ioprio_get',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'vfork',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'prctl',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'move_pages',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigreturn',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'tkill',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'setpriority',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'clone',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getparam',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])}],
+ 'rt_tgsigqueueinfo': [{'call': 'rt_sigtimedwait',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'kill',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'timer_create',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'rt_sigqueueinfo',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'tgkill',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'rt_sigreturn',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'tkill',
+                        'reason': set([('siginfo', 'si_code')])}],
+ 'sched_getattr': [{'call': 'keyctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'kill',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getppid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ioperm',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'capget',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'signal',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'umount',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('sched_attr', 'size'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setns',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'fork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ptrace',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getrusage',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'vfork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'prctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'move_pages',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'clone',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])}],
+ 'sched_getparam': [{'call': 'keyctl',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'rt_sigtimedwait',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'msgrcv',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'kill',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getaffinity',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setparam',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'ioprio_set',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getppid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'mq_timedreceive',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'capget',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setaffinity',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'signal',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'semtimedop',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'umount',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_rr_get_interval',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'rt_sigprocmask',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setsid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sigaltstack',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setattr',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'migrate_pages',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getitimer',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setpgid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getsid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'prlimit64',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'perf_event_open',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'rt_sigaction',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getpgid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getpriority',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sigaction',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setns',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'fork',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'get_robust_list',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'mq_timedsend',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getscheduler',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'ptrace',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getattr',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getrusage',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setscheduler',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setitimer',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'ioprio_get',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'vfork',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'prctl',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'move_pages',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setpriority',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'clone',
+                     'reason': set([('task_struct', 'policy')])}],
+ 'sched_getscheduler': [{'call': 'keyctl',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'rt_sigtimedwait',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'msgrcv',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'kill',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getaffinity',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setparam',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'ioprio_set',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getppid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'mq_timedreceive',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'capget',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setaffinity',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'signal',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'semtimedop',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'umount',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_rr_get_interval',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'rt_sigprocmask',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setsid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sigaltstack',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setattr',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'migrate_pages',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getitimer',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setpgid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getsid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'prlimit64',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'perf_event_open',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'rt_sigaction',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getpgid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getpriority',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sigaction',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setns',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'fork',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'get_robust_list',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'mq_timedsend',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'ptrace',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getattr',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getrusage',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setscheduler',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setitimer',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'ioprio_get',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'vfork',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'prctl',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'move_pages',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setpriority',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'clone',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getparam',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])}],
+ 'sched_setaffinity': [{'call': 'keyctl',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'rt_sigtimedwait',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setfsuid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'msgrcv',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'kill',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getresuid16',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'getresgid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'sched_getaffinity',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_setparam',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setgid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'ioprio_set',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'capset',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'getppid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'mq_timedreceive',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getresgid16',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'capget',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setfsgid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'unshare',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'signal',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setreuid',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags')])},
+                       {'call': 'semtimedop',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'umount',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_rr_get_interval',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'epoll_create1',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'getresuid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'rt_sigprocmask',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setsid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sigaltstack',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_setattr',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'migrate_pages',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getitimer',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setpgid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setresgid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'setregid',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'getsid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'prlimit64',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getgroups16',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'rt_sigaction',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getpgid',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getpriority',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sigaction',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'faccessat',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'setns',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'fork',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'get_robust_list',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'mq_timedsend',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_getscheduler',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'ptrace',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_getattr',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getrusage',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_setscheduler',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setresuid',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags')])},
+                       {'call': 'setitimer',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'ioprio_get',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'vfork',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'setuid',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags')])},
+                       {'call': 'prctl',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'move_pages',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'getgroups',
+                        'reason': set([('cred', 'user_ns')])},
+                       {'call': 'setpriority',
+                        'reason': set([('cred', 'user_ns'),
+                                       ('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'clone',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])},
+                       {'call': 'sched_getparam',
+                        'reason': set([('task_struct', 'flags'),
+                                       ('task_struct', 'real_cred')])}],
+ 'sched_setattr': [{'call': 'keyctl',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getppid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioperm',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'capget',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'signal',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'umount',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setsid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getitimer',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setpgid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getsid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getpgid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getpriority',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sigaction',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setns',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ptrace',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('sched_attr', 'sched_policy')])},
+                   {'call': 'getrusage',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setitimer',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'vfork',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'prctl',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'move_pages',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setpriority',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'clone',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('mm_segment_t', 'seg')])}],
+ 'select': [{'call': 'keyctl',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_unlink',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'swapoff',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchmod',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'memfd_create',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'ioprio_set',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'personality',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'dup3', 'reason': set([('files_struct', 'fdt')])},
+            {'call': 'readlinkat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'io_getevents',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchown',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'utime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'unshare', 'reason': set([('files_struct', 'fdt')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'settimeofday',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timerfd_gettime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'pselect6',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'uselib',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchmodat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timer_settime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'ftruncate',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timer_gettime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioctl',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'prlimit64',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'linkat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'stime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'futimesat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'poll',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'unlink',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'nanosleep',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'faccessat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ptrace',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'swapon',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'epoll_wait',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchownat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getrusage',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fstat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timerfd_settime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioprio_get',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'prctl',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'move_pages',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'dup2', 'reason': set([('files_struct', 'fdt')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_notify',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sendfile',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'newfstat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'clock_nanosleep',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'unlinkat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'futex',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'recvmmsg',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sendfile64',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'ppoll',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])}],
+ 'semctl': [{'call': 'semtimedop',
+             'reason': set([('sem_array', 'sem_nsems')])}],
+ 'semtimedop': [{'call': 'syncfs', 'reason': set([('list_head', 'prev')])},
+                {'call': 'keyctl', 'reason': set([('list_head', 'prev')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'vmsplice', 'reason': set([('list_head', 'prev')])},
+                {'call': 'msgrcv',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'eventfd2', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mq_unlink',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'kill', 'reason': set([('list_head', 'prev')])},
+                {'call': 'swapoff',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'readahead', 'reason': set([('list_head', 'prev')])},
+                {'call': 'timer_delete',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'fchmod',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'setgid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'pivot_root',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'memfd_create',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'delete_module',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'dup3', 'reason': set([('list_head', 'prev')])},
+                {'call': 'readlinkat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'io_getevents',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'getppid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'fchown',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'capget', 'reason': set([('list_head', 'prev')])},
+                {'call': 'utime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'ustat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'bpf', 'reason': set([('list_head', 'prev')])},
+                {'call': 'unshare', 'reason': set([('list_head', 'prev')])},
+                {'call': 'signal', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setreuid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'umount', 'reason': set([('list_head', 'prev')])},
+                {'call': 'settimeofday',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timer_create',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mkdirat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'timerfd_gettime',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'tee', 'reason': set([('list_head', 'prev')])},
+                {'call': 'semctl',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev'),
+                                ('sem_array', 'complex_count'),
+                                ('sem_array', 'sem_nsems'),
+                                ('sem_array', 'use_global_lock'),
+                                ('sem_undo', 'semid')])},
+                {'call': 'sync_file_range',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'epoll_ctl', 'reason': set([('list_head', 'prev')])},
+                {'call': 'flock', 'reason': set([('list_head', 'prev')])},
+                {'call': 'openat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'lookup_dcookie',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'pselect6',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'uselib',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'renameat2', 'reason': set([('list_head', 'prev')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'accept4', 'reason': set([('list_head', 'prev')])},
+                {'call': 'msgctl',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'reboot', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setsid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'set_trip_temp',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'socketpair',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'getitimer', 'reason': set([('list_head', 'prev')])},
+                {'call': 'fchmodat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'setpgid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'init_module',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'setresgid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'getcwd', 'reason': set([('list_head', 'prev')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'get_trip_temp',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'timer_settime',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'setregid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'splice', 'reason': set([('list_head', 'prev')])},
+                {'call': 'ftruncate',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timer_gettime',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'getsid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'shmat',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'mknodat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'socket', 'reason': set([('list_head', 'prev')])},
+                {'call': 'symlinkat', 'reason': set([('list_head', 'prev')])},
+                {'call': 'pipe2', 'reason': set([('list_head', 'prev')])},
+                {'call': 'ioctl',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'prlimit64', 'reason': set([('list_head', 'prev')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'linkat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'stime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'getgroups16',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'shmdt', 'reason': set([('list_head', 'prev')])},
+                {'call': 'quotactl', 'reason': set([('list_head', 'prev')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'futimesat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'request_key',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'getpgid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'brk', 'reason': set([('list_head', 'prev')])},
+                {'call': 'acct', 'reason': set([('list_head', 'prev')])},
+                {'call': 'poll',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'open', 'reason': set([('list_head', 'prev')])},
+                {'call': 'select',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'unlink',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'exit_group',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'getpriority',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sigaction', 'reason': set([('list_head', 'prev')])},
+                {'call': 'nanosleep',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mq_getsetattr',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'faccessat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'rmdir', 'reason': set([('list_head', 'prev')])},
+                {'call': 'dup', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setgroups16',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'setns', 'reason': set([('list_head', 'prev')])},
+                {'call': 'fork', 'reason': set([('list_head', 'prev')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'io_submit', 'reason': set([('list_head', 'prev')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_yield',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'ptrace', 'reason': set([('list_head', 'prev')])},
+                {'call': 'shmctl',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'munlockall',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'swapon',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'pkey_mprotect',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'madvise', 'reason': set([('list_head', 'prev')])},
+                {'call': 'epoll_wait',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'fchownat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'getrusage', 'reason': set([('list_head', 'prev')])},
+                {'call': 'fstat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timerfd_settime',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'setresuid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setitimer', 'reason': set([('list_head', 'prev')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'vfork', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setuid', 'reason': set([('list_head', 'prev')])},
+                {'call': 'io_setup', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mprotect', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mmap_pgoff',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mremap', 'reason': set([('list_head', 'prev')])},
+                {'call': 'io_destroy',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mbind', 'reason': set([('list_head', 'prev')])},
+                {'call': 'prctl', 'reason': set([('list_head', 'prev')])},
+                {'call': 'move_pages',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'timerfd_create',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'modify_ldt',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'getgroups', 'reason': set([('list_head', 'prev')])},
+                {'call': 'dup2', 'reason': set([('list_head', 'prev')])},
+                {'call': 'get_curr_temp',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'msgsnd',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('list_head', 'prev')])},
+                {'call': 'munlock', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setpriority',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'inotify_init1',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'mincore', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mq_notify',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sendfile',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timer_getoverrun',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'newfstat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'kexec_load',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'clone', 'reason': set([('list_head', 'prev')])},
+                {'call': 'mq_open', 'reason': set([('list_head', 'prev')])},
+                {'call': 'setgroups', 'reason': set([('list_head', 'prev')])},
+                {'call': 'clock_nanosleep',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'unlinkat',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'io_cancel', 'reason': set([('list_head', 'prev')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'futex',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'recvmmsg',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'finit_module',
+                 'reason': set([('list_head', 'prev')])},
+                {'call': 'sendfile64',
+                 'reason': set([('list_head', 'prev'),
+                                ('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mlockall', 'reason': set([('list_head', 'prev')])},
+                {'call': 'ppoll',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])}],
+ 'sendfile': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'perf_event_open',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])}],
+ 'sendfile64': [{'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+                {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+                {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+                {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+                {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+                {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_mode')])}],
+ 'sendmmsg': [{'call': 'recvfrom', 'reason': set([('socket', 'file')])},
+              {'call': 'sendto', 'reason': set([('socket', 'file')])},
+              {'call': 'connect', 'reason': set([('socket', 'file')])},
+              {'call': 'getsockname', 'reason': set([('socket', 'file')])},
+              {'call': 'accept4', 'reason': set([('socket', 'file')])},
+              {'call': 'getpeername', 'reason': set([('socket', 'file')])},
+              {'call': 'setsockopt', 'reason': set([('socket', 'file')])},
+              {'call': 'sendmsg', 'reason': set([('socket', 'file')])},
+              {'call': 'shutdown', 'reason': set([('socket', 'file')])},
+              {'call': 'getsockopt', 'reason': set([('socket', 'file')])},
+              {'call': 'listen', 'reason': set([('socket', 'file')])},
+              {'call': 'recvmsg', 'reason': set([('socket', 'file')])},
+              {'call': 'bind', 'reason': set([('socket', 'file')])},
+              {'call': 'recvmmsg', 'reason': set([('socket', 'file')])}],
+ 'sendmsg': [{'call': 'recvfrom', 'reason': set([('socket', 'file')])},
+             {'call': 'sendto', 'reason': set([('socket', 'file')])},
+             {'call': 'connect', 'reason': set([('socket', 'file')])},
+             {'call': 'getsockname', 'reason': set([('socket', 'file')])},
+             {'call': 'accept4', 'reason': set([('socket', 'file')])},
+             {'call': 'getpeername', 'reason': set([('socket', 'file')])},
+             {'call': 'setsockopt', 'reason': set([('socket', 'file')])},
+             {'call': 'shutdown', 'reason': set([('socket', 'file')])},
+             {'call': 'getsockopt', 'reason': set([('socket', 'file')])},
+             {'call': 'listen', 'reason': set([('socket', 'file')])},
+             {'call': 'recvmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'sendmmsg', 'reason': set([('socket', 'file')])},
+             {'call': 'bind', 'reason': set([('socket', 'file')])},
+             {'call': 'recvmmsg', 'reason': set([('socket', 'file')])}],
+ 'sendto': [{'call': 'eventfd2', 'reason': set([('file', 'f_flags')])},
+            {'call': 'swapoff', 'reason': set([('file', 'f_flags')])},
+            {'call': 'memfd_create', 'reason': set([('file', 'f_flags')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('file', 'f_flags')])},
+            {'call': 'dup3', 'reason': set([('file', 'f_flags')])},
+            {'call': 'epoll_create1', 'reason': set([('file', 'f_flags')])},
+            {'call': 'epoll_ctl', 'reason': set([('file', 'f_flags')])},
+            {'call': 'flock', 'reason': set([('file', 'f_flags')])},
+            {'call': 'openat', 'reason': set([('file', 'f_flags')])},
+            {'call': 'uselib', 'reason': set([('file', 'f_flags')])},
+            {'call': 'accept4', 'reason': set([('file', 'f_flags')])},
+            {'call': 'socketpair', 'reason': set([('file', 'f_flags')])},
+            {'call': 'shmat', 'reason': set([('file', 'f_flags')])},
+            {'call': 'socket', 'reason': set([('file', 'f_flags')])},
+            {'call': 'pipe2', 'reason': set([('file', 'f_flags')])},
+            {'call': 'perf_event_open', 'reason': set([('file', 'f_flags')])},
+            {'call': 'shmdt', 'reason': set([('file', 'f_flags')])},
+            {'call': 'acct', 'reason': set([('file', 'f_flags')])},
+            {'call': 'open', 'reason': set([('file', 'f_flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('file', 'f_flags')])},
+            {'call': 'dup', 'reason': set([('file', 'f_flags')])},
+            {'call': 'setns', 'reason': set([('file', 'f_flags')])},
+            {'call': 'shmctl', 'reason': set([('file', 'f_flags')])},
+            {'call': 'swapon', 'reason': set([('file', 'f_flags')])},
+            {'call': 'mmap_pgoff', 'reason': set([('file', 'f_flags')])},
+            {'call': 'mq_open', 'reason': set([('file', 'f_flags')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('file', 'f_flags')])}],
+ 'set_mempolicy': [{'call': 'get_mempolicy',
+                    'reason': set([('mempolicy', 'mode')])},
+                   {'call': 'mbind', 'reason': set([('mempolicy', 'mode')])}],
+ 'set_thread_area': [{'call': 'keyctl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'rt_sigtimedwait',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'msgrcv',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'kill',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getaffinity',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'arch_prctl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setparam',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ioprio_set',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getppid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ioperm',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'capget',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setaffinity',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'signal',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'umount',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'rt_sigprocmask',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setsid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sigaltstack',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setattr',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'migrate_pages',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getitimer',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setpgid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getsid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'prlimit64',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'rt_sigaction',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getpgid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getpriority',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sigaction',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setns',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'fork',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'get_robust_list',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getscheduler',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ptrace',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getattr',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getrusage',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setscheduler',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setitimer',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ioprio_get',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'vfork',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'prctl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'move_pages',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setpriority',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'clone',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getparam',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])}],
+ 'set_trip_temp': [{'call': 'get_trip_temp',
+                    'reason': set([('pkg_device', 'cpu'),
+                                   ('pkg_device', 'tj_max')])},
+                   {'call': 'get_curr_temp',
+                    'reason': set([('pkg_device', 'cpu'),
+                                   ('pkg_device', 'tj_max')])}],
+ 'setdomainname': [{'call': 'setns',
+                    'reason': set([('uts_namespace', 'user_ns')])}],
+ 'setfsgid': [{'call': 'keyctl',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setgid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'fsgid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'ioprio_set',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setreuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'epoll_create1', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresgid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'fsgid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'setregid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'fsgid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'faccessat',
+               'reason': set([('cred', 'fsgid'), ('cred', 'user_ns')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'setfsuid': [{'call': 'keyctl',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'ioprio_set',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setreuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'fsuid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'epoll_create1', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setregid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'faccessat',
+               'reason': set([('cred', 'fsuid'), ('cred', 'user_ns')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'fsuid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'fsuid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'setgid': [{'call': 'keyctl',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_set',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setreuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'epoll_create1', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setresgid',
+             'reason': set([('cred', 'gid'),
+                            ('cred', 'sgid'),
+                            ('cred', 'user_ns')])},
+            {'call': 'setregid',
+             'reason': set([('cred', 'gid'),
+                            ('cred', 'sgid'),
+                            ('cred', 'user_ns')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'faccessat', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setresuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setuid', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+            {'call': 'setpriority',
+             'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'setgroups16': [{'call': 'setgroups',
+                  'reason': set([('group_info', 'ngroups')])}],
+ 'sethostname': [{'call': 'setns',
+                  'reason': set([('uts_namespace', 'user_ns')])}],
+ 'setitimer': [{'call': 'waitid',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'settimeofday',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'timer_create',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'adjtimex',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'getitimer',
+                'reason': set([('itimerval', 'it_interval'),
+                               ('itimerval', 'it_value'),
+                               ('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'select',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'exit_group',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'wait4',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'getrusage',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'clock_adjtime',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'alarm',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'ppoll',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])}],
+ 'setpgid': [{'call': 'keyctl',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'msgrcv',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'kill',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'ioprio_set',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getppid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'capget',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'signal',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+             {'call': 'semtimedop',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'umount',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'timer_create',
+              'reason': set([('signal_struct', 'leader')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setsid',
+              'reason': set([('signal_struct', 'leader'),
+                             ('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sigaltstack',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getitimer',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getsid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'prlimit64',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getpgid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'exit_group',
+              'reason': set([('signal_struct', 'leader')])},
+             {'call': 'getpriority',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sigaction',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setns',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'fork',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'ptrace',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'getrusage',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+             {'call': 'setitimer',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'ioprio_get',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'vfork',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+             {'call': 'prctl',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'move_pages',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'setpriority',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'clone',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags'),
+                             ('task_struct', 'real_parent'),
+                             ('task_struct', 'signal')])}],
+ 'setpriority': [{'call': 'keyctl',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigtimedwait',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'msgrcv',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'kill',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getaffinity',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setparam',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ioprio_set',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getppid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'capget',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setaffinity',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'signal',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setreuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'semtimedop',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'umount',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_rr_get_interval',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigprocmask',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setsid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sigaltstack',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setattr',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'migrate_pages',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getitimer',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setpgid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getsid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'prlimit64',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'rt_sigaction',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getpgid',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getpriority',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sigaction',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setns',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'fork',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'get_robust_list',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'mq_timedsend',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getscheduler',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ptrace',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getattr',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'getrusage',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_setscheduler',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setresuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'setitimer',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'ioprio_get',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'vfork',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'setuid', 'reason': set([('cred', 'uid')])},
+                 {'call': 'prctl',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'move_pages',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'clone',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])},
+                 {'call': 'sched_getparam',
+                  'reason': set([('task_struct', 'cred'),
+                                 ('task_struct', 'real_cred')])}],
+ 'setregid': [{'call': 'keyctl',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setgid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'ioprio_set',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setreuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'epoll_create1', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresgid',
+               'reason': set([('cred', 'egid'),
+                              ('cred', 'gid'),
+                              ('cred', 'sgid'),
+                              ('cred', 'user_ns')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'faccessat', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setuid', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+              {'call': 'setpriority',
+               'reason': set([('cred', 'user_ns'), ('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'setresgid': [{'call': 'keyctl',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setfsuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresuid16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'getresgid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setgid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'ioprio_set',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'capset', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresgid16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'setfsgid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'unshare', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setreuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'epoll_create1',
+                'reason': set([('cred', 'user_ns')])},
+               {'call': 'getresuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setregid',
+                'reason': set([('cred', 'egid'),
+                               ('cred', 'gid'),
+                               ('cred', 'sgid'),
+                               ('cred', 'user_ns')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups16', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'faccessat', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setuid', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups', 'reason': set([('cred', 'user_ns')])},
+               {'call': 'setpriority',
+                'reason': set([('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'setresuid': [{'call': 'keyctl',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setfsuid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresuid16',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'getresgid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setgid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'ioprio_set',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'capset',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getresgid16',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'setfsgid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'unshare',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setreuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user'),
+                               ('cred', 'user_ns')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'epoll_create1',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'getresuid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'migrate_pages',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setresgid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'setregid',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'prlimit64',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups16',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'getpriority',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'faccessat',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'ioprio_get',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'setuid',
+                'reason': set([('cred', 'euid'),
+                               ('cred', 'suid'),
+                               ('cred', 'uid'),
+                               ('cred', 'user'),
+                               ('cred', 'user_ns')])},
+               {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'cred')])},
+               {'call': 'getgroups',
+                'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+               {'call': 'setpriority',
+                'reason': set([('cred', 'user'),
+                               ('cred', 'user_ns'),
+                               ('task_struct', 'cred')])},
+               {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'cred')])}],
+ 'setreuid': [{'call': 'keyctl',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setfsuid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresuid16',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'getresgid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setgid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'ioprio_set',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'capset',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getresgid16',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'setfsgid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'unshare',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'epoll_create1',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'getresuid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'migrate_pages',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresgid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'setregid',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'prlimit64',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups16',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'getpriority',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'faccessat',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'setresuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user'),
+                              ('cred', 'user_ns')])},
+              {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'ioprio_get',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'setuid',
+               'reason': set([('cred', 'euid'),
+                              ('cred', 'suid'),
+                              ('cred', 'uid'),
+                              ('cred', 'user'),
+                              ('cred', 'user_ns')])},
+              {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'cred')])},
+              {'call': 'getgroups',
+               'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+              {'call': 'setpriority',
+               'reason': set([('cred', 'user'),
+                              ('cred', 'user_ns'),
+                              ('task_struct', 'cred')])},
+              {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'cred')])}],
+ 'setrlimit': [{'call': 'keyctl',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'msgrcv',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'kill',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setparam',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ioprio_set',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getppid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'capget',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'signal',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'semtimedop',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'umount',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setsid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sigaltstack',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setattr',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'migrate_pages',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getitimer',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setpgid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getsid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'old_getrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'prlimit64',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max'),
+                               ('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'perf_event_open',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getpgid',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getpriority',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sigaction',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setns',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'fork',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'get_robust_list',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ptrace',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getattr',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getrusage',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setitimer',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'ioprio_get',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'vfork',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'prctl',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'move_pages',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'setpriority',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'getrlimit',
+                'reason': set([('compat_rlimit', 'rlim_cur'),
+                               ('compat_rlimit', 'rlim_max')])},
+               {'call': 'clone',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])},
+               {'call': 'sched_getparam',
+                'reason': set([('task_struct', 'group_leader'),
+                               ('task_struct', 'sighand')])}],
+ 'setsid': [{'call': 'timer_create',
+             'reason': set([('signal_struct', 'leader')])},
+            {'call': 'exit_group',
+             'reason': set([('signal_struct', 'leader')])}],
+ 'setsockopt': [{'call': 'accept4',
+                 'reason': set([('proto_ops', 'compat_setsockopt')])}],
+ 'settimeofday': [{'call': 'waitid',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'adjtimex',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'getitimer',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'select',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'wait4',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'getrusage',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'setitimer',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'clock_adjtime',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'alarm',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'ppoll',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])}],
+ 'setuid': [{'call': 'keyctl',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setfsuid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getresuid16',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'getresgid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setgid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'ioprio_set',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'capset',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getresgid16',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'setfsgid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'unshare',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setreuid',
+             'reason': set([('cred', 'suid'),
+                            ('cred', 'uid'),
+                            ('cred', 'user'),
+                            ('cred', 'user_ns')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'epoll_create1',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'getresuid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setresgid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'setregid',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getgroups16',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'faccessat',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setresuid',
+             'reason': set([('cred', 'suid'),
+                            ('cred', 'uid'),
+                            ('cred', 'user'),
+                            ('cred', 'user_ns')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getgroups',
+             'reason': set([('cred', 'user'), ('cred', 'user_ns')])},
+            {'call': 'setpriority',
+             'reason': set([('cred', 'user'),
+                            ('cred', 'user_ns'),
+                            ('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'setxattr': [{'call': 'eventfd2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pivot_root',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'memfd_create',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup3',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'unshare',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_create1',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'flock',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'openat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'lookup_dcookie',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'uselib',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'accept4',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socketpair',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'getcwd',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socket',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pipe2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmdt',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'quotactl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'acct',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'setns',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapon',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mmap_pgoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mq_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'shmat': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'eventfd2', 'reason': set([('path', 'dentry')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'swapoff', 'reason': set([('path', 'dentry')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setparam', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'pivot_root', 'reason': set([('path', 'dentry')])},
+           {'call': 'memfd_create', 'reason': set([('path', 'dentry')])},
+           {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'remap_file_pages', 'reason': set([('path', 'dentry')])},
+           {'call': 'dup3', 'reason': set([('path', 'dentry')])},
+           {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'unshare', 'reason': set([('path', 'dentry')])},
+           {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'epoll_create1', 'reason': set([('path', 'dentry')])},
+           {'call': 'epoll_ctl', 'reason': set([('path', 'dentry')])},
+           {'call': 'flock', 'reason': set([('path', 'dentry')])},
+           {'call': 'openat', 'reason': set([('path', 'dentry')])},
+           {'call': 'lookup_dcookie', 'reason': set([('path', 'dentry')])},
+           {'call': 'uselib', 'reason': set([('path', 'dentry')])},
+           {'call': 'rt_sigprocmask', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'accept4', 'reason': set([('path', 'dentry')])},
+           {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setattr', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'socketpair', 'reason': set([('path', 'dentry')])},
+           {'call': 'migrate_pages', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getcwd', 'reason': set([('path', 'dentry')])},
+           {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'socket', 'reason': set([('path', 'dentry')])},
+           {'call': 'pipe2', 'reason': set([('path', 'dentry')])},
+           {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'perf_event_open',
+            'reason': set([('path', 'dentry'), ('task_struct', 'mm')])},
+           {'call': 'shmdt', 'reason': set([('path', 'dentry')])},
+           {'call': 'quotactl', 'reason': set([('path', 'dentry')])},
+           {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'acct', 'reason': set([('path', 'dentry')])},
+           {'call': 'open', 'reason': set([('path', 'dentry')])},
+           {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'dup', 'reason': set([('path', 'dentry')])},
+           {'call': 'setns',
+            'reason': set([('path', 'dentry'), ('task_struct', 'mm')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'shmctl',
+            'reason': set([('path', 'dentry'),
+                           ('shmid_kernel', 'shm_file')])},
+           {'call': 'swapon', 'reason': set([('path', 'dentry')])},
+           {'call': 'sched_getattr', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'mm')])},
+           {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'mmap_pgoff', 'reason': set([('path', 'dentry')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'mq_open', 'reason': set([('path', 'dentry')])},
+           {'call': 'sched_getparam', 'reason': set([('task_struct', 'mm')])},
+           {'call': 'open_by_handle_at', 'reason': set([('path', 'dentry')])}],
+ 'shmctl': [{'call': 'keyctl',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'msgrcv',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode'),
+                            ('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+            {'call': 'mq_unlink',
+             'reason': set([('ipc_namespace', 'user_ns')])},
+            {'call': 'kill',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+            {'call': 'msgget', 'reason': set([('ipc_namespace', 'user_ns')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+            {'call': 'ioprio_set',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'remap_file_pages', 'reason': set([('file', 'f_op')])},
+            {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+            {'call': 'getppid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'capget',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'signal',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'semtimedop',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode'),
+                            ('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'umount',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+            {'call': 'semctl',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'epoll_ctl', 'reason': set([('file', 'f_op')])},
+            {'call': 'flock', 'reason': set([('file', 'f_op')])},
+            {'call': 'openat', 'reason': set([('file', 'f_op')])},
+            {'call': 'shmget', 'reason': set([('ipc_namespace', 'user_ns')])},
+            {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'accept4', 'reason': set([('file', 'f_op')])},
+            {'call': 'msgctl',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'setsid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sigaltstack',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'getitimer',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'setpgid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'semget', 'reason': set([('ipc_namespace', 'user_ns')])},
+            {'call': 'getsid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'shmat',
+             'reason': set([('file', 'f_op'),
+                            ('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'socket', 'reason': set([('file', 'f_op')])},
+            {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+            {'call': 'prlimit64',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('file', 'f_op'),
+                            ('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'getpgid',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'acct', 'reason': set([('file', 'f_op')])},
+            {'call': 'open', 'reason': set([('file', 'f_op')])},
+            {'call': 'getpriority',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sigaction',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'dup', 'reason': set([('file', 'f_op')])},
+            {'call': 'setns',
+             'reason': set([('file', 'f_op'),
+                            ('ipc_namespace', 'user_ns'),
+                            ('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'fork',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'ptrace',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+            {'call': 'sched_getattr',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'getrusage',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'setitimer',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'ioprio_get',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'vfork',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+            {'call': 'prctl',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'move_pages',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'msgsnd',
+             'reason': set([('ipc_namespace', 'user_ns'),
+                            ('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'setpriority',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'clone',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'mq_open',
+             'reason': set([('file', 'f_op'), ('ipc_namespace', 'user_ns')])},
+            {'call': 'sched_getparam',
+             'reason': set([('mm_segment_t', 'seg'),
+                            ('task_struct', 'cred')])},
+            {'call': 'open_by_handle_at', 'reason': set([('file', 'f_op')])}],
+ 'shmdt': [{'call': 'remap_file_pages',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'brk',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'get_mempolicy',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'munlockall',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'pkey_mprotect',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'madvise',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mprotect',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mremap',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'prctl',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'munlock',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mincore',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mlockall',
+            'reason': set([('vm_area_struct', 'vm_file'),
+                           ('vm_area_struct', 'vm_ops'),
+                           ('vm_area_struct', 'vm_pgoff')])}],
+ 'sigaction': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setparam',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_set',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'semtimedop',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaltstack',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'migrate_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prlimit64',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'perf_event_open',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'get_robust_list',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getrusage',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_get',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'move_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getparam',
+                'reason': set([('mm_segment_t', 'seg')])}],
+ 'signalfd4': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'eventfd2', 'reason': set([('file', 'f_op')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'swapoff', 'reason': set([('file', 'f_op')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'memfd_create', 'reason': set([('file', 'f_op')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_op')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_op')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_op')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'openat', 'reason': set([('file', 'f_op')])},
+               {'call': 'uselib', 'reason': set([('file', 'f_op')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_op')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'shmat', 'reason': set([('file', 'f_op')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'socket', 'reason': set([('file', 'f_op')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_op')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'flags'), ('file', 'f_op')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_op')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'acct', 'reason': set([('file', 'f_op')])},
+               {'call': 'open', 'reason': set([('file', 'f_op')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'dup', 'reason': set([('file', 'f_op')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'setns', 'reason': set([('file', 'f_op')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_op')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'swapon', 'reason': set([('file', 'f_op')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_op')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_op')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_op')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'splice': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'eventfd2',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapoff',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'memfd_create',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'dup3',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_create1',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'openat',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'uselib',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'socketpair',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmat',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'socket',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'pipe2',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'shmdt',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'acct',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'open',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('fd', 'flags'), ('file', 'f_flags')])},
+            {'call': 'dup',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'setns',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmctl',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapon',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_open',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'stat': [{'call': 'lstat',
+           'reason': set([('__old_kernel_stat', 'st_ino'),
+                          ('__old_kernel_stat', 'st_nlink')])},
+          {'call': 'fstat',
+           'reason': set([('__old_kernel_stat', 'st_ino'),
+                          ('__old_kernel_stat', 'st_nlink'),
+                          ('kstat', 'dev'),
+                          ('kstat', 'ino'),
+                          ('kstat', 'nlink'),
+                          ('kstat', 'rdev')])},
+          {'call': 'newfstat',
+           'reason': set([('kstat', 'dev'),
+                          ('kstat', 'ino'),
+                          ('kstat', 'nlink'),
+                          ('kstat', 'rdev')])}],
+ 'statfs': [{'call': 'ustat',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'fstatfs',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'fstatfs64',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'statfs64',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])}],
+ 'statfs64': [{'call': 'ustat',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'fstatfs',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'statfs',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'fstatfs64',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])}],
+ 'swapoff': [{'call': 'keyctl', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'msgrcv', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'kill', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'ioprio_set', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mapping')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'getppid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'capget', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'signal', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'semtimedop', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'umount', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'epoll_create1',
+              'reason': set([('file', 'f_mapping')])},
+             {'call': 'epoll_ctl', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'flock', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'accept4', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'setsid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sigaltstack', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'getitimer', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'setpgid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'getsid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'prlimit64', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'perf_event_open',
+              'reason': set([('file', 'f_mapping'), ('task_struct', 'mm')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'rt_sigaction', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'getpgid', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'open', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'getpriority', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sigaction', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'setns',
+              'reason': set([('file', 'f_mapping'), ('task_struct', 'mm')])},
+             {'call': 'fork', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_timedsend', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'ptrace', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'swapon',
+              'reason': set([('file', 'f_mapping'),
+                             ('page', 'private'),
+                             ('swap_info_struct', 'cluster_info'),
+                             ('swap_info_struct', 'flags'),
+                             ('swap_info_struct', 'inuse_pages'),
+                             ('swap_info_struct', 'pages'),
+                             ('swap_info_struct', 'prio'),
+                             ('swap_info_struct', 'swap_map')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'getrusage', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'setitimer', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'ioprio_get', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'vfork', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'prctl', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'move_pages', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'setpriority', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'clone', 'reason': set([('task_struct', 'mm')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mapping')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'mm')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mapping')])}],
+ 'swapon': [{'call': 'mq_unlink', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'swapoff',
+             'reason': set([('inode', 'i_flags'),
+                            ('swap_info_struct', 'bdev'),
+                            ('swap_info_struct', 'flags'),
+                            ('swap_info_struct', 'percpu_cluster'),
+                            ('swap_info_struct', 'type')])},
+            {'call': 'fchmod', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'memfd_create', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'readlinkat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'fchown', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('inode', 'i_flags')])},
+            {'call': 'uselib', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'fchmodat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('inode', 'i_flags')])},
+            {'call': 'ftruncate', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'ioctl', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'linkat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'unlink', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'faccessat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'fchownat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_notify', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'sendfile', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'unlinkat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'sendfile64', 'reason': set([('inode', 'i_flags')])}],
+ 'symlinkat': [{'call': 'sysfs',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'mq_unlink',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapoff',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'openat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'uselib',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'renameat2',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'quotactl',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'acct',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'unlink',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'rmdir',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapon',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'mq_open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'unlinkat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])}],
+ 'sync_file_range': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                     {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'read', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                     {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                     {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                     {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockname',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                     {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'old_readdir',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getpeername',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64v2',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                     {'call': 'copy_file_range',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                     {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'write', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'syncfs': [{'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'flock', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'sysfs': [{'call': 'mq_unlink', 'reason': set([('filename', 'name')])},
+           {'call': 'swapoff', 'reason': set([('filename', 'name')])},
+           {'call': 'openat', 'reason': set([('filename', 'name')])},
+           {'call': 'uselib', 'reason': set([('filename', 'name')])},
+           {'call': 'renameat2', 'reason': set([('filename', 'name')])},
+           {'call': 'symlinkat', 'reason': set([('filename', 'name')])},
+           {'call': 'quotactl', 'reason': set([('filename', 'name')])},
+           {'call': 'acct', 'reason': set([('filename', 'name')])},
+           {'call': 'open', 'reason': set([('filename', 'name')])},
+           {'call': 'unlink', 'reason': set([('filename', 'name')])},
+           {'call': 'rmdir', 'reason': set([('filename', 'name')])},
+           {'call': 'swapon', 'reason': set([('filename', 'name')])},
+           {'call': 'mq_open', 'reason': set([('filename', 'name')])},
+           {'call': 'unlinkat', 'reason': set([('filename', 'name')])}],
+ 'sysinfo': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_unlink', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setparam',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchmod', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'memfd_create',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'readlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'io_getevents',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchown', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'utime', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'semtimedop',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'settimeofday',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'timerfd_gettime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sigaltstack',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setattr',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'migrate_pages',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'inotify_add_watch',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'timer_settime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ftruncate', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'timer_gettime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ioctl', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'perf_event_open',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'futimesat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'select', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getpriority',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'nanosleep', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'mq_getsetattr',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'faccessat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'get_robust_list',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'epoll_wait', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_getattr',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fstat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'timerfd_settime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setpriority',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_notify', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sendfile', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'newfstat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'clock_nanosleep',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_getparam',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sendfile64', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ppoll', 'reason': set([('timespec', 'tv_nsec')])}],
+ 'syslog': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setparam',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semtimedop', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'perf_event_open',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'get_robust_list',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getparam',
+             'reason': set([('mm_segment_t', 'seg')])}],
+ 'tee': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+         {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+         {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+         {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+         {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+         {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+         {'call': 'writev', 'reason': set([('fd', 'flags')])},
+         {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+         {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+         {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+         {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+         {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+         {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+         {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+         {'call': 'read', 'reason': set([('fd', 'flags')])},
+         {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+         {'call': 'utime', 'reason': set([('fd', 'flags')])},
+         {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+         {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+         {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+         {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+         {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+         {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+         {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+         {'call': 'connect', 'reason': set([('fd', 'flags')])},
+         {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+         {'call': 'epoll_ctl',
+          'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+         {'call': 'flock',
+          'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+         {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+         {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+         {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+         {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+         {'call': 'accept4',
+          'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+         {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+         {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+         {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+         {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+         {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+         {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+         {'call': 'splice', 'reason': set([('fd', 'flags')])},
+         {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+         {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+         {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+         {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+         {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+         {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+         {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+         {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+         {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+         {'call': 'perf_event_open',
+          'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+         {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+         {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+         {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+         {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+         {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+         {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+         {'call': 'open', 'reason': set([('file', 'f_mode')])},
+         {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+         {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+         {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+         {'call': 'listen', 'reason': set([('fd', 'flags')])},
+         {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+         {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+         {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+         {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+         {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+         {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+         {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+         {'call': 'readv', 'reason': set([('fd', 'flags')])},
+         {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+         {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+         {'call': 'write', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+         {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+         {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])},
+         {'call': 'bind', 'reason': set([('fd', 'flags')])},
+         {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'tgkill': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'cred')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'cred')])}],
+ 'timer_create': [{'call': 'clock_getres',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'timer_delete',
+                   'reason': set([('k_clock', 'timer_create'),
+                                  ('k_itimer', 'it_pid')])},
+                  {'call': 'clock_gettime',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'timer_settime',
+                   'reason': set([('k_clock', 'timer_create'),
+                                  ('k_itimer', 'it_pid')])},
+                  {'call': 'timer_gettime',
+                   'reason': set([('k_clock', 'timer_create'),
+                                  ('k_itimer', 'it_pid')])},
+                  {'call': 'clock_settime',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'timer_getoverrun',
+                   'reason': set([('k_itimer', 'it_pid')])},
+                  {'call': 'clock_nanosleep',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'clock_adjtime',
+                   'reason': set([('k_clock', 'timer_create')])}],
+ 'timer_delete': [{'call': 'keyctl',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'rt_sigtimedwait',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'msgrcv',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'kill',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'clock_getres',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'sched_getaffinity',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_setparam',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'ioprio_set',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'getppid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'capget',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_setaffinity',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'signal',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'semtimedop',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'umount',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'timer_create',
+                   'reason': set([('k_clock', 'timer_del'),
+                                  ('k_itimer', 'it_pid'),
+                                  ('k_itimer', 'it_signal'),
+                                  ('k_itimer', 'sigq')])},
+                  {'call': 'clock_gettime',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'sched_rr_get_interval',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'rt_sigprocmask',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setsid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sigaltstack',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_setattr',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'migrate_pages',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'getitimer',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setpgid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'timer_settime',
+                   'reason': set([('k_clock', 'timer_del'),
+                                  ('k_itimer', 'it_pid'),
+                                  ('k_itimer', 'it_signal'),
+                                  ('k_itimer', 'sigq')])},
+                  {'call': 'timer_gettime',
+                   'reason': set([('k_clock', 'timer_del'),
+                                  ('k_itimer', 'it_pid'),
+                                  ('k_itimer', 'it_signal'),
+                                  ('k_itimer', 'sigq')])},
+                  {'call': 'getsid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'prlimit64',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'rt_sigaction',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'getpgid',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'clock_settime',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'getpriority',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sigaction',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setns',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'fork',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'get_robust_list',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_getscheduler',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'ptrace',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_getattr',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'getrusage',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'sched_setscheduler',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setitimer',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'ioprio_get',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'vfork',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'prctl',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'move_pages',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'setpriority',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'timer_getoverrun',
+                   'reason': set([('k_itimer', 'it_pid'),
+                                  ('k_itimer', 'it_signal'),
+                                  ('k_itimer', 'sigq')])},
+                  {'call': 'clone',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'clock_nanosleep',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'sched_getparam',
+                   'reason': set([('task_struct', 'signal')])},
+                  {'call': 'clock_adjtime',
+                   'reason': set([('k_clock', 'timer_del')])}],
+ 'timer_getoverrun': [{'call': 'keyctl',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'rt_sigtimedwait',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'msgrcv',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'kill',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'timer_delete',
+                       'reason': set([('k_itimer', 'it_signal')])},
+                      {'call': 'sched_getaffinity',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_setparam',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'ioprio_set',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getppid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'mq_timedreceive',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'capget',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_setaffinity',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'signal',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'semtimedop',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'umount',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'timer_create',
+                       'reason': set([('k_itimer', 'it_signal')])},
+                      {'call': 'sched_rr_get_interval',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'rt_sigprocmask',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setsid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sigaltstack',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_setattr',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'migrate_pages',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getitimer',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setpgid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'timer_settime',
+                       'reason': set([('k_itimer', 'it_signal')])},
+                      {'call': 'timer_gettime',
+                       'reason': set([('k_itimer', 'it_signal')])},
+                      {'call': 'getsid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'prlimit64',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'perf_event_open',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'rt_sigaction',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getpgid',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getpriority',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sigaction',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setns',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'fork',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'get_robust_list',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'mq_timedsend',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_getscheduler',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'ptrace',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_getattr',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'getrusage',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_setscheduler',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setitimer',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'ioprio_get',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'vfork',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'prctl',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'move_pages',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'setpriority',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'clone',
+                       'reason': set([('task_struct', 'signal')])},
+                      {'call': 'sched_getparam',
+                       'reason': set([('task_struct', 'signal')])}],
+ 'timer_gettime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'timer_get')])}],
+ 'timer_settime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'timer_set')])}],
+ 'timerfd_create': [{'call': 'timerfd_gettime',
+                     'reason': set([('timerfd_ctx', 'clockid')])},
+                    {'call': 'timerfd_settime',
+                     'reason': set([('timerfd_ctx', 'clockid')])}],
+ 'timerfd_gettime': [{'call': 'timerfd_settime',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])},
+                     {'call': 'timerfd_create',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])}],
+ 'timerfd_settime': [{'call': 'timerfd_gettime',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])},
+                     {'call': 'timerfd_create',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])}],
+ 'tkill': [{'call': 'keyctl', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'msgrcv', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'ioprio_set', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'getppid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'capget', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'signal', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'semtimedop', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'umount', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'setsid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sigaltstack', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'getitimer', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'setpgid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'getsid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'prlimit64', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'rt_sigaction', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'getpgid', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'getpriority', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sigaction', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'mq_timedsend', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'ptrace', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'getrusage', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'cred')])},
+           {'call': 'setitimer', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'ioprio_get', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'move_pages', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'setpriority', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'cred')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'cred')])}],
+ 'umount': [{'call': 'syncfs', 'reason': set([('super_block', 's_flags')])},
+            {'call': 'keyctl', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'eventfd2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_unlink',
+             'reason': set([('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'swapoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'pivot_root',
+             'reason': set([('mount', 'mnt_ns'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'memfd_create',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'dup3',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+            {'call': 'unshare',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'epoll_create1',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'flock',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'openat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'lookup_dcookie',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'uselib',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'accept4',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'socketpair',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'getcwd',
+             'reason': set([('mount', 'mnt_ns'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'shmat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'socket',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pipe2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('task_struct', 'flags')])},
+            {'call': 'shmdt',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'quotactl',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('super_block', 's_flags')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'acct',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'dup',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setns',
+             'reason': set([('nsproxy', 'mnt_ns'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('task_struct', 'flags')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'shmctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'swapon',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('super_block', 's_flags')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'mq_open',
+             'reason': set([('path', 'dentry'),
+                            ('path', 'mnt'),
+                            ('vfsmount', 'mnt_flags'),
+                            ('vfsmount', 'mnt_root')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'uname': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getrusage',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'move_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'personality')])}],
+ 'unlink': [{'call': 'eventfd2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_unlink', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'swapoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'pivot_root',
+             'reason': set([('dentry', 'd_inode'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'memfd_create',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'dup3',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'unshare',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mkdirat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'epoll_create1',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'flock',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'openat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'lookup_dcookie',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'uselib',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'renameat2', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'accept4',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'socketpair',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'getcwd',
+             'reason': set([('dentry', 'd_inode'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'ftruncate', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'shmat',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mknodat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'socket',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'symlinkat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'pipe2',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'perf_event_open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'linkat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'shmdt',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'quotactl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'acct',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'open',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'rmdir', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'dup',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'setns',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'shmctl',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'swapon',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+            {'call': 'mq_open',
+             'reason': set([('dentry', 'd_inode'),
+                            ('path', 'dentry'),
+                            ('path', 'mnt')])},
+            {'call': 'unlinkat', 'reason': set([('dentry', 'd_inode')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'unlinkat': [{'call': 'eventfd2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mq_unlink', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'swapoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'pivot_root',
+               'reason': set([('dentry', 'd_inode'),
+                              ('path', 'dentry'),
+                              ('path', 'mnt')])},
+              {'call': 'memfd_create',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'dup3',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'unshare',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mkdirat', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'epoll_create1',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'flock',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'openat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'lookup_dcookie',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'uselib',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'renameat2', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'accept4',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'socketpair',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'getcwd',
+               'reason': set([('dentry', 'd_inode'),
+                              ('path', 'dentry'),
+                              ('path', 'mnt')])},
+              {'call': 'ftruncate', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'shmat',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mknodat', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'socket',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'symlinkat', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'pipe2',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'perf_event_open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'linkat', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'shmdt',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'quotactl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'acct',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'open',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'unlink', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'rmdir', 'reason': set([('dentry', 'd_inode')])},
+              {'call': 'dup',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'setns',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'shmctl',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'swapon',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mmap_pgoff',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])},
+              {'call': 'mq_open',
+               'reason': set([('dentry', 'd_inode'),
+                              ('path', 'dentry'),
+                              ('path', 'mnt')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('path', 'dentry'), ('path', 'mnt')])}],
+ 'uselib': [{'call': 'syncfs', 'reason': set([('super_block', 's_iflags')])},
+            {'call': 'mq_unlink', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'pivot_root',
+             'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'ustat', 'reason': set([('super_block', 's_iflags')])},
+            {'call': 'umount',
+             'reason': set([('super_block', 's_iflags'),
+                            ('vfsmount', 'mnt_flags')])},
+            {'call': 'getcwd', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'quotactl',
+             'reason': set([('super_block', 's_iflags')])},
+            {'call': 'acct', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'swapon', 'reason': set([('super_block', 's_iflags')])},
+            {'call': 'mq_open', 'reason': set([('vfsmount', 'mnt_flags')])}],
+ 'ustat': [{'call': 'syncfs', 'reason': set([('super_block', 's_root')])},
+           {'call': 'umount', 'reason': set([('super_block', 's_root')])},
+           {'call': 'quotactl', 'reason': set([('super_block', 's_root')])},
+           {'call': 'swapon', 'reason': set([('super_block', 's_root')])}],
+ 'utime': [{'call': 'rt_sigtimedwait',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_unlink', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fchmod', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'memfd_create', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'readlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'io_getevents', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fchown', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'semtimedop', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'settimeofday', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timerfd_gettime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timer_settime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'ftruncate', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timer_gettime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'ioctl', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'futimesat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'select', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'nanosleep', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'faccessat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_timedsend', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'epoll_wait', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fstat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timerfd_settime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_notify', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'sendfile', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'newfstat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'clock_nanosleep',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'sendfile64', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'ppoll', 'reason': set([('timespec', 'tv_nsec')])}],
+ 'utimensat': [{'call': 'rt_sigtimedwait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_unlink',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchmod', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'memfd_create',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'readlinkat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'io_getevents',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchown', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'utime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'semtimedop',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'settimeofday',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timer_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ftruncate',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timer_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ioctl', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'futimesat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'select', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'faccessat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'epoll_wait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fstat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_notify',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'newfstat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'clock_nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile64',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ppoll', 'reason': set([('timespec', 'tv_nsec')])}],
+ 'vmsplice': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+              {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+              {'call': 'writev', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+              {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'read', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+              {'call': 'utime', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+              {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'tee', 'reason': set([('fd', 'flags')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'connect', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+              {'call': 'splice', 'reason': set([('fd', 'flags')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+              {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+              {'call': 'listen', 'reason': set([('fd', 'flags')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+              {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'readv', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+              {'call': 'write', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'bind', 'reason': set([('fd', 'flags')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'write': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'flock', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}]}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies.json b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies.json
new file mode 100644
index 0000000000..4f14d39f1f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies.json
@@ -0,0 +1 @@
+{"lseek": ["epoll_ctl", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "flistxattr", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "syncfs": ["lseek", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "epoll_ctl": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_create1", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "rt_sigtimedwait": ["clone", "rt_sigaction", "iopl", "msgrcv", "rt_sigqueueinfo", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "tgkill", "sched_getparam", "getpriority", "rt_sigprocmask", "rt_tgsigqueueinfo", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "tkill", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "timer_create", "perf_event_open", "ioprio_get", "vfork", "rt_sigreturn", "ptrace"], "vmsplice": ["lseek", "syncfs", "flistxattr", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "msync", "epoll_wait", "utimensat", "ftruncate", "fadvise64_64", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "msgrcv": ["mq_timedsend", "msgsnd", "mq_timedreceive"], "uname": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "personality", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "io_getevents": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "io_destroy", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "io_setup", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "io_submit", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "io_cancel", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "swapoff": ["swapon"], "newlstat": ["newstat", "newfstat", "newfstatat"], "pkey_alloc": ["get_mempolicy", "migrate_pages", "move_pages", "remap_file_pages", "io_setup", "msync", "shmdt", "getrusage", "modify_ldt", "io_destroy", "pkey_free", "brk", "mremap", "io_getevents", "swapoff", "prctl", "io_cancel", "mincore", "mbind"], "readahead": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "msync", "epoll_wait", "utimensat", "ftruncate", "fadvise64_64", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "newfstatat": ["newstat", "newlstat", "newfstat"], "preadv": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "getdents": ["lseek", "syncfs", "flistxattr", "rt_sigtimedwait", "iopl", "msgrcv", "kill", "readahead", "preadv", "sched_getaffinity", "writev", "pwritev2", "fchmod", "signalfd4", "epoll_wait", "ioprio_set", "read", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "fsync", "bpf", "signal", "semtimedop", "umount", "recvfrom", "old_readdir", "sendto", "fsetxattr", "tee", "sync_file_range", "connect", "getsockname", "flock", "pwritev", "rt_sigprocmask", "accept4", "fremovexattr", "setsid", "sigaltstack", "ioperm", "inotify_rm_watch", "fstatfs64", "fcntl", "migrate_pages", "getitimer", "setpgid", "keyctl", "inotify_add_watch", "preadv2", "fchdir", "ioprio_get", "getpeername", "sigaction", "getsid", "setsockopt", "getpriority", "prlimit64", "pwrite64", "perf_event_open", "vfork", "clone", "epoll_ctl", "pwritev64v2", "splice", "rt_sigaction", "getpgid", "sched_rr_get_interval", "getsockopt", "sched_setparam", "mq_getsetattr", "fdatasync", "setns", "listen", "fork", "shutdown", "get_robust_list", "futimesat", "mq_timedsend", "sched_getscheduler", "fgetxattr", "ptrace", "vmsplice", "fcntl64", "fallocate", "sched_getattr", "getrusage", "sched_setscheduler", "utimensat", "bind", "ftruncate", "fadvise64_64", "llseek", "getdents64", "pread64", "preadv64v2", "readv", "prctl", "move_pages", "copy_file_range", "fstatfs", "sched_getparam", "write", "setpriority", "mq_notify", "sendfile", "preadv64", "pwritev64", "ioctl", "setitimer", "sendfile64"], "timer_delete": ["clock_gettime", "clock_adjtime", "timer_settime", "timer_create", "timer_gettime", "clock_nanosleep", "clock_settime", "clock_getres"], "pwritev2": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "fchmod": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "pivot_root": ["mq_unlink", "getcwd", "mq_open", "umount", "acct"], "signalfd4": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "epoll_wait": ["lseek", "syncfs", "flistxattr", "rt_sigtimedwait", "iopl", "msgrcv", "kill", "readahead", "preadv", "getdents", "sched_getaffinity", "writev", "pwritev2", "fchmod", "signalfd4", "ioprio_set", "read", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "fsync", "bpf", "signal", "semtimedop", "umount", "recvfrom", "old_readdir", "sendto", "fsetxattr", "tee", "sync_file_range", "connect", "getsockname", "flock", "pwritev", "rt_sigprocmask", "accept4", "fremovexattr", "setsid", "sigaltstack", "ioperm", "inotify_rm_watch", "fstatfs64", "fcntl", "migrate_pages", "getitimer", "setpgid", "keyctl", "inotify_add_watch", "preadv2", "fchdir", "ioprio_get", "getpeername", "sigaction", "getsid", "setsockopt", "getpriority", "prlimit64", "pwrite64", "perf_event_open", "vfork", "clone", "epoll_ctl", "pwritev64v2", "splice", "rt_sigaction", "getpgid", "sched_rr_get_interval", "getsockopt", "sched_setparam", "mq_getsetattr", "fdatasync", "setns", "listen", "fork", "shutdown", "get_robust_list", "futimesat", "mq_timedsend", "sched_getscheduler", "fgetxattr", "ptrace", "vmsplice", "fcntl64", "fallocate", "sched_getattr", "getrusage", "sched_setscheduler", "utimensat", "bind", "ftruncate", "fadvise64_64", "llseek", "getdents64", "pread64", "preadv64v2", "readv", "prctl", "move_pages", "copy_file_range", "fstatfs", "sched_getparam", "write", "setpriority", "mq_notify", "sendfile", "preadv64", "pwritev64", "ioctl", "setitimer", "sendfile64"], "fstat": ["stat", "lstat"], "setgroups16": ["setgroups"], "delete_module": ["init_module", "finit_module"], "remap_file_pages": ["get_mempolicy", "munlockall", "msync", "madvise", "mprotect", "shmdt", "mremap", "munlock", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "dup3": ["unshare", "select", "dup2"], "read": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "mq_timedsend", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "llseek", "pread64"], "preadv64": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "fchown": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "ioperm": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "mq_timedreceive": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "msgrcv", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "mq_getsetattr", "dup", "memfd_create", "socketpair", "mq_notify", "remap_file_pages", "dup3", "mq_timedsend", "openat", "mq_open", "shmctl", "msgsnd", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "setns", "pipe2", "eventfd2", "perf_event_open"], "utime": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "fadvise64_64", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "pselect6", "uselib", "nanosleep", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "timerfd_settime", "sendfile64", "ftruncate", "ppoll"], "sched_setaffinity": ["setuid", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "clone", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "setitimer", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "bpf": ["clone", "epoll_ctl", "shmdt", "rt_sigaction", "epoll_create1", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "acct", "flock", "open", "getitimer", "sched_getparam", "getpriority", "uselib", "swapon", "rt_sigprocmask", "accept4", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "memfd_create", "ioprio_set", "dup", "fork", "migrate_pages", "get_robust_list", "remap_file_pages", "dup3", "setpgid", "mq_timedsend", "openat", "keyctl", "getppid", "sched_getscheduler", "mq_open", "sched_setattr", "mq_timedreceive", "shmctl", "move_pages", "capget", "sigaction", "getsid", "msync", "shmat", "sched_setaffinity", "socket", "open_by_handle_at", "setns", "signal", "pipe2", "sched_getattr", "semtimedop", "umount", "socketpair", "eventfd2", "sched_setscheduler", "prlimit64", "setitimer", "perf_event_open", "ioprio_get", "mmap_pgoff", "vfork", "ptrace"], "newstat": ["newlstat", "newfstat", "newfstatat"], "semtimedop": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "semctl", "mq_unlink", "fchownat", "fadvise64_64", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "pselect6", "uselib", "nanosleep", "msgctl", "mq_getsetattr", "faccessat", "fchmod", "msgrcv", "memfd_create", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "mq_timedreceive", "shmctl", "timer_gettime", "msgsnd", "unlink", "swapon", "unlinkat", "utime", "shmat", "readlinkat", "epoll_wait", "timerfd_gettime", "futex", "timerfd_settime", "sendfile64", "ftruncate", "ppoll", "stime"], "umount": ["setuid", "syncfs", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "mq_unlink", "getpgid", "kill", "fadvise64_64", "sched_rr_get_interval", "prctl", "acct", "clone", "sched_getparam", "getpriority", "swapon", "rt_sigprocmask", "quotactl", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "pivot_root", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "getcwd", "keyctl", "getppid", "sched_getscheduler", "mq_open", "mq_timedreceive", "move_pages", "capget", "sigaction", "getsid", "sched_setaffinity", "ustat", "setitimer", "signal", "setreuid", "sched_getattr", "semtimedop", "getrusage", "sched_setscheduler", "prlimit64", "setresuid", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "recvfrom": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "mq_getsetattr", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "old_readdir": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "sendfile64", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "settimeofday": ["wait4", "clock_adjtime", "getitimer", "setitimer", "waitid", "adjtimex", "getrusage", "alarm", "select", "ppoll"], "timer_create": ["clock_gettime", "clock_adjtime", "timer_delete", "timer_settime", "timer_gettime", "clock_nanosleep", "clock_settime", "clock_getres"], "sendto": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "swapoff", "acct", "flock", "open", "uselib", "accept4", "mq_getsetattr", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "mkdirat": ["syncfs", "quotactl", "ustat", "umount", "fadvise64_64", "swapon"], "newuname": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "personality", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "olduname": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "personality", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "tee": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "msync", "epoll_wait", "utimensat", "ftruncate", "fadvise64_64", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "semctl": ["semtimedop"], "syslog": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "rt_sigqueueinfo": ["tgkill", "rt_sigtimedwait", "rt_sigreturn", "rt_tgsigqueueinfo", "tkill", "kill", "timer_create"], "sync_file_range": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "fadvise64_64": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "setsockopt", "tee", "mq_timedreceive", "mq_unlink", "fchownat", "pread64", "fsetxattr", "swapoff", "flock", "writev", "readahead", "bind", "preadv", "getsockopt", "getdents", "uselib", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "faccessat", "fchmod", "pwritev", "linkat", "sendfile64", "inotify_rm_watch", "signalfd4", "memfd_create", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "fchmodat", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "unlink", "swapon", "fdatasync", "unlinkat", "utime", "splice", "readlinkat", "fgetxattr", "readv", "fsync", "bpf", "epoll_wait", "flistxattr", "futimesat", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "connect"], "llseek": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "pread64"], "flock": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "ustat", "fsync", "bpf", "umount", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "quotactl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "msync", "epoll_wait", "utimensat", "ftruncate", "fadvise64_64", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "pwritev": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "pselect6": ["rt_sigtimedwait", "iopl", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "sched_getaffinity", "sched_setparam", "fchmod", "memfd_create", "ioprio_set", "readlinkat", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "signal", "semtimedop", "umount", "linkat", "timerfd_gettime", "fchownat", "fadvise64_64", "uselib", "rt_sigprocmask", "inotify_add_watch", "setsid", "sigaltstack", "ioperm", "settimeofday", "migrate_pages", "getitimer", "fchmodat", "setpgid", "keyctl", "timer_settime", "stime", "ftruncate", "timer_gettime", "sigaction", "getsid", "futimesat", "prlimit64", "perf_event_open", "rt_sigaction", "getpgid", "sched_rr_get_interval", "poll", "select", "unlink", "getpriority", "nanosleep", "mq_getsetattr", "faccessat", "setns", "fork", "move_pages", "mq_timedsend", "sched_getscheduler", "ptrace", "swapon", "epoll_wait", "sched_getattr", "getrusage", "timerfd_settime", "sched_setscheduler", "ioprio_get", "vfork", "prctl", "get_robust_list", "sched_getparam", "ppoll", "setpriority", "mq_notify", "sendfile", "clone", "ioctl", "clock_nanosleep", "unlinkat", "setitimer", "futex", "recvmmsg", "sendfile64"], "uselib": ["syncfs", "quotactl", "getcwd", "ustat", "umount", "mq_unlink", "fadvise64_64", "acct", "mq_open", "pivot_root", "swapon"], "sysfs": ["swapon", "open", "uselib", "openat", "quotactl", "mq_open", "mq_unlink", "symlinkat", "rmdir", "swapoff", "acct", "unlink", "renameat2", "unlinkat"], "msgctl": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "mq_unlink", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "msgsnd", "shmget", "sched_getparam", "getpriority", "rt_sigprocmask", "setpgid", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "semctl", "fork", "migrate_pages", "get_robust_list", "getitimer", "msgget", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_open", "sched_setattr", "mq_timedreceive", "shmctl", "capget", "sigaction", "getsid", "shmat", "sched_setaffinity", "semget", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "fremovexattr": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "copy_file_range", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "writev", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "clock_adjtime": ["clock_gettime", "timer_delete", "timer_settime", "timer_create", "timer_gettime", "clock_nanosleep", "clock_settime", "clock_getres"], "setsid": ["exit_group", "timer_create"], "timerfd_create": ["timerfd_settime", "timerfd_gettime"], "set_trip_temp": ["get_trip_temp", "get_curr_temp"], "sched_setattr": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "inotify_rm_watch": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "fdatasync", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fallocate", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "renameat2": ["quotactl", "swapon", "uselib", "openat", "sysfs", "mq_open", "mq_unlink", "symlinkat", "rmdir", "swapoff", "acct", "unlink", "open", "unlinkat"], "keyctl": ["rt_sigaction", "rt_sigtimedwait", "msgrcv", "request_key", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "clone", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "setrlimit": ["prlimit64", "getrlimit", "old_getrlimit"], "fcntl": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "msync", "epoll_wait", "utimensat", "ftruncate", "fadvise64_64", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "migrate_pages": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "getitimer": ["setitimer", "exit_group", "timer_create"], "setpgid": ["setuid", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "clone", "sched_getparam", "exit_group", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "timer_create", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "init_module": ["delete_module", "finit_module"], "inotify_add_watch": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "futimesat", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "preadv2": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "timer_settime": ["clock_gettime", "clock_adjtime", "timer_delete", "timer_create", "timer_gettime", "clock_nanosleep", "clock_settime", "clock_getres"], "fchdir": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "splice", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "mq_timedsend", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "llseek", "pread64"], "timer_gettime": ["clock_gettime", "clock_adjtime", "timer_delete", "timer_settime", "timer_create", "clock_nanosleep", "clock_settime", "clock_getres"], "msgsnd": ["shmat", "shmget", "msgget", "semget", "msgctl", "semtimedop", "semctl", "mq_unlink", "msgrcv", "shmctl", "mq_open", "setns"], "sysinfo": ["rt_sigtimedwait", "iopl", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "sched_getaffinity", "sched_setparam", "fchmod", "memfd_create", "ioprio_set", "readlinkat", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "signal", "semtimedop", "umount", "linkat", "timerfd_gettime", "fchownat", "fadvise64_64", "pselect6", "uselib", "rt_sigprocmask", "inotify_add_watch", "setsid", "sigaltstack", "ioperm", "settimeofday", "migrate_pages", "getitimer", "fchmodat", "setpgid", "keyctl", "timer_settime", "stime", "ftruncate", "timer_gettime", "sigaction", "getsid", "futimesat", "prlimit64", "perf_event_open", "rt_sigaction", "getpgid", "sched_rr_get_interval", "poll", "select", "unlink", "getpriority", "nanosleep", "mq_getsetattr", "faccessat", "setns", "fork", "move_pages", "mq_timedsend", "sched_getscheduler", "ptrace", "swapon", "epoll_wait", "sched_getattr", "getrusage", "timerfd_settime", "sched_setscheduler", "ioprio_get", "vfork", "prctl", "get_robust_list", "sched_getparam", "ppoll", "setpriority", "mq_notify", "sendfile", "clone", "ioctl", "clock_nanosleep", "unlinkat", "setitimer", "futex", "recvmmsg", "sendfile64"], "mknodat": ["syncfs", "quotactl", "ustat", "umount", "fadvise64_64", "swapon"], "setsockopt": ["accept4"], "munlockall": ["get_mempolicy", "remap_file_pages", "madvise", "mprotect", "shmdt", "mremap", "munlock", "msync", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "msync": ["get_mempolicy", "munlockall", "remap_file_pages", "madvise", "mprotect", "shmdt", "mremap", "munlock", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "ioctl": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "fgetxattr", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "prlimit64": ["old_getrlimit", "setrlimit"], "set_mempolicy": ["get_mempolicy", "mbind"], "pwrite64": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "msync", "epoll_wait", "utimensat", "ftruncate", "fadvise64_64", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "perf_event_open": ["lseek", "syncfs", "flistxattr", "rt_sigtimedwait", "iopl", "msgrcv", "kill", "readahead", "preadv", "getdents", "sched_getaffinity", "writev", "pwritev2", "fchmod", "signalfd4", "epoll_wait", "ioprio_set", "read", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "fsync", "bpf", "signal", "setreuid", "semtimedop", "umount", "recvfrom", "old_readdir", "sendto", "fsetxattr", "tee", "sync_file_range", "connect", "getsockname", "flock", "pwritev", "rt_sigprocmask", "accept4", "fremovexattr", "setsid", "sigaltstack", "ioperm", "inotify_rm_watch", "fstatfs64", "setresuid", "fcntl", "migrate_pages", "getitimer", "setpgid", "keyctl", "inotify_add_watch", "preadv2", "fchdir", "ioprio_get", "getpeername", "sigaction", "getsid", "setsockopt", "prlimit64", "pwrite64", "vfork", "clone", "epoll_ctl", "pwritev64v2", "sched_setparam", "rt_sigaction", "getpgid", "sched_rr_get_interval", "getsockopt", "getpriority", "mq_getsetattr", "fdatasync", "setns", "listen", "fork", "shutdown", "get_robust_list", "futimesat", "mq_timedsend", "sched_getscheduler", "fgetxattr", "ptrace", "vmsplice", "fcntl64", "fallocate", "splice", "sched_getattr", "getrusage", "sched_setscheduler", "utimensat", "bind", "ftruncate", "fadvise64_64", "setuid", "llseek", "getdents64", "pread64", "preadv64v2", "readv", "prctl", "move_pages", "copy_file_range", "fstatfs", "sched_getparam", "write", "setpriority", "mq_notify", "sendfile", "preadv64", "pwritev64", "ioctl", "setitimer", "sendfile64"], "lstat": ["stat", "fstat"], "flistxattr": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "rt_tgsigqueueinfo": ["tgkill", "rt_sigtimedwait", "rt_sigreturn", "tkill", "rt_sigqueueinfo", "kill", "timer_create"], "pwritev64v2": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "splice": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "msync", "epoll_wait", "utimensat", "ftruncate", "fadvise64_64", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "symlinkat": ["quotactl", "swapon", "open", "uselib", "openat", "sysfs", "mq_open", "mq_unlink", "rmdir", "swapoff", "acct", "unlink", "renameat2", "unlinkat"], "brk": ["io_setup", "mprotect", "mremap", "io_destroy", "mbind", "io_getevents", "swapoff", "prctl", "modify_ldt", "shmdt", "munlock", "mincore", "get_mempolicy", "migrate_pages", "move_pages", "remap_file_pages", "io_cancel", "pkey_mprotect", "munlockall", "msync", "madvise", "getrusage", "mlockall"], "fsetxattr": ["lseek", "syncfs", "pwritev64v2", "splice", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "getsockname", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "mq_timedsend", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "llseek", "pread64"], "acct": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "poll": ["ppoll"], "clock_settime": ["clock_gettime", "clock_adjtime", "timer_delete", "timer_settime", "timer_create", "timer_gettime", "clock_nanosleep", "clock_getres"], "select": ["rt_sigtimedwait", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "sched_getaffinity", "sched_setparam", "fchmod", "memfd_create", "ioprio_set", "personality", "readlinkat", "getppid", "fchown", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "signal", "semtimedop", "umount", "linkat", "timerfd_gettime", "fchownat", "fadvise64_64", "pselect6", "uselib", "rt_sigprocmask", "inotify_add_watch", "setsid", "sigaltstack", "sched_setattr", "settimeofday", "migrate_pages", "getitimer", "fchmodat", "setpgid", "keyctl", "timer_settime", "stime", "ftruncate", "timer_gettime", "sigaction", "getsid", "futimesat", "prlimit64", "perf_event_open", "rt_sigaction", "getpgid", "sched_rr_get_interval", "poll", "unlink", "getpriority", "nanosleep", "mq_getsetattr", "faccessat", "setns", "fork", "move_pages", "mq_timedsend", "sched_getscheduler", "ptrace", "swapon", "epoll_wait", "sched_getattr", "getrusage", "timerfd_settime", "sched_setscheduler", "ioprio_get", "vfork", "prctl", "get_robust_list", "sched_getparam", "ppoll", "setpriority", "mq_notify", "sendfile", "clone", "ioctl", "clock_nanosleep", "unlinkat", "setitimer", "futex", "recvmmsg", "sendfile64"], "getsockopt": ["accept4"], "sigaction": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "nanosleep": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "fadvise64_64", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "pselect6", "uselib", "ppoll", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "timerfd_settime", "sendfile64", "ftruncate"], "quotactl": ["ustat", "swapon", "open", "uselib", "openat", "sysfs", "syncfs", "umount", "mq_unlink", "symlinkat", "fadvise64_64", "swapoff", "mq_open", "acct", "unlink", "renameat2", "unlinkat", "rmdir"], "mq_getsetattr": ["mq_timedsend", "mq_open", "mq_timedreceive", "mq_notify"], "fallocate": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "getdents64": ["lseek", "syncfs", "flistxattr", "rt_sigtimedwait", "iopl", "msgrcv", "kill", "readahead", "preadv", "getdents", "sched_getaffinity", "writev", "pwritev2", "fchmod", "signalfd4", "epoll_wait", "ioprio_set", "read", "getppid", "fchown", "sched_setattr", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "fsync", "bpf", "signal", "semtimedop", "umount", "recvfrom", "old_readdir", "sendto", "fsetxattr", "tee", "sync_file_range", "connect", "getsockname", "flock", "pwritev", "rt_sigprocmask", "accept4", "fremovexattr", "setsid", "sigaltstack", "ioperm", "inotify_rm_watch", "fstatfs64", "fcntl", "migrate_pages", "getitimer", "setpgid", "keyctl", "inotify_add_watch", "preadv2", "fchdir", "ioprio_get", "getpeername", "sigaction", "getsid", "setsockopt", "getpriority", "prlimit64", "pwrite64", "perf_event_open", "vfork", "clone", "epoll_ctl", "pwritev64v2", "splice", "rt_sigaction", "getpgid", "sched_rr_get_interval", "getsockopt", "sched_setparam", "mq_getsetattr", "fdatasync", "setns", "listen", "fork", "shutdown", "get_robust_list", "futimesat", "mq_timedsend", "sched_getscheduler", "fgetxattr", "ptrace", "vmsplice", "fcntl64", "fallocate", "sched_getattr", "getrusage", "sched_setscheduler", "utimensat", "bind", "ftruncate", "fadvise64_64", "llseek", "pread64", "preadv64v2", "readv", "prctl", "move_pages", "copy_file_range", "fstatfs", "sched_getparam", "write", "setpriority", "mq_notify", "sendfile", "preadv64", "pwritev64", "ioctl", "setitimer", "sendfile64"], "get_mempolicy": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mbind", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "set_mempolicy", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "io_submit": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "futimesat": ["linkat", "io_getevents", "rt_sigtimedwait", "adjtimex", "mq_timedreceive", "mq_unlink", "fchownat", "fadvise64_64", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "pselect6", "uselib", "nanosleep", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "settimeofday", "mq_notify", "sendfile", "getitimer", "fchmodat", "inotify_add_watch", "mq_timedsend", "waitid", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "wait4", "readlinkat", "clock_adjtime", "epoll_wait", "alarm", "timerfd_gettime", "semtimedop", "getrusage", "futex", "timerfd_settime", "sendfile64", "setitimer", "ftruncate", "ppoll"], "mq_timedsend": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "mq_timedreceive", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "mq_getsetattr", "dup", "memfd_create", "socketpair", "mq_notify", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "setns", "pipe2", "eventfd2", "perf_event_open"], "sched_getscheduler": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "fgetxattr": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "ptrace": ["setuid", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "pause", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "sigsuspend", "getppid", "rt_sigsuspend", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "epoll_wait", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "setitimer", "perf_event_open", "ioprio_get", "clone", "vfork"], "shmctl": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "msgsnd", "sched_getparam", "getpriority", "rt_sigprocmask", "msgctl", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "semctl", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "shmat", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "fcntl64": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "connect", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "swapon", "fdatasync", "msync", "epoll_wait", "utimensat", "ftruncate", "fadvise64_64", "llseek", "getdents64", "mmap_pgoff", "pread64", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "old_getrlimit": ["prlimit64", "setrlimit"], "swapon": ["linkat", "mq_timedreceive", "mq_unlink", "fchownat", "fadvise64_64", "swapoff", "uselib", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "unlink", "unlinkat", "readlinkat", "sendfile64", "ftruncate"], "pkey_mprotect": ["clone", "rt_sigaction", "rt_sigtimedwait", "mprotect", "msgrcv", "mlockall", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getitimer", "sched_getparam", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "sched_setaffinity", "munlockall", "msync", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "madvise": ["get_mempolicy", "munlockall", "remap_file_pages", "mprotect", "shmdt", "mremap", "munlock", "msync", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "statfs": ["ustat", "fstatfs64", "fstatfs", "statfs64"], "mount": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "personality", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "sched_getattr": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "getrusage": ["exit_group", "timer_create"], "timerfd_settime": ["timerfd_gettime", "timerfd_create"], "utimensat": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "fadvise64_64", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "pselect6", "uselib", "nanosleep", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "timerfd_settime", "sendfile64", "ftruncate", "ppoll"], "ftruncate": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "mq_timedreceive", "mq_unlink", "fchownat", "fadvise64_64", "swapoff", "acct", "flock", "open", "fchmodat", "uselib", "accept4", "mq_getsetattr", "faccessat", "fchmod", "linkat", "memfd_create", "socketpair", "mq_notify", "sendfile", "remap_file_pages", "dup3", "inotify_add_watch", "mq_timedsend", "openat", "mq_open", "fchown", "dup", "ioctl", "shmctl", "unlink", "swapon", "unlinkat", "msync", "shmat", "readlinkat", "socket", "open_by_handle_at", "setns", "pipe2", "eventfd2", "sendfile64", "perf_event_open"], "io_setup": ["io_destroy", "io_submit", "io_cancel", "io_getevents"], "mprotect": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "mlockall", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getitimer", "sched_getparam", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "msync", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "mremap": ["clone", "io_getevents", "rt_sigaction", "rt_sigtimedwait", "mprotect", "msgrcv", "mlockall", "io_destroy", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "move_pages", "getitimer", "io_setup", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "modify_ldt", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "mbind", "sched_getparam", "mq_timedreceive", "ioprio_get", "io_cancel", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "msync", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "io_destroy": ["io_submit", "io_cancel", "io_setup", "io_getevents"], "pread64": ["lseek", "syncfs", "flistxattr", "vmsplice", "mq_timedreceive", "swapoff", "readahead", "preadv", "getdents", "writev", "pwritev2", "fchmod", "signalfd4", "memfd_create", "remap_file_pages", "dup3", "read", "preadv64", "fchown", "utime", "fsync", "bpf", "eventfd2", "old_readdir", "sendto", "shutdown", "epoll_create1", "tee", "fadvise64_64", "getsockname", "flock", "pwritev", "recvfrom", "uselib", "accept4", "fremovexattr", "inotify_rm_watch", "socketpair", "fcntl", "sync_file_range", "inotify_add_watch", "fstatfs64", "preadv2", "fchdir", "getpeername", "shmat", "futimesat", "socket", "pipe2", "pwrite64", "perf_event_open", "epoll_ctl", "pwritev64v2", "splice", "fsetxattr", "acct", "open", "getsockopt", "shmdt", "mq_getsetattr", "dup", "fallocate", "setns", "listen", "setsockopt", "mq_timedsend", "fgetxattr", "shmctl", "fcntl64", "swapon", "fdatasync", "msync", "epoll_wait", "utimensat", "ftruncate", "connect", "llseek", "getdents64", "mmap_pgoff", "preadv64v2", "readv", "copy_file_range", "fstatfs", "write", "mq_notify", "sendfile", "openat", "pwritev64", "mq_open", "ioctl", "open_by_handle_at", "bind", "sendfile64"], "preadv64v2": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "prctl": ["setuid", "io_getevents", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "io_destroy", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "move_pages", "clone", "getitimer", "io_setup", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "modify_ldt", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mbind", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "sched_getparam", "sched_setaffinity", "io_cancel", "msync", "setitimer", "signal", "setreuid", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "setresuid", "perf_event_open", "brk", "vfork", "ptrace"], "copy_file_range": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "write", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "fstatfs": ["statfs", "ustat", "fstatfs64", "statfs64"], "modify_ldt": ["set_thread_area", "get_thread_area"], "sched_getparam": ["clone", "rt_sigaction", "rt_sigtimedwait", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "fstatfs64": ["statfs", "ustat", "statfs64", "fstatfs"], "rt_sigreturn": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "msgrcv", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "mq_timedreceive", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "write": ["lseek", "syncfs", "pwritev64v2", "getsockname", "fstatfs", "epoll_ctl", "getdents64", "futimesat", "tee", "mq_timedreceive", "connect", "fadvise64_64", "fsetxattr", "readv", "flock", "writev", "readahead", "preadv", "getsockopt", "getdents", "fallocate", "accept4", "mq_getsetattr", "fremovexattr", "pwritev2", "fchmod", "pwritev", "sendfile64", "inotify_rm_watch", "signalfd4", "epoll_wait", "fstatfs64", "listen", "fcntl", "shutdown", "sync_file_range", "sendfile", "inotify_add_watch", "read", "pwritev64", "pwrite64", "preadv64", "fchown", "ioctl", "preadv2", "preadv64v2", "fchdir", "vmsplice", "fcntl64", "getpeername", "fdatasync", "utime", "splice", "setsockopt", "fsync", "bpf", "bind", "flistxattr", "fgetxattr", "recvfrom", "copy_file_range", "old_readdir", "utimensat", "sendto", "perf_event_open", "ftruncate", "mq_notify", "mq_timedsend", "llseek", "pread64"], "munlock": ["get_mempolicy", "munlockall", "remap_file_pages", "madvise", "mprotect", "shmdt", "mremap", "msync", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "shmdt": ["get_mempolicy", "munlockall", "remap_file_pages", "madvise", "mprotect", "mremap", "munlock", "msync", "brk", "prctl", "mlockall", "mincore", "pkey_mprotect"], "getrlimit": ["prlimit64", "old_getrlimit", "setrlimit"], "mincore": ["clone", "rt_sigaction", "rt_sigtimedwait", "mprotect", "iopl", "msgrcv", "mlockall", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "getitimer", "sched_getparam", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "sched_setattr", "mq_timedreceive", "ioprio_get", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "msync", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "mq_notify": ["tgkill", "mq_timedsend", "rt_sigtimedwait", "rt_sigreturn", "rt_tgsigqueueinfo", "mq_getsetattr", "mq_timedreceive", "tkill", "rt_sigqueueinfo", "timer_create"], "sendfile": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "stat": ["fstat", "lstat"], "newfstat": ["newstat", "newlstat", "newfstatat"], "timerfd_gettime": ["timerfd_settime", "timerfd_create"], "pwritev64": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "mq_open": ["quotactl", "swapon", "open", "uselib", "openat", "sysfs", "mq_unlink", "symlinkat", "rmdir", "swapoff", "acct", "unlink", "renameat2", "unlinkat"], "statfs64": ["statfs", "ustat", "fstatfs64", "fstatfs"], "set_thread_area": ["clone", "rt_sigaction", "rt_sigtimedwait", "iopl", "mq_timedreceive", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "prctl", "move_pages", "sched_getparam", "getpriority", "rt_sigprocmask", "sched_getaffinity", "arch_prctl", "sched_setparam", "setsid", "setpriority", "sigaltstack", "ioperm", "setns", "ioprio_set", "fork", "migrate_pages", "get_robust_list", "getitimer", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "sched_setattr", "msgrcv", "capget", "sigaction", "getsid", "sched_setaffinity", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "ioprio_get", "vfork", "ptrace"], "clock_nanosleep": ["clock_gettime", "io_getevents", "linkat", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "fadvise64_64", "sched_rr_get_interval", "swapoff", "poll", "clock_settime", "select", "clock_getres", "recvmmsg", "pselect6", "uselib", "nanosleep", "timer_delete", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "clock_adjtime", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "timerfd_settime", "sendfile64", "timer_create", "ftruncate", "ppoll"], "getgroups16": ["setgroups", "setgroups16"], "io_cancel": ["io_destroy", "io_submit", "io_setup", "io_getevents"], "setitimer": ["wait4", "clock_adjtime", "getitimer", "exit_group", "waitid", "adjtimex", "getrusage", "settimeofday", "timer_create", "alarm", "select", "ppoll"], "alarm": ["wait4", "clock_adjtime", "getitimer", "setitimer", "waitid", "adjtimex", "getrusage", "select", "ppoll", "settimeofday"], "futex": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "fadvise64_64", "sched_rr_get_interval", "swapoff", "poll", "select", "recvmmsg", "clock_nanosleep", "pselect6", "uselib", "nanosleep", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "timerfd_settime", "sendfile64", "ftruncate", "ppoll"], "recvmmsg": ["linkat", "io_getevents", "rt_sigtimedwait", "futimesat", "mq_timedreceive", "mq_unlink", "fchownat", "fadvise64_64", "sched_rr_get_interval", "swapoff", "poll", "select", "timerfd_settime", "clock_nanosleep", "pselect6", "uselib", "nanosleep", "mq_getsetattr", "faccessat", "fchmod", "memfd_create", "settimeofday", "mq_notify", "sendfile", "fchmodat", "inotify_add_watch", "mq_timedsend", "fchown", "ioctl", "timer_settime", "stime", "timer_gettime", "unlink", "swapon", "unlinkat", "utime", "readlinkat", "epoll_wait", "timerfd_gettime", "semtimedop", "futex", "recvfrom", "sendfile64", "sendto", "ftruncate", "ppoll"], "finit_module": ["delete_module", "init_module"], "sendfile64": ["epoll_ctl", "shmdt", "epoll_create1", "mmap_pgoff", "fadvise64_64", "swapoff", "acct", "flock", "open", "uselib", "accept4", "dup", "setns", "socketpair", "remap_file_pages", "dup3", "openat", "mq_open", "shmctl", "swapon", "msync", "shmat", "socket", "open_by_handle_at", "memfd_create", "pipe2", "eventfd2", "perf_event_open"], "mlockall": ["clone", "io_getevents", "rt_sigaction", "rt_sigtimedwait", "mprotect", "msgrcv", "io_destroy", "getpgid", "kill", "getrusage", "sched_rr_get_interval", "swapoff", "prctl", "move_pages", "getitimer", "io_setup", "getpriority", "rt_sigprocmask", "shmdt", "sched_getaffinity", "modify_ldt", "sched_setparam", "setsid", "setpriority", "sigaltstack", "sched_setattr", "setns", "ioprio_set", "mincore", "personality", "fork", "get_mempolicy", "migrate_pages", "get_robust_list", "remap_file_pages", "mremap", "setpgid", "mq_timedsend", "keyctl", "getppid", "sched_getscheduler", "munlock", "mbind", "sched_getparam", "mq_timedreceive", "ioprio_get", "io_cancel", "capget", "sigaction", "getsid", "pkey_mprotect", "sched_setaffinity", "munlockall", "msync", "madvise", "setitimer", "signal", "sched_getattr", "semtimedop", "umount", "sched_setscheduler", "prlimit64", "perf_event_open", "brk", "vfork", "ptrace"], "ppoll": ["rt_sigtimedwait", "msgrcv", "mq_unlink", "kill", "io_getevents", "swapoff", "sched_getaffinity", "sched_setparam", "fchmod", "memfd_create", "ioprio_set", "personality", "readlinkat", "getppid", "fchown", "mq_timedreceive", "capget", "utime", "sched_setaffinity", "signal", "semtimedop", "umount", "linkat", "timerfd_gettime", "fchownat", "fadvise64_64", "pselect6", "uselib", "rt_sigprocmask", "inotify_add_watch", "setsid", "sigaltstack", "sched_setattr", "settimeofday", "migrate_pages", "getitimer", "fchmodat", "setpgid", "keyctl", "timer_settime", "stime", "ftruncate", "timer_gettime", "sigaction", "getsid", "futimesat", "prlimit64", "perf_event_open", "rt_sigaction", "getpgid", "sched_rr_get_interval", "poll", "select", "unlink", "getpriority", "nanosleep", "mq_getsetattr", "faccessat", "setns", "fork", "move_pages", "mq_timedsend", "sched_getscheduler", "ptrace", "swapon", "epoll_wait", "sched_getattr", "getrusage", "timerfd_settime", "sched_setscheduler", "ioprio_get", "vfork", "prctl", "get_robust_list", "sched_getparam", "setpriority", "mq_notify", "sendfile", "clone", "ioctl", "clock_nanosleep", "unlinkat", "setitimer", "futex", "recvmmsg", "sendfile64"]}
\ No newline at end of file
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies.pretty b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies.pretty
new file mode 100644
index 0000000000..86f0d9a353
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies.pretty
@@ -0,0 +1,6119 @@
+{'acct': set(['accept4',
+              'dup',
+              'dup3',
+              'epoll_create1',
+              'epoll_ctl',
+              'eventfd2',
+              'fadvise64_64',
+              'flock',
+              'memfd_create',
+              'mmap_pgoff',
+              'mq_open',
+              'msync',
+              'open',
+              'open_by_handle_at',
+              'openat',
+              'perf_event_open',
+              'pipe2',
+              'remap_file_pages',
+              'setns',
+              'shmat',
+              'shmctl',
+              'shmdt',
+              'socket',
+              'socketpair',
+              'swapoff',
+              'swapon',
+              'uselib']),
+ 'alarm': set(['adjtimex',
+               'clock_adjtime',
+               'getitimer',
+               'getrusage',
+               'ppoll',
+               'select',
+               'setitimer',
+               'settimeofday',
+               'wait4',
+               'waitid']),
+ 'bpf': set(['accept4',
+             'acct',
+             'capget',
+             'clone',
+             'dup',
+             'dup3',
+             'epoll_create1',
+             'epoll_ctl',
+             'eventfd2',
+             'flock',
+             'fork',
+             'get_robust_list',
+             'getitimer',
+             'getpgid',
+             'getppid',
+             'getpriority',
+             'getrusage',
+             'getsid',
+             'ioperm',
+             'iopl',
+             'ioprio_get',
+             'ioprio_set',
+             'keyctl',
+             'kill',
+             'memfd_create',
+             'migrate_pages',
+             'mmap_pgoff',
+             'move_pages',
+             'mq_open',
+             'mq_timedreceive',
+             'mq_timedsend',
+             'msgrcv',
+             'msync',
+             'open',
+             'open_by_handle_at',
+             'openat',
+             'perf_event_open',
+             'pipe2',
+             'prctl',
+             'prlimit64',
+             'ptrace',
+             'remap_file_pages',
+             'rt_sigaction',
+             'rt_sigprocmask',
+             'rt_sigtimedwait',
+             'sched_getaffinity',
+             'sched_getattr',
+             'sched_getparam',
+             'sched_getscheduler',
+             'sched_rr_get_interval',
+             'sched_setaffinity',
+             'sched_setattr',
+             'sched_setparam',
+             'sched_setscheduler',
+             'semtimedop',
+             'setitimer',
+             'setns',
+             'setpgid',
+             'setpriority',
+             'setsid',
+             'shmat',
+             'shmctl',
+             'shmdt',
+             'sigaction',
+             'sigaltstack',
+             'signal',
+             'socket',
+             'socketpair',
+             'swapoff',
+             'swapon',
+             'umount',
+             'uselib',
+             'vfork']),
+ 'brk': set(['get_mempolicy',
+             'getrusage',
+             'io_cancel',
+             'io_destroy',
+             'io_getevents',
+             'io_setup',
+             'madvise',
+             'mbind',
+             'migrate_pages',
+             'mincore',
+             'mlockall',
+             'modify_ldt',
+             'move_pages',
+             'mprotect',
+             'mremap',
+             'msync',
+             'munlock',
+             'munlockall',
+             'pkey_mprotect',
+             'prctl',
+             'remap_file_pages',
+             'shmdt',
+             'swapoff']),
+ 'clock_adjtime': set(['clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime',
+                       'timer_settime']),
+ 'clock_nanosleep': set(['clock_adjtime',
+                         'clock_getres',
+                         'clock_gettime',
+                         'clock_settime',
+                         'epoll_wait',
+                         'faccessat',
+                         'fadvise64_64',
+                         'fchmod',
+                         'fchmodat',
+                         'fchown',
+                         'fchownat',
+                         'ftruncate',
+                         'futex',
+                         'futimesat',
+                         'inotify_add_watch',
+                         'io_getevents',
+                         'ioctl',
+                         'linkat',
+                         'memfd_create',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'mq_unlink',
+                         'nanosleep',
+                         'poll',
+                         'ppoll',
+                         'pselect6',
+                         'readlinkat',
+                         'recvmmsg',
+                         'rt_sigtimedwait',
+                         'sched_rr_get_interval',
+                         'select',
+                         'semtimedop',
+                         'sendfile',
+                         'sendfile64',
+                         'settimeofday',
+                         'stime',
+                         'swapoff',
+                         'swapon',
+                         'timer_create',
+                         'timer_delete',
+                         'timer_gettime',
+                         'timer_settime',
+                         'timerfd_gettime',
+                         'timerfd_settime',
+                         'unlink',
+                         'unlinkat',
+                         'uselib',
+                         'utime']),
+ 'clock_settime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime',
+                       'timer_settime']),
+ 'copy_file_range': set(['accept4',
+                         'bind',
+                         'bpf',
+                         'connect',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'fadvise64_64',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchown',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'flistxattr',
+                         'flock',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'getdents',
+                         'getdents64',
+                         'getpeername',
+                         'getsockname',
+                         'getsockopt',
+                         'inotify_add_watch',
+                         'inotify_rm_watch',
+                         'ioctl',
+                         'listen',
+                         'llseek',
+                         'lseek',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'old_readdir',
+                         'perf_event_open',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'read',
+                         'readahead',
+                         'readv',
+                         'recvfrom',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'setsockopt',
+                         'shutdown',
+                         'signalfd4',
+                         'splice',
+                         'sync_file_range',
+                         'syncfs',
+                         'tee',
+                         'utime',
+                         'utimensat',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'delete_module': set(['finit_module', 'init_module']),
+ 'dup3': set(['dup2', 'select', 'unshare']),
+ 'epoll_ctl': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_create1',
+                   'epoll_wait',
+                   'fadvise64_64',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'epoll_wait': set(['accept4',
+                    'bind',
+                    'bpf',
+                    'capget',
+                    'clone',
+                    'connect',
+                    'copy_file_range',
+                    'epoll_ctl',
+                    'fadvise64_64',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fork',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'get_robust_list',
+                    'getdents',
+                    'getdents64',
+                    'getitimer',
+                    'getpeername',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'ioperm',
+                    'iopl',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'keyctl',
+                    'kill',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'migrate_pages',
+                    'move_pages',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'old_readdir',
+                    'perf_event_open',
+                    'prctl',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'prlimit64',
+                    'ptrace',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'setsockopt',
+                    'shutdown',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'signalfd4',
+                    'splice',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'umount',
+                    'utime',
+                    'utimensat',
+                    'vfork',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'fadvise64_64': set(['accept4',
+                      'bind',
+                      'bpf',
+                      'connect',
+                      'copy_file_range',
+                      'epoll_ctl',
+                      'epoll_wait',
+                      'faccessat',
+                      'fallocate',
+                      'fchdir',
+                      'fchmod',
+                      'fchmodat',
+                      'fchown',
+                      'fchownat',
+                      'fcntl',
+                      'fcntl64',
+                      'fdatasync',
+                      'fgetxattr',
+                      'flistxattr',
+                      'flock',
+                      'fremovexattr',
+                      'fsetxattr',
+                      'fstatfs',
+                      'fstatfs64',
+                      'fsync',
+                      'ftruncate',
+                      'futimesat',
+                      'getdents',
+                      'getdents64',
+                      'getpeername',
+                      'getsockname',
+                      'getsockopt',
+                      'inotify_add_watch',
+                      'inotify_rm_watch',
+                      'ioctl',
+                      'linkat',
+                      'listen',
+                      'llseek',
+                      'lseek',
+                      'memfd_create',
+                      'mq_getsetattr',
+                      'mq_notify',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'mq_unlink',
+                      'old_readdir',
+                      'perf_event_open',
+                      'pread64',
+                      'preadv',
+                      'preadv2',
+                      'preadv64',
+                      'preadv64v2',
+                      'pwrite64',
+                      'pwritev',
+                      'pwritev2',
+                      'pwritev64',
+                      'pwritev64v2',
+                      'read',
+                      'readahead',
+                      'readlinkat',
+                      'readv',
+                      'recvfrom',
+                      'sendfile',
+                      'sendfile64',
+                      'sendto',
+                      'setsockopt',
+                      'shutdown',
+                      'signalfd4',
+                      'splice',
+                      'swapoff',
+                      'swapon',
+                      'sync_file_range',
+                      'syncfs',
+                      'tee',
+                      'unlink',
+                      'unlinkat',
+                      'uselib',
+                      'utime',
+                      'utimensat',
+                      'vmsplice',
+                      'write',
+                      'writev']),
+ 'fallocate': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fadvise64_64',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'fchdir': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fadvise64_64',
+                'fallocate',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'fchmod': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fadvise64_64',
+                'fallocate',
+                'fchdir',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'fchown': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fadvise64_64',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'fcntl': set(['accept4',
+               'acct',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'epoll_wait',
+               'eventfd2',
+               'fadvise64_64',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'memfd_create',
+               'mmap_pgoff',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_open',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msync',
+               'old_readdir',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'remap_file_pages',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setns',
+               'setsockopt',
+               'shmat',
+               'shmctl',
+               'shmdt',
+               'shutdown',
+               'signalfd4',
+               'socket',
+               'socketpair',
+               'splice',
+               'swapoff',
+               'swapon',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'uselib',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'fcntl64': set(['accept4',
+                 'acct',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'eventfd2',
+                 'fadvise64_64',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msync',
+                 'old_readdir',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'pread64',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'remap_file_pages',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setns',
+                 'setsockopt',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'shutdown',
+                 'signalfd4',
+                 'socket',
+                 'socketpair',
+                 'splice',
+                 'swapoff',
+                 'swapon',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'uselib',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'fgetxattr': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fadvise64_64',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'finit_module': set(['delete_module', 'init_module']),
+ 'flistxattr': set(['accept4',
+                    'bind',
+                    'bpf',
+                    'connect',
+                    'copy_file_range',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'fadvise64_64',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flock',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'getdents',
+                    'getdents64',
+                    'getpeername',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'old_readdir',
+                    'perf_event_open',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setsockopt',
+                    'shutdown',
+                    'signalfd4',
+                    'splice',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'utime',
+                    'utimensat',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'flock': set(['accept4',
+               'acct',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'dup',
+               'dup3',
+               'epoll_create1',
+               'epoll_ctl',
+               'epoll_wait',
+               'eventfd2',
+               'fadvise64_64',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'memfd_create',
+               'mmap_pgoff',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_open',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msync',
+               'old_readdir',
+               'open',
+               'open_by_handle_at',
+               'openat',
+               'perf_event_open',
+               'pipe2',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'quotactl',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'remap_file_pages',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setns',
+               'setsockopt',
+               'shmat',
+               'shmctl',
+               'shmdt',
+               'shutdown',
+               'signalfd4',
+               'socket',
+               'socketpair',
+               'splice',
+               'swapoff',
+               'swapon',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'umount',
+               'uselib',
+               'ustat',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'fremovexattr': set(['accept4',
+                      'bind',
+                      'bpf',
+                      'connect',
+                      'copy_file_range',
+                      'epoll_ctl',
+                      'epoll_wait',
+                      'fadvise64_64',
+                      'fallocate',
+                      'fchdir',
+                      'fchmod',
+                      'fchown',
+                      'fcntl',
+                      'fcntl64',
+                      'fdatasync',
+                      'fgetxattr',
+                      'flistxattr',
+                      'flock',
+                      'fsetxattr',
+                      'fstatfs',
+                      'fstatfs64',
+                      'fsync',
+                      'ftruncate',
+                      'futimesat',
+                      'getdents',
+                      'getdents64',
+                      'getpeername',
+                      'getsockname',
+                      'getsockopt',
+                      'inotify_add_watch',
+                      'inotify_rm_watch',
+                      'ioctl',
+                      'listen',
+                      'llseek',
+                      'lseek',
+                      'mq_getsetattr',
+                      'mq_notify',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'old_readdir',
+                      'perf_event_open',
+                      'pread64',
+                      'preadv',
+                      'preadv2',
+                      'preadv64',
+                      'preadv64v2',
+                      'pwrite64',
+                      'pwritev',
+                      'pwritev2',
+                      'pwritev64',
+                      'pwritev64v2',
+                      'read',
+                      'readahead',
+                      'readv',
+                      'recvfrom',
+                      'sendfile',
+                      'sendfile64',
+                      'sendto',
+                      'setsockopt',
+                      'shutdown',
+                      'signalfd4',
+                      'splice',
+                      'sync_file_range',
+                      'syncfs',
+                      'tee',
+                      'utime',
+                      'utimensat',
+                      'vmsplice',
+                      'write',
+                      'writev']),
+ 'fsetxattr': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fadvise64_64',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'signalfd4',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'fstat': set(['lstat', 'stat']),
+ 'fstatfs': set(['fstatfs64', 'statfs', 'statfs64', 'ustat']),
+ 'fstatfs64': set(['fstatfs', 'statfs', 'statfs64', 'ustat']),
+ 'ftruncate': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'faccessat',
+                   'fadvise64_64',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'flock',
+                   'inotify_add_watch',
+                   'ioctl',
+                   'linkat',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'msync',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'readlinkat',
+                   'remap_file_pages',
+                   'sendfile',
+                   'sendfile64',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'unlink',
+                   'unlinkat',
+                   'uselib']),
+ 'futex': set(['clock_nanosleep',
+               'epoll_wait',
+               'faccessat',
+               'fadvise64_64',
+               'fchmod',
+               'fchmodat',
+               'fchown',
+               'fchownat',
+               'ftruncate',
+               'futimesat',
+               'inotify_add_watch',
+               'io_getevents',
+               'ioctl',
+               'linkat',
+               'memfd_create',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mq_unlink',
+               'nanosleep',
+               'poll',
+               'ppoll',
+               'pselect6',
+               'readlinkat',
+               'recvmmsg',
+               'rt_sigtimedwait',
+               'sched_rr_get_interval',
+               'select',
+               'semtimedop',
+               'sendfile',
+               'sendfile64',
+               'settimeofday',
+               'stime',
+               'swapoff',
+               'swapon',
+               'timer_gettime',
+               'timer_settime',
+               'timerfd_gettime',
+               'timerfd_settime',
+               'unlink',
+               'unlinkat',
+               'uselib',
+               'utime']),
+ 'futimesat': set(['adjtimex',
+                   'alarm',
+                   'clock_adjtime',
+                   'clock_nanosleep',
+                   'epoll_wait',
+                   'faccessat',
+                   'fadvise64_64',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'ftruncate',
+                   'futex',
+                   'getitimer',
+                   'getrusage',
+                   'inotify_add_watch',
+                   'io_getevents',
+                   'ioctl',
+                   'linkat',
+                   'memfd_create',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'nanosleep',
+                   'poll',
+                   'ppoll',
+                   'pselect6',
+                   'readlinkat',
+                   'recvmmsg',
+                   'rt_sigtimedwait',
+                   'sched_rr_get_interval',
+                   'select',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'setitimer',
+                   'settimeofday',
+                   'stime',
+                   'swapoff',
+                   'swapon',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime',
+                   'wait4',
+                   'waitid']),
+ 'get_mempolicy': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'mbind',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'set_mempolicy',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'getdents': set(['accept4',
+                  'bind',
+                  'bpf',
+                  'capget',
+                  'clone',
+                  'connect',
+                  'copy_file_range',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'fadvise64_64',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fork',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'get_robust_list',
+                  'getdents64',
+                  'getitimer',
+                  'getpeername',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'ioperm',
+                  'iopl',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'old_readdir',
+                  'perf_event_open',
+                  'prctl',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'prlimit64',
+                  'ptrace',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'setsockopt',
+                  'shutdown',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'signalfd4',
+                  'splice',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'umount',
+                  'utime',
+                  'utimensat',
+                  'vfork',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'getdents64': set(['accept4',
+                    'bind',
+                    'bpf',
+                    'capget',
+                    'clone',
+                    'connect',
+                    'copy_file_range',
+                    'epoll_ctl',
+                    'epoll_wait',
+                    'fadvise64_64',
+                    'fallocate',
+                    'fchdir',
+                    'fchmod',
+                    'fchown',
+                    'fcntl',
+                    'fcntl64',
+                    'fdatasync',
+                    'fgetxattr',
+                    'flistxattr',
+                    'flock',
+                    'fork',
+                    'fremovexattr',
+                    'fsetxattr',
+                    'fstatfs',
+                    'fstatfs64',
+                    'fsync',
+                    'ftruncate',
+                    'futimesat',
+                    'get_robust_list',
+                    'getdents',
+                    'getitimer',
+                    'getpeername',
+                    'getpgid',
+                    'getppid',
+                    'getpriority',
+                    'getrusage',
+                    'getsid',
+                    'getsockname',
+                    'getsockopt',
+                    'inotify_add_watch',
+                    'inotify_rm_watch',
+                    'ioctl',
+                    'ioperm',
+                    'iopl',
+                    'ioprio_get',
+                    'ioprio_set',
+                    'keyctl',
+                    'kill',
+                    'listen',
+                    'llseek',
+                    'lseek',
+                    'migrate_pages',
+                    'move_pages',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'msgrcv',
+                    'old_readdir',
+                    'perf_event_open',
+                    'prctl',
+                    'pread64',
+                    'preadv',
+                    'preadv2',
+                    'preadv64',
+                    'preadv64v2',
+                    'prlimit64',
+                    'ptrace',
+                    'pwrite64',
+                    'pwritev',
+                    'pwritev2',
+                    'pwritev64',
+                    'pwritev64v2',
+                    'read',
+                    'readahead',
+                    'readv',
+                    'recvfrom',
+                    'rt_sigaction',
+                    'rt_sigprocmask',
+                    'rt_sigtimedwait',
+                    'sched_getaffinity',
+                    'sched_getattr',
+                    'sched_getparam',
+                    'sched_getscheduler',
+                    'sched_rr_get_interval',
+                    'sched_setaffinity',
+                    'sched_setattr',
+                    'sched_setparam',
+                    'sched_setscheduler',
+                    'semtimedop',
+                    'sendfile',
+                    'sendfile64',
+                    'sendto',
+                    'setitimer',
+                    'setns',
+                    'setpgid',
+                    'setpriority',
+                    'setsid',
+                    'setsockopt',
+                    'shutdown',
+                    'sigaction',
+                    'sigaltstack',
+                    'signal',
+                    'signalfd4',
+                    'splice',
+                    'sync_file_range',
+                    'syncfs',
+                    'tee',
+                    'umount',
+                    'utime',
+                    'utimensat',
+                    'vfork',
+                    'vmsplice',
+                    'write',
+                    'writev']),
+ 'getgroups16': set(['setgroups', 'setgroups16']),
+ 'getitimer': set(['exit_group', 'setitimer', 'timer_create']),
+ 'getrlimit': set(['old_getrlimit', 'prlimit64', 'setrlimit']),
+ 'getrusage': set(['exit_group', 'timer_create']),
+ 'getsockopt': set(['accept4']),
+ 'init_module': set(['delete_module', 'finit_module']),
+ 'inotify_add_watch': set(['accept4',
+                           'bind',
+                           'bpf',
+                           'connect',
+                           'copy_file_range',
+                           'epoll_ctl',
+                           'epoll_wait',
+                           'fadvise64_64',
+                           'fallocate',
+                           'fchdir',
+                           'fchmod',
+                           'fchown',
+                           'fcntl',
+                           'fcntl64',
+                           'fdatasync',
+                           'fgetxattr',
+                           'flistxattr',
+                           'flock',
+                           'fremovexattr',
+                           'fsetxattr',
+                           'fstatfs',
+                           'fstatfs64',
+                           'fsync',
+                           'ftruncate',
+                           'futimesat',
+                           'getdents',
+                           'getdents64',
+                           'getpeername',
+                           'getsockname',
+                           'getsockopt',
+                           'inotify_rm_watch',
+                           'ioctl',
+                           'listen',
+                           'llseek',
+                           'lseek',
+                           'mq_getsetattr',
+                           'mq_notify',
+                           'mq_timedreceive',
+                           'mq_timedsend',
+                           'old_readdir',
+                           'perf_event_open',
+                           'pread64',
+                           'preadv',
+                           'preadv2',
+                           'preadv64',
+                           'preadv64v2',
+                           'pwrite64',
+                           'pwritev',
+                           'pwritev2',
+                           'pwritev64',
+                           'pwritev64v2',
+                           'read',
+                           'readahead',
+                           'readv',
+                           'recvfrom',
+                           'sendfile',
+                           'sendfile64',
+                           'sendto',
+                           'setsockopt',
+                           'shutdown',
+                           'signalfd4',
+                           'splice',
+                           'sync_file_range',
+                           'syncfs',
+                           'tee',
+                           'utime',
+                           'utimensat',
+                           'vmsplice',
+                           'write',
+                           'writev']),
+ 'inotify_rm_watch': set(['accept4',
+                          'bind',
+                          'bpf',
+                          'connect',
+                          'copy_file_range',
+                          'epoll_ctl',
+                          'epoll_wait',
+                          'fadvise64_64',
+                          'fallocate',
+                          'fchdir',
+                          'fchmod',
+                          'fchown',
+                          'fcntl',
+                          'fcntl64',
+                          'fdatasync',
+                          'fgetxattr',
+                          'flistxattr',
+                          'flock',
+                          'fremovexattr',
+                          'fsetxattr',
+                          'fstatfs',
+                          'fstatfs64',
+                          'fsync',
+                          'ftruncate',
+                          'futimesat',
+                          'getdents',
+                          'getdents64',
+                          'getpeername',
+                          'getsockname',
+                          'getsockopt',
+                          'inotify_add_watch',
+                          'ioctl',
+                          'listen',
+                          'llseek',
+                          'lseek',
+                          'mq_getsetattr',
+                          'mq_notify',
+                          'mq_timedreceive',
+                          'mq_timedsend',
+                          'old_readdir',
+                          'perf_event_open',
+                          'pread64',
+                          'preadv',
+                          'preadv2',
+                          'preadv64',
+                          'preadv64v2',
+                          'pwrite64',
+                          'pwritev',
+                          'pwritev2',
+                          'pwritev64',
+                          'pwritev64v2',
+                          'read',
+                          'readahead',
+                          'readv',
+                          'recvfrom',
+                          'sendfile',
+                          'sendfile64',
+                          'sendto',
+                          'setsockopt',
+                          'shutdown',
+                          'signalfd4',
+                          'splice',
+                          'sync_file_range',
+                          'syncfs',
+                          'tee',
+                          'utime',
+                          'utimensat',
+                          'vmsplice',
+                          'write',
+                          'writev']),
+ 'io_cancel': set(['io_destroy', 'io_getevents', 'io_setup', 'io_submit']),
+ 'io_destroy': set(['io_cancel', 'io_getevents', 'io_setup', 'io_submit']),
+ 'io_getevents': set(['capget',
+                      'clone',
+                      'fork',
+                      'get_robust_list',
+                      'getitimer',
+                      'getpgid',
+                      'getppid',
+                      'getpriority',
+                      'getrusage',
+                      'getsid',
+                      'io_cancel',
+                      'io_destroy',
+                      'io_setup',
+                      'io_submit',
+                      'ioprio_get',
+                      'ioprio_set',
+                      'keyctl',
+                      'kill',
+                      'migrate_pages',
+                      'move_pages',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'msgrcv',
+                      'perf_event_open',
+                      'prctl',
+                      'prlimit64',
+                      'ptrace',
+                      'rt_sigaction',
+                      'rt_sigprocmask',
+                      'rt_sigtimedwait',
+                      'sched_getaffinity',
+                      'sched_getattr',
+                      'sched_getparam',
+                      'sched_getscheduler',
+                      'sched_rr_get_interval',
+                      'sched_setaffinity',
+                      'sched_setattr',
+                      'sched_setparam',
+                      'sched_setscheduler',
+                      'semtimedop',
+                      'setitimer',
+                      'setns',
+                      'setpgid',
+                      'setpriority',
+                      'setsid',
+                      'sigaction',
+                      'sigaltstack',
+                      'signal',
+                      'umount',
+                      'vfork']),
+ 'io_setup': set(['io_cancel', 'io_destroy', 'io_getevents', 'io_submit']),
+ 'io_submit': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioperm',
+                   'iopl',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaction',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'ioctl': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fadvise64_64',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'listen',
+               'llseek',
+               'lseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'ioperm': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'iopl',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'keyctl': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'request_key',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'llseek': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fadvise64_64',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'lseek': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fadvise64_64',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'write',
+               'writev']),
+ 'lstat': set(['fstat', 'stat']),
+ 'madvise': set(['brk',
+                 'get_mempolicy',
+                 'mincore',
+                 'mlockall',
+                 'mprotect',
+                 'mremap',
+                 'msync',
+                 'munlock',
+                 'munlockall',
+                 'pkey_mprotect',
+                 'prctl',
+                 'remap_file_pages',
+                 'shmdt']),
+ 'migrate_pages': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioperm',
+                       'iopl',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'mincore': set(['brk',
+                 'capget',
+                 'clone',
+                 'fork',
+                 'get_mempolicy',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioperm',
+                 'iopl',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'madvise',
+                 'migrate_pages',
+                 'mlockall',
+                 'move_pages',
+                 'mprotect',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'mremap',
+                 'msgrcv',
+                 'msync',
+                 'munlock',
+                 'munlockall',
+                 'perf_event_open',
+                 'pkey_mprotect',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'remap_file_pages',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'shmdt',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'umount',
+                 'vfork']),
+ 'mkdirat': set(['fadvise64_64',
+                 'quotactl',
+                 'swapon',
+                 'syncfs',
+                 'umount',
+                 'ustat']),
+ 'mknodat': set(['fadvise64_64',
+                 'quotactl',
+                 'swapon',
+                 'syncfs',
+                 'umount',
+                 'ustat']),
+ 'mlockall': set(['brk',
+                  'capget',
+                  'clone',
+                  'fork',
+                  'get_mempolicy',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'io_cancel',
+                  'io_destroy',
+                  'io_getevents',
+                  'io_setup',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'madvise',
+                  'mbind',
+                  'migrate_pages',
+                  'mincore',
+                  'modify_ldt',
+                  'move_pages',
+                  'mprotect',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mremap',
+                  'msgrcv',
+                  'msync',
+                  'munlock',
+                  'munlockall',
+                  'perf_event_open',
+                  'personality',
+                  'pkey_mprotect',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'remap_file_pages',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'shmdt',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'swapoff',
+                  'umount',
+                  'vfork']),
+ 'modify_ldt': set(['get_thread_area', 'set_thread_area']),
+ 'mount': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'personality',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'mprotect': set(['brk',
+                  'capget',
+                  'clone',
+                  'fork',
+                  'get_mempolicy',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'madvise',
+                  'migrate_pages',
+                  'mincore',
+                  'mlockall',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mremap',
+                  'msgrcv',
+                  'msync',
+                  'munlock',
+                  'munlockall',
+                  'perf_event_open',
+                  'personality',
+                  'pkey_mprotect',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'remap_file_pages',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'shmdt',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'mq_getsetattr': set(['mq_notify',
+                       'mq_open',
+                       'mq_timedreceive',
+                       'mq_timedsend']),
+ 'mq_notify': set(['mq_getsetattr',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'rt_sigqueueinfo',
+                   'rt_sigreturn',
+                   'rt_sigtimedwait',
+                   'rt_tgsigqueueinfo',
+                   'tgkill',
+                   'timer_create',
+                   'tkill']),
+ 'mq_open': set(['acct',
+                 'mq_unlink',
+                 'open',
+                 'openat',
+                 'quotactl',
+                 'renameat2',
+                 'rmdir',
+                 'swapoff',
+                 'swapon',
+                 'symlinkat',
+                 'sysfs',
+                 'unlink',
+                 'unlinkat',
+                 'uselib']),
+ 'mq_timedreceive': set(['accept4',
+                         'acct',
+                         'dup',
+                         'dup3',
+                         'epoll_create1',
+                         'epoll_ctl',
+                         'eventfd2',
+                         'fadvise64_64',
+                         'flock',
+                         'memfd_create',
+                         'mmap_pgoff',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_open',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'msgsnd',
+                         'msync',
+                         'open',
+                         'open_by_handle_at',
+                         'openat',
+                         'perf_event_open',
+                         'pipe2',
+                         'remap_file_pages',
+                         'setns',
+                         'shmat',
+                         'shmctl',
+                         'shmdt',
+                         'socket',
+                         'socketpair',
+                         'swapoff',
+                         'swapon',
+                         'uselib']),
+ 'mq_timedsend': set(['accept4',
+                      'acct',
+                      'dup',
+                      'dup3',
+                      'epoll_create1',
+                      'epoll_ctl',
+                      'eventfd2',
+                      'fadvise64_64',
+                      'flock',
+                      'memfd_create',
+                      'mmap_pgoff',
+                      'mq_getsetattr',
+                      'mq_notify',
+                      'mq_open',
+                      'mq_timedreceive',
+                      'msync',
+                      'open',
+                      'open_by_handle_at',
+                      'openat',
+                      'perf_event_open',
+                      'pipe2',
+                      'remap_file_pages',
+                      'setns',
+                      'shmat',
+                      'shmctl',
+                      'shmdt',
+                      'socket',
+                      'socketpair',
+                      'swapoff',
+                      'swapon',
+                      'uselib']),
+ 'mremap': set(['brk',
+                'capget',
+                'clone',
+                'fork',
+                'get_mempolicy',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'io_cancel',
+                'io_destroy',
+                'io_getevents',
+                'io_setup',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'madvise',
+                'mbind',
+                'migrate_pages',
+                'mincore',
+                'mlockall',
+                'modify_ldt',
+                'move_pages',
+                'mprotect',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'msync',
+                'munlock',
+                'munlockall',
+                'perf_event_open',
+                'personality',
+                'pkey_mprotect',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'remap_file_pages',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'shmdt',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'swapoff',
+                'umount',
+                'vfork']),
+ 'msgctl': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'iopl',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgget',
+                'msgrcv',
+                'msgsnd',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semctl',
+                'semget',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'shmat',
+                'shmctl',
+                'shmget',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'msgrcv': set(['mq_timedreceive', 'mq_timedsend', 'msgsnd']),
+ 'msgsnd': set(['mq_open',
+                'mq_unlink',
+                'msgctl',
+                'msgget',
+                'msgrcv',
+                'semctl',
+                'semget',
+                'semtimedop',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmget']),
+ 'msync': set(['brk',
+               'get_mempolicy',
+               'madvise',
+               'mincore',
+               'mlockall',
+               'mprotect',
+               'mremap',
+               'munlock',
+               'munlockall',
+               'pkey_mprotect',
+               'prctl',
+               'remap_file_pages',
+               'shmdt']),
+ 'munlock': set(['brk',
+                 'get_mempolicy',
+                 'madvise',
+                 'mincore',
+                 'mlockall',
+                 'mprotect',
+                 'mremap',
+                 'msync',
+                 'munlockall',
+                 'pkey_mprotect',
+                 'prctl',
+                 'remap_file_pages',
+                 'shmdt']),
+ 'munlockall': set(['brk',
+                    'get_mempolicy',
+                    'madvise',
+                    'mincore',
+                    'mlockall',
+                    'mprotect',
+                    'mremap',
+                    'msync',
+                    'munlock',
+                    'pkey_mprotect',
+                    'prctl',
+                    'remap_file_pages',
+                    'shmdt']),
+ 'nanosleep': set(['clock_nanosleep',
+                   'epoll_wait',
+                   'faccessat',
+                   'fadvise64_64',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'ftruncate',
+                   'futex',
+                   'futimesat',
+                   'inotify_add_watch',
+                   'io_getevents',
+                   'ioctl',
+                   'linkat',
+                   'memfd_create',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'poll',
+                   'ppoll',
+                   'pselect6',
+                   'readlinkat',
+                   'recvmmsg',
+                   'rt_sigtimedwait',
+                   'sched_rr_get_interval',
+                   'select',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'settimeofday',
+                   'stime',
+                   'swapoff',
+                   'swapon',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime']),
+ 'newfstat': set(['newfstatat', 'newlstat', 'newstat']),
+ 'newfstatat': set(['newfstat', 'newlstat', 'newstat']),
+ 'newlstat': set(['newfstat', 'newfstatat', 'newstat']),
+ 'newstat': set(['newfstat', 'newfstatat', 'newlstat']),
+ 'newuname': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'personality',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'old_getrlimit': set(['prlimit64', 'setrlimit']),
+ 'old_readdir': set(['accept4',
+                     'bind',
+                     'bpf',
+                     'connect',
+                     'copy_file_range',
+                     'epoll_ctl',
+                     'epoll_wait',
+                     'fadvise64_64',
+                     'fallocate',
+                     'fchdir',
+                     'fchmod',
+                     'fchown',
+                     'fcntl',
+                     'fcntl64',
+                     'fdatasync',
+                     'fgetxattr',
+                     'flistxattr',
+                     'flock',
+                     'fremovexattr',
+                     'fsetxattr',
+                     'fstatfs',
+                     'fstatfs64',
+                     'fsync',
+                     'ftruncate',
+                     'futimesat',
+                     'getdents',
+                     'getdents64',
+                     'getpeername',
+                     'getsockname',
+                     'getsockopt',
+                     'inotify_add_watch',
+                     'inotify_rm_watch',
+                     'ioctl',
+                     'listen',
+                     'llseek',
+                     'lseek',
+                     'mq_getsetattr',
+                     'mq_notify',
+                     'mq_timedreceive',
+                     'mq_timedsend',
+                     'perf_event_open',
+                     'pread64',
+                     'preadv',
+                     'preadv2',
+                     'preadv64',
+                     'preadv64v2',
+                     'pwrite64',
+                     'pwritev',
+                     'pwritev2',
+                     'pwritev64',
+                     'pwritev64v2',
+                     'read',
+                     'readahead',
+                     'readv',
+                     'recvfrom',
+                     'sendfile',
+                     'sendfile64',
+                     'sendto',
+                     'setsockopt',
+                     'shutdown',
+                     'signalfd4',
+                     'splice',
+                     'sync_file_range',
+                     'syncfs',
+                     'tee',
+                     'utime',
+                     'utimensat',
+                     'vmsplice',
+                     'write',
+                     'writev']),
+ 'olduname': set(['capget',
+                  'clone',
+                  'fork',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'ioperm',
+                  'iopl',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msgrcv',
+                  'perf_event_open',
+                  'personality',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'semtimedop',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'umount',
+                  'vfork']),
+ 'perf_event_open': set(['accept4',
+                         'bind',
+                         'bpf',
+                         'capget',
+                         'clone',
+                         'connect',
+                         'copy_file_range',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'fadvise64_64',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchown',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'flistxattr',
+                         'flock',
+                         'fork',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'get_robust_list',
+                         'getdents',
+                         'getdents64',
+                         'getitimer',
+                         'getpeername',
+                         'getpgid',
+                         'getppid',
+                         'getpriority',
+                         'getrusage',
+                         'getsid',
+                         'getsockname',
+                         'getsockopt',
+                         'inotify_add_watch',
+                         'inotify_rm_watch',
+                         'ioctl',
+                         'ioperm',
+                         'iopl',
+                         'ioprio_get',
+                         'ioprio_set',
+                         'keyctl',
+                         'kill',
+                         'listen',
+                         'llseek',
+                         'lseek',
+                         'migrate_pages',
+                         'move_pages',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'old_readdir',
+                         'prctl',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'prlimit64',
+                         'ptrace',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'read',
+                         'readahead',
+                         'readv',
+                         'recvfrom',
+                         'rt_sigaction',
+                         'rt_sigprocmask',
+                         'rt_sigtimedwait',
+                         'sched_getaffinity',
+                         'sched_getattr',
+                         'sched_getparam',
+                         'sched_getscheduler',
+                         'sched_rr_get_interval',
+                         'sched_setaffinity',
+                         'sched_setattr',
+                         'sched_setparam',
+                         'sched_setscheduler',
+                         'semtimedop',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'setitimer',
+                         'setns',
+                         'setpgid',
+                         'setpriority',
+                         'setresuid',
+                         'setreuid',
+                         'setsid',
+                         'setsockopt',
+                         'setuid',
+                         'shutdown',
+                         'sigaction',
+                         'sigaltstack',
+                         'signal',
+                         'signalfd4',
+                         'splice',
+                         'sync_file_range',
+                         'syncfs',
+                         'tee',
+                         'umount',
+                         'utime',
+                         'utimensat',
+                         'vfork',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'pivot_root': set(['acct', 'getcwd', 'mq_open', 'mq_unlink', 'umount']),
+ 'pkey_alloc': set(['brk',
+                    'get_mempolicy',
+                    'getrusage',
+                    'io_cancel',
+                    'io_destroy',
+                    'io_getevents',
+                    'io_setup',
+                    'mbind',
+                    'migrate_pages',
+                    'mincore',
+                    'modify_ldt',
+                    'move_pages',
+                    'mremap',
+                    'msync',
+                    'pkey_free',
+                    'prctl',
+                    'remap_file_pages',
+                    'shmdt',
+                    'swapoff']),
+ 'pkey_mprotect': set(['brk',
+                       'capget',
+                       'clone',
+                       'fork',
+                       'get_mempolicy',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'madvise',
+                       'migrate_pages',
+                       'mincore',
+                       'mlockall',
+                       'move_pages',
+                       'mprotect',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'mremap',
+                       'msgrcv',
+                       'msync',
+                       'munlock',
+                       'munlockall',
+                       'perf_event_open',
+                       'personality',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'remap_file_pages',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'shmdt',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'poll': set(['ppoll']),
+ 'ppoll': set(['capget',
+               'clock_nanosleep',
+               'clone',
+               'epoll_wait',
+               'faccessat',
+               'fadvise64_64',
+               'fchmod',
+               'fchmodat',
+               'fchown',
+               'fchownat',
+               'fork',
+               'ftruncate',
+               'futex',
+               'futimesat',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'inotify_add_watch',
+               'io_getevents',
+               'ioctl',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'linkat',
+               'memfd_create',
+               'migrate_pages',
+               'move_pages',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mq_unlink',
+               'msgrcv',
+               'nanosleep',
+               'perf_event_open',
+               'personality',
+               'poll',
+               'prctl',
+               'prlimit64',
+               'pselect6',
+               'ptrace',
+               'readlinkat',
+               'recvmmsg',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'select',
+               'semtimedop',
+               'sendfile',
+               'sendfile64',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'settimeofday',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'stime',
+               'swapoff',
+               'swapon',
+               'timer_gettime',
+               'timer_settime',
+               'timerfd_gettime',
+               'timerfd_settime',
+               'umount',
+               'unlink',
+               'unlinkat',
+               'uselib',
+               'utime',
+               'vfork']),
+ 'prctl': set(['brk',
+               'capget',
+               'clone',
+               'fork',
+               'get_mempolicy',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'io_cancel',
+               'io_destroy',
+               'io_getevents',
+               'io_setup',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'mbind',
+               'migrate_pages',
+               'mincore',
+               'modify_ldt',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mremap',
+               'msgrcv',
+               'msync',
+               'perf_event_open',
+               'personality',
+               'prlimit64',
+               'ptrace',
+               'remap_file_pages',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setresuid',
+               'setreuid',
+               'setsid',
+               'setuid',
+               'shmdt',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'swapoff',
+               'umount',
+               'vfork']),
+ 'pread64': set(['accept4',
+                 'acct',
+                 'bind',
+                 'bpf',
+                 'connect',
+                 'copy_file_range',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'epoll_wait',
+                 'eventfd2',
+                 'fadvise64_64',
+                 'fallocate',
+                 'fchdir',
+                 'fchmod',
+                 'fchown',
+                 'fcntl',
+                 'fcntl64',
+                 'fdatasync',
+                 'fgetxattr',
+                 'flistxattr',
+                 'flock',
+                 'fremovexattr',
+                 'fsetxattr',
+                 'fstatfs',
+                 'fstatfs64',
+                 'fsync',
+                 'ftruncate',
+                 'futimesat',
+                 'getdents',
+                 'getdents64',
+                 'getpeername',
+                 'getsockname',
+                 'getsockopt',
+                 'inotify_add_watch',
+                 'inotify_rm_watch',
+                 'ioctl',
+                 'listen',
+                 'llseek',
+                 'lseek',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_open',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msync',
+                 'old_readdir',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'preadv',
+                 'preadv2',
+                 'preadv64',
+                 'preadv64v2',
+                 'pwrite64',
+                 'pwritev',
+                 'pwritev2',
+                 'pwritev64',
+                 'pwritev64v2',
+                 'read',
+                 'readahead',
+                 'readv',
+                 'recvfrom',
+                 'remap_file_pages',
+                 'sendfile',
+                 'sendfile64',
+                 'sendto',
+                 'setns',
+                 'setsockopt',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'shutdown',
+                 'signalfd4',
+                 'socket',
+                 'socketpair',
+                 'splice',
+                 'swapoff',
+                 'swapon',
+                 'sync_file_range',
+                 'syncfs',
+                 'tee',
+                 'uselib',
+                 'utime',
+                 'utimensat',
+                 'vmsplice',
+                 'write',
+                 'writev']),
+ 'preadv': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'fadvise64_64',
+                'flock',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_open',
+                'msync',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'remap_file_pages',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'uselib']),
+ 'preadv2': set(['accept4',
+                 'acct',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'eventfd2',
+                 'fadvise64_64',
+                 'flock',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_open',
+                 'msync',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'remap_file_pages',
+                 'setns',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'socket',
+                 'socketpair',
+                 'swapoff',
+                 'swapon',
+                 'uselib']),
+ 'preadv64': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'fadvise64_64',
+                  'flock',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'msync',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'uselib']),
+ 'preadv64v2': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'fadvise64_64',
+                    'flock',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'msync',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'uselib']),
+ 'prlimit64': set(['old_getrlimit', 'setrlimit']),
+ 'pselect6': set(['capget',
+                  'clock_nanosleep',
+                  'clone',
+                  'epoll_wait',
+                  'faccessat',
+                  'fadvise64_64',
+                  'fchmod',
+                  'fchmodat',
+                  'fchown',
+                  'fchownat',
+                  'fork',
+                  'ftruncate',
+                  'futex',
+                  'futimesat',
+                  'get_robust_list',
+                  'getitimer',
+                  'getpgid',
+                  'getppid',
+                  'getpriority',
+                  'getrusage',
+                  'getsid',
+                  'inotify_add_watch',
+                  'io_getevents',
+                  'ioctl',
+                  'ioperm',
+                  'iopl',
+                  'ioprio_get',
+                  'ioprio_set',
+                  'keyctl',
+                  'kill',
+                  'linkat',
+                  'memfd_create',
+                  'migrate_pages',
+                  'move_pages',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mq_unlink',
+                  'msgrcv',
+                  'nanosleep',
+                  'perf_event_open',
+                  'poll',
+                  'ppoll',
+                  'prctl',
+                  'prlimit64',
+                  'ptrace',
+                  'readlinkat',
+                  'recvmmsg',
+                  'rt_sigaction',
+                  'rt_sigprocmask',
+                  'rt_sigtimedwait',
+                  'sched_getaffinity',
+                  'sched_getattr',
+                  'sched_getparam',
+                  'sched_getscheduler',
+                  'sched_rr_get_interval',
+                  'sched_setaffinity',
+                  'sched_setattr',
+                  'sched_setparam',
+                  'sched_setscheduler',
+                  'select',
+                  'semtimedop',
+                  'sendfile',
+                  'sendfile64',
+                  'setitimer',
+                  'setns',
+                  'setpgid',
+                  'setpriority',
+                  'setsid',
+                  'settimeofday',
+                  'sigaction',
+                  'sigaltstack',
+                  'signal',
+                  'stime',
+                  'swapoff',
+                  'swapon',
+                  'timer_gettime',
+                  'timer_settime',
+                  'timerfd_gettime',
+                  'timerfd_settime',
+                  'umount',
+                  'unlink',
+                  'unlinkat',
+                  'uselib',
+                  'utime',
+                  'vfork']),
+ 'ptrace': set(['capget',
+                'clone',
+                'epoll_wait',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'pause',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigsuspend',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'sigsuspend',
+                'umount',
+                'vfork']),
+ 'pwrite64': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fadvise64_64',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msync',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'vmsplice',
+                  'write',
+                  'writev']),
+ 'pwritev': set(['accept4',
+                 'acct',
+                 'dup',
+                 'dup3',
+                 'epoll_create1',
+                 'epoll_ctl',
+                 'eventfd2',
+                 'fadvise64_64',
+                 'flock',
+                 'memfd_create',
+                 'mmap_pgoff',
+                 'mq_open',
+                 'msync',
+                 'open',
+                 'open_by_handle_at',
+                 'openat',
+                 'perf_event_open',
+                 'pipe2',
+                 'remap_file_pages',
+                 'setns',
+                 'shmat',
+                 'shmctl',
+                 'shmdt',
+                 'socket',
+                 'socketpair',
+                 'swapoff',
+                 'swapon',
+                 'uselib']),
+ 'pwritev2': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'fadvise64_64',
+                  'flock',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'msync',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'uselib']),
+ 'pwritev64': set(['accept4',
+                   'acct',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'eventfd2',
+                   'fadvise64_64',
+                   'flock',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_open',
+                   'msync',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'remap_file_pages',
+                   'setns',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'socket',
+                   'socketpair',
+                   'swapoff',
+                   'swapon',
+                   'uselib']),
+ 'pwritev64v2': set(['accept4',
+                     'acct',
+                     'dup',
+                     'dup3',
+                     'epoll_create1',
+                     'epoll_ctl',
+                     'eventfd2',
+                     'fadvise64_64',
+                     'flock',
+                     'memfd_create',
+                     'mmap_pgoff',
+                     'mq_open',
+                     'msync',
+                     'open',
+                     'open_by_handle_at',
+                     'openat',
+                     'perf_event_open',
+                     'pipe2',
+                     'remap_file_pages',
+                     'setns',
+                     'shmat',
+                     'shmctl',
+                     'shmdt',
+                     'socket',
+                     'socketpair',
+                     'swapoff',
+                     'swapon',
+                     'uselib']),
+ 'quotactl': set(['acct',
+                  'fadvise64_64',
+                  'mq_open',
+                  'mq_unlink',
+                  'open',
+                  'openat',
+                  'renameat2',
+                  'rmdir',
+                  'swapoff',
+                  'swapon',
+                  'symlinkat',
+                  'syncfs',
+                  'sysfs',
+                  'umount',
+                  'unlink',
+                  'unlinkat',
+                  'uselib',
+                  'ustat']),
+ 'read': set(['accept4',
+              'bind',
+              'bpf',
+              'connect',
+              'copy_file_range',
+              'epoll_ctl',
+              'epoll_wait',
+              'fadvise64_64',
+              'fallocate',
+              'fchdir',
+              'fchmod',
+              'fchown',
+              'fcntl',
+              'fcntl64',
+              'fdatasync',
+              'fgetxattr',
+              'flistxattr',
+              'flock',
+              'fremovexattr',
+              'fsetxattr',
+              'fstatfs',
+              'fstatfs64',
+              'fsync',
+              'ftruncate',
+              'futimesat',
+              'getdents',
+              'getdents64',
+              'getpeername',
+              'getsockname',
+              'getsockopt',
+              'inotify_add_watch',
+              'inotify_rm_watch',
+              'ioctl',
+              'listen',
+              'llseek',
+              'lseek',
+              'mq_getsetattr',
+              'mq_notify',
+              'mq_timedreceive',
+              'mq_timedsend',
+              'old_readdir',
+              'perf_event_open',
+              'pread64',
+              'preadv',
+              'preadv2',
+              'preadv64',
+              'preadv64v2',
+              'pwrite64',
+              'pwritev',
+              'pwritev2',
+              'pwritev64',
+              'pwritev64v2',
+              'readahead',
+              'readv',
+              'recvfrom',
+              'sendfile',
+              'sendfile64',
+              'sendto',
+              'setsockopt',
+              'shutdown',
+              'signalfd4',
+              'splice',
+              'sync_file_range',
+              'syncfs',
+              'tee',
+              'utime',
+              'utimensat',
+              'vmsplice',
+              'write',
+              'writev']),
+ 'readahead': set(['accept4',
+                   'acct',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'dup',
+                   'dup3',
+                   'epoll_create1',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'eventfd2',
+                   'fadvise64_64',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'memfd_create',
+                   'mmap_pgoff',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_open',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msync',
+                   'old_readdir',
+                   'open',
+                   'open_by_handle_at',
+                   'openat',
+                   'perf_event_open',
+                   'pipe2',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readv',
+                   'recvfrom',
+                   'remap_file_pages',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setns',
+                   'setsockopt',
+                   'shmat',
+                   'shmctl',
+                   'shmdt',
+                   'shutdown',
+                   'signalfd4',
+                   'socket',
+                   'socketpair',
+                   'splice',
+                   'swapoff',
+                   'swapon',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'uselib',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'recvfrom': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'flock',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_open',
+                  'msync',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'uselib']),
+ 'recvmmsg': set(['clock_nanosleep',
+                  'epoll_wait',
+                  'faccessat',
+                  'fadvise64_64',
+                  'fchmod',
+                  'fchmodat',
+                  'fchown',
+                  'fchownat',
+                  'ftruncate',
+                  'futex',
+                  'futimesat',
+                  'inotify_add_watch',
+                  'io_getevents',
+                  'ioctl',
+                  'linkat',
+                  'memfd_create',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'mq_unlink',
+                  'nanosleep',
+                  'poll',
+                  'ppoll',
+                  'pselect6',
+                  'readlinkat',
+                  'recvfrom',
+                  'rt_sigtimedwait',
+                  'sched_rr_get_interval',
+                  'select',
+                  'semtimedop',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'settimeofday',
+                  'stime',
+                  'swapoff',
+                  'swapon',
+                  'timer_gettime',
+                  'timer_settime',
+                  'timerfd_gettime',
+                  'timerfd_settime',
+                  'unlink',
+                  'unlinkat',
+                  'uselib',
+                  'utime']),
+ 'remap_file_pages': set(['brk',
+                          'get_mempolicy',
+                          'madvise',
+                          'mincore',
+                          'mlockall',
+                          'mprotect',
+                          'mremap',
+                          'msync',
+                          'munlock',
+                          'munlockall',
+                          'pkey_mprotect',
+                          'prctl',
+                          'shmdt']),
+ 'renameat2': set(['acct',
+                   'mq_open',
+                   'mq_unlink',
+                   'open',
+                   'openat',
+                   'quotactl',
+                   'rmdir',
+                   'swapoff',
+                   'swapon',
+                   'symlinkat',
+                   'sysfs',
+                   'unlink',
+                   'unlinkat',
+                   'uselib']),
+ 'rt_sigqueueinfo': set(['kill',
+                         'rt_sigreturn',
+                         'rt_sigtimedwait',
+                         'rt_tgsigqueueinfo',
+                         'tgkill',
+                         'timer_create',
+                         'tkill']),
+ 'rt_sigreturn': set(['capget',
+                      'clone',
+                      'fork',
+                      'get_robust_list',
+                      'getitimer',
+                      'getpgid',
+                      'getppid',
+                      'getpriority',
+                      'getrusage',
+                      'getsid',
+                      'ioperm',
+                      'iopl',
+                      'ioprio_get',
+                      'ioprio_set',
+                      'keyctl',
+                      'kill',
+                      'migrate_pages',
+                      'move_pages',
+                      'mq_timedreceive',
+                      'mq_timedsend',
+                      'msgrcv',
+                      'perf_event_open',
+                      'prctl',
+                      'prlimit64',
+                      'ptrace',
+                      'rt_sigaction',
+                      'rt_sigprocmask',
+                      'rt_sigtimedwait',
+                      'sched_getaffinity',
+                      'sched_getattr',
+                      'sched_getparam',
+                      'sched_getscheduler',
+                      'sched_rr_get_interval',
+                      'sched_setaffinity',
+                      'sched_setattr',
+                      'sched_setparam',
+                      'sched_setscheduler',
+                      'semtimedop',
+                      'setitimer',
+                      'setns',
+                      'setpgid',
+                      'setpriority',
+                      'setsid',
+                      'sigaction',
+                      'sigaltstack',
+                      'signal',
+                      'umount',
+                      'vfork']),
+ 'rt_sigtimedwait': set(['capget',
+                         'clone',
+                         'fork',
+                         'get_robust_list',
+                         'getitimer',
+                         'getpgid',
+                         'getppid',
+                         'getpriority',
+                         'getrusage',
+                         'getsid',
+                         'ioperm',
+                         'iopl',
+                         'ioprio_get',
+                         'ioprio_set',
+                         'keyctl',
+                         'kill',
+                         'migrate_pages',
+                         'move_pages',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'perf_event_open',
+                         'prctl',
+                         'prlimit64',
+                         'ptrace',
+                         'rt_sigaction',
+                         'rt_sigprocmask',
+                         'rt_sigqueueinfo',
+                         'rt_sigreturn',
+                         'rt_tgsigqueueinfo',
+                         'sched_getaffinity',
+                         'sched_getattr',
+                         'sched_getparam',
+                         'sched_getscheduler',
+                         'sched_rr_get_interval',
+                         'sched_setaffinity',
+                         'sched_setattr',
+                         'sched_setparam',
+                         'sched_setscheduler',
+                         'semtimedop',
+                         'setitimer',
+                         'setns',
+                         'setpgid',
+                         'setpriority',
+                         'setsid',
+                         'sigaction',
+                         'sigaltstack',
+                         'signal',
+                         'tgkill',
+                         'timer_create',
+                         'tkill',
+                         'umount',
+                         'vfork']),
+ 'rt_tgsigqueueinfo': set(['kill',
+                           'rt_sigqueueinfo',
+                           'rt_sigreturn',
+                           'rt_sigtimedwait',
+                           'tgkill',
+                           'timer_create',
+                           'tkill']),
+ 'sched_getattr': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioperm',
+                       'iopl',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setattr',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'sched_getparam': set(['capget',
+                        'clone',
+                        'fork',
+                        'get_robust_list',
+                        'getitimer',
+                        'getpgid',
+                        'getppid',
+                        'getpriority',
+                        'getrusage',
+                        'getsid',
+                        'ioprio_get',
+                        'ioprio_set',
+                        'keyctl',
+                        'kill',
+                        'migrate_pages',
+                        'move_pages',
+                        'mq_timedreceive',
+                        'mq_timedsend',
+                        'msgrcv',
+                        'perf_event_open',
+                        'prctl',
+                        'prlimit64',
+                        'ptrace',
+                        'rt_sigaction',
+                        'rt_sigprocmask',
+                        'rt_sigtimedwait',
+                        'sched_getaffinity',
+                        'sched_getattr',
+                        'sched_getscheduler',
+                        'sched_rr_get_interval',
+                        'sched_setaffinity',
+                        'sched_setattr',
+                        'sched_setparam',
+                        'sched_setscheduler',
+                        'semtimedop',
+                        'setitimer',
+                        'setns',
+                        'setpgid',
+                        'setpriority',
+                        'setsid',
+                        'sigaction',
+                        'sigaltstack',
+                        'signal',
+                        'umount',
+                        'vfork']),
+ 'sched_getscheduler': set(['capget',
+                            'clone',
+                            'fork',
+                            'get_robust_list',
+                            'getitimer',
+                            'getpgid',
+                            'getppid',
+                            'getpriority',
+                            'getrusage',
+                            'getsid',
+                            'ioprio_get',
+                            'ioprio_set',
+                            'keyctl',
+                            'kill',
+                            'migrate_pages',
+                            'move_pages',
+                            'mq_timedreceive',
+                            'mq_timedsend',
+                            'msgrcv',
+                            'perf_event_open',
+                            'prctl',
+                            'prlimit64',
+                            'ptrace',
+                            'rt_sigaction',
+                            'rt_sigprocmask',
+                            'rt_sigtimedwait',
+                            'sched_getaffinity',
+                            'sched_getattr',
+                            'sched_getparam',
+                            'sched_rr_get_interval',
+                            'sched_setaffinity',
+                            'sched_setattr',
+                            'sched_setparam',
+                            'sched_setscheduler',
+                            'semtimedop',
+                            'setitimer',
+                            'setns',
+                            'setpgid',
+                            'setpriority',
+                            'setsid',
+                            'sigaction',
+                            'sigaltstack',
+                            'signal',
+                            'umount',
+                            'vfork']),
+ 'sched_setaffinity': set(['capget',
+                           'clone',
+                           'fork',
+                           'get_robust_list',
+                           'getitimer',
+                           'getpgid',
+                           'getppid',
+                           'getpriority',
+                           'getrusage',
+                           'getsid',
+                           'ioprio_get',
+                           'ioprio_set',
+                           'keyctl',
+                           'kill',
+                           'migrate_pages',
+                           'move_pages',
+                           'mq_timedreceive',
+                           'mq_timedsend',
+                           'msgrcv',
+                           'perf_event_open',
+                           'prctl',
+                           'prlimit64',
+                           'ptrace',
+                           'rt_sigaction',
+                           'rt_sigprocmask',
+                           'rt_sigtimedwait',
+                           'sched_getaffinity',
+                           'sched_getattr',
+                           'sched_getparam',
+                           'sched_getscheduler',
+                           'sched_rr_get_interval',
+                           'sched_setattr',
+                           'sched_setparam',
+                           'sched_setscheduler',
+                           'semtimedop',
+                           'setitimer',
+                           'setns',
+                           'setpgid',
+                           'setpriority',
+                           'setresuid',
+                           'setreuid',
+                           'setsid',
+                           'setuid',
+                           'sigaction',
+                           'sigaltstack',
+                           'signal',
+                           'umount',
+                           'vfork']),
+ 'sched_setattr': set(['capget',
+                       'clone',
+                       'fork',
+                       'get_robust_list',
+                       'getitimer',
+                       'getpgid',
+                       'getppid',
+                       'getpriority',
+                       'getrusage',
+                       'getsid',
+                       'ioperm',
+                       'iopl',
+                       'ioprio_get',
+                       'ioprio_set',
+                       'keyctl',
+                       'kill',
+                       'migrate_pages',
+                       'move_pages',
+                       'mq_timedreceive',
+                       'mq_timedsend',
+                       'msgrcv',
+                       'perf_event_open',
+                       'prctl',
+                       'prlimit64',
+                       'ptrace',
+                       'rt_sigaction',
+                       'rt_sigprocmask',
+                       'rt_sigtimedwait',
+                       'sched_getaffinity',
+                       'sched_getattr',
+                       'sched_getparam',
+                       'sched_getscheduler',
+                       'sched_rr_get_interval',
+                       'sched_setaffinity',
+                       'sched_setparam',
+                       'sched_setscheduler',
+                       'semtimedop',
+                       'setitimer',
+                       'setns',
+                       'setpgid',
+                       'setpriority',
+                       'setsid',
+                       'sigaction',
+                       'sigaltstack',
+                       'signal',
+                       'umount',
+                       'vfork']),
+ 'select': set(['capget',
+                'clock_nanosleep',
+                'clone',
+                'epoll_wait',
+                'faccessat',
+                'fadvise64_64',
+                'fchmod',
+                'fchmodat',
+                'fchown',
+                'fchownat',
+                'fork',
+                'ftruncate',
+                'futex',
+                'futimesat',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'inotify_add_watch',
+                'io_getevents',
+                'ioctl',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'linkat',
+                'memfd_create',
+                'migrate_pages',
+                'move_pages',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgrcv',
+                'nanosleep',
+                'perf_event_open',
+                'personality',
+                'poll',
+                'ppoll',
+                'prctl',
+                'prlimit64',
+                'pselect6',
+                'ptrace',
+                'readlinkat',
+                'recvmmsg',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'sendfile',
+                'sendfile64',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'settimeofday',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'stime',
+                'swapoff',
+                'swapon',
+                'timer_gettime',
+                'timer_settime',
+                'timerfd_gettime',
+                'timerfd_settime',
+                'umount',
+                'unlink',
+                'unlinkat',
+                'uselib',
+                'utime',
+                'vfork']),
+ 'semctl': set(['semtimedop']),
+ 'semtimedop': set(['clock_nanosleep',
+                    'epoll_wait',
+                    'faccessat',
+                    'fadvise64_64',
+                    'fchmod',
+                    'fchmodat',
+                    'fchown',
+                    'fchownat',
+                    'ftruncate',
+                    'futex',
+                    'futimesat',
+                    'inotify_add_watch',
+                    'io_getevents',
+                    'ioctl',
+                    'linkat',
+                    'memfd_create',
+                    'mq_getsetattr',
+                    'mq_notify',
+                    'mq_timedreceive',
+                    'mq_timedsend',
+                    'mq_unlink',
+                    'msgctl',
+                    'msgrcv',
+                    'msgsnd',
+                    'nanosleep',
+                    'poll',
+                    'ppoll',
+                    'pselect6',
+                    'readlinkat',
+                    'recvmmsg',
+                    'rt_sigtimedwait',
+                    'sched_rr_get_interval',
+                    'select',
+                    'semctl',
+                    'sendfile',
+                    'sendfile64',
+                    'settimeofday',
+                    'shmat',
+                    'shmctl',
+                    'stime',
+                    'swapoff',
+                    'swapon',
+                    'timer_gettime',
+                    'timer_settime',
+                    'timerfd_gettime',
+                    'timerfd_settime',
+                    'unlink',
+                    'unlinkat',
+                    'uselib',
+                    'utime']),
+ 'sendfile': set(['accept4',
+                  'acct',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'eventfd2',
+                  'fadvise64_64',
+                  'flock',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_open',
+                  'msync',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'remap_file_pages',
+                  'setns',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'socket',
+                  'socketpair',
+                  'swapoff',
+                  'swapon',
+                  'uselib']),
+ 'sendfile64': set(['accept4',
+                    'acct',
+                    'dup',
+                    'dup3',
+                    'epoll_create1',
+                    'epoll_ctl',
+                    'eventfd2',
+                    'fadvise64_64',
+                    'flock',
+                    'memfd_create',
+                    'mmap_pgoff',
+                    'mq_open',
+                    'msync',
+                    'open',
+                    'open_by_handle_at',
+                    'openat',
+                    'perf_event_open',
+                    'pipe2',
+                    'remap_file_pages',
+                    'setns',
+                    'shmat',
+                    'shmctl',
+                    'shmdt',
+                    'socket',
+                    'socketpair',
+                    'swapoff',
+                    'swapon',
+                    'uselib']),
+ 'sendto': set(['accept4',
+                'acct',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'eventfd2',
+                'flock',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_open',
+                'msync',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'remap_file_pages',
+                'setns',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'uselib']),
+ 'set_mempolicy': set(['get_mempolicy', 'mbind']),
+ 'set_thread_area': set(['arch_prctl',
+                         'capget',
+                         'clone',
+                         'fork',
+                         'get_robust_list',
+                         'getitimer',
+                         'getpgid',
+                         'getppid',
+                         'getpriority',
+                         'getrusage',
+                         'getsid',
+                         'ioperm',
+                         'iopl',
+                         'ioprio_get',
+                         'ioprio_set',
+                         'keyctl',
+                         'kill',
+                         'migrate_pages',
+                         'move_pages',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'msgrcv',
+                         'perf_event_open',
+                         'prctl',
+                         'prlimit64',
+                         'ptrace',
+                         'rt_sigaction',
+                         'rt_sigprocmask',
+                         'rt_sigtimedwait',
+                         'sched_getaffinity',
+                         'sched_getattr',
+                         'sched_getparam',
+                         'sched_getscheduler',
+                         'sched_rr_get_interval',
+                         'sched_setaffinity',
+                         'sched_setattr',
+                         'sched_setparam',
+                         'sched_setscheduler',
+                         'semtimedop',
+                         'setitimer',
+                         'setns',
+                         'setpgid',
+                         'setpriority',
+                         'setsid',
+                         'sigaction',
+                         'sigaltstack',
+                         'signal',
+                         'umount',
+                         'vfork']),
+ 'set_trip_temp': set(['get_curr_temp', 'get_trip_temp']),
+ 'setgroups16': set(['setgroups']),
+ 'setitimer': set(['adjtimex',
+                   'alarm',
+                   'clock_adjtime',
+                   'exit_group',
+                   'getitimer',
+                   'getrusage',
+                   'ppoll',
+                   'select',
+                   'settimeofday',
+                   'timer_create',
+                   'wait4',
+                   'waitid']),
+ 'setpgid': set(['capget',
+                 'clone',
+                 'exit_group',
+                 'fork',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'msgrcv',
+                 'perf_event_open',
+                 'prctl',
+                 'prlimit64',
+                 'ptrace',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'semtimedop',
+                 'setitimer',
+                 'setns',
+                 'setpriority',
+                 'setresuid',
+                 'setreuid',
+                 'setsid',
+                 'setuid',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'timer_create',
+                 'umount',
+                 'vfork']),
+ 'setrlimit': set(['getrlimit', 'old_getrlimit', 'prlimit64']),
+ 'setsid': set(['exit_group', 'timer_create']),
+ 'setsockopt': set(['accept4']),
+ 'settimeofday': set(['adjtimex',
+                      'alarm',
+                      'clock_adjtime',
+                      'getitimer',
+                      'getrusage',
+                      'ppoll',
+                      'select',
+                      'setitimer',
+                      'wait4',
+                      'waitid']),
+ 'shmctl': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'iopl',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgctl',
+                'msgrcv',
+                'msgsnd',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semctl',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'shmat',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'shmdt': set(['brk',
+               'get_mempolicy',
+               'madvise',
+               'mincore',
+               'mlockall',
+               'mprotect',
+               'mremap',
+               'msync',
+               'munlock',
+               'munlockall',
+               'pkey_mprotect',
+               'prctl',
+               'remap_file_pages']),
+ 'sigaction': set(['capget',
+                   'clone',
+                   'fork',
+                   'get_robust_list',
+                   'getitimer',
+                   'getpgid',
+                   'getppid',
+                   'getpriority',
+                   'getrusage',
+                   'getsid',
+                   'ioperm',
+                   'iopl',
+                   'ioprio_get',
+                   'ioprio_set',
+                   'keyctl',
+                   'kill',
+                   'migrate_pages',
+                   'move_pages',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'msgrcv',
+                   'perf_event_open',
+                   'prctl',
+                   'prlimit64',
+                   'ptrace',
+                   'rt_sigaction',
+                   'rt_sigprocmask',
+                   'rt_sigtimedwait',
+                   'sched_getaffinity',
+                   'sched_getattr',
+                   'sched_getparam',
+                   'sched_getscheduler',
+                   'sched_rr_get_interval',
+                   'sched_setaffinity',
+                   'sched_setattr',
+                   'sched_setparam',
+                   'sched_setscheduler',
+                   'semtimedop',
+                   'setitimer',
+                   'setns',
+                   'setpgid',
+                   'setpriority',
+                   'setsid',
+                   'sigaltstack',
+                   'signal',
+                   'umount',
+                   'vfork']),
+ 'signalfd4': set(['accept4',
+                   'bind',
+                   'bpf',
+                   'connect',
+                   'copy_file_range',
+                   'epoll_ctl',
+                   'epoll_wait',
+                   'fadvise64_64',
+                   'fallocate',
+                   'fchdir',
+                   'fchmod',
+                   'fchown',
+                   'fcntl',
+                   'fcntl64',
+                   'fdatasync',
+                   'fgetxattr',
+                   'flistxattr',
+                   'flock',
+                   'fremovexattr',
+                   'fsetxattr',
+                   'fstatfs',
+                   'fstatfs64',
+                   'fsync',
+                   'ftruncate',
+                   'futimesat',
+                   'getdents',
+                   'getdents64',
+                   'getpeername',
+                   'getsockname',
+                   'getsockopt',
+                   'inotify_add_watch',
+                   'inotify_rm_watch',
+                   'ioctl',
+                   'listen',
+                   'llseek',
+                   'lseek',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'old_readdir',
+                   'perf_event_open',
+                   'pread64',
+                   'preadv',
+                   'preadv2',
+                   'preadv64',
+                   'preadv64v2',
+                   'pwrite64',
+                   'pwritev',
+                   'pwritev2',
+                   'pwritev64',
+                   'pwritev64v2',
+                   'read',
+                   'readahead',
+                   'readv',
+                   'recvfrom',
+                   'sendfile',
+                   'sendfile64',
+                   'sendto',
+                   'setsockopt',
+                   'shutdown',
+                   'splice',
+                   'sync_file_range',
+                   'syncfs',
+                   'tee',
+                   'utime',
+                   'utimensat',
+                   'vmsplice',
+                   'write',
+                   'writev']),
+ 'splice': set(['accept4',
+                'acct',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'dup',
+                'dup3',
+                'epoll_create1',
+                'epoll_ctl',
+                'epoll_wait',
+                'eventfd2',
+                'fadvise64_64',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'memfd_create',
+                'mmap_pgoff',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msync',
+                'old_readdir',
+                'open',
+                'open_by_handle_at',
+                'openat',
+                'perf_event_open',
+                'pipe2',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'remap_file_pages',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setns',
+                'setsockopt',
+                'shmat',
+                'shmctl',
+                'shmdt',
+                'shutdown',
+                'signalfd4',
+                'socket',
+                'socketpair',
+                'swapoff',
+                'swapon',
+                'sync_file_range',
+                'syncfs',
+                'tee',
+                'uselib',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'stat': set(['fstat', 'lstat']),
+ 'statfs': set(['fstatfs', 'fstatfs64', 'statfs64', 'ustat']),
+ 'statfs64': set(['fstatfs', 'fstatfs64', 'statfs', 'ustat']),
+ 'swapoff': set(['swapon']),
+ 'swapon': set(['faccessat',
+                'fadvise64_64',
+                'fchmod',
+                'fchmodat',
+                'fchown',
+                'fchownat',
+                'ftruncate',
+                'inotify_add_watch',
+                'ioctl',
+                'linkat',
+                'memfd_create',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'readlinkat',
+                'sendfile',
+                'sendfile64',
+                'swapoff',
+                'unlink',
+                'unlinkat',
+                'uselib']),
+ 'symlinkat': set(['acct',
+                   'mq_open',
+                   'mq_unlink',
+                   'open',
+                   'openat',
+                   'quotactl',
+                   'renameat2',
+                   'rmdir',
+                   'swapoff',
+                   'swapon',
+                   'sysfs',
+                   'unlink',
+                   'unlinkat',
+                   'uselib']),
+ 'sync_file_range': set(['accept4',
+                         'bind',
+                         'bpf',
+                         'connect',
+                         'copy_file_range',
+                         'epoll_ctl',
+                         'epoll_wait',
+                         'fadvise64_64',
+                         'fallocate',
+                         'fchdir',
+                         'fchmod',
+                         'fchown',
+                         'fcntl',
+                         'fcntl64',
+                         'fdatasync',
+                         'fgetxattr',
+                         'flistxattr',
+                         'flock',
+                         'fremovexattr',
+                         'fsetxattr',
+                         'fstatfs',
+                         'fstatfs64',
+                         'fsync',
+                         'ftruncate',
+                         'futimesat',
+                         'getdents',
+                         'getdents64',
+                         'getpeername',
+                         'getsockname',
+                         'getsockopt',
+                         'inotify_add_watch',
+                         'inotify_rm_watch',
+                         'ioctl',
+                         'listen',
+                         'llseek',
+                         'lseek',
+                         'mq_getsetattr',
+                         'mq_notify',
+                         'mq_timedreceive',
+                         'mq_timedsend',
+                         'old_readdir',
+                         'perf_event_open',
+                         'pread64',
+                         'preadv',
+                         'preadv2',
+                         'preadv64',
+                         'preadv64v2',
+                         'pwrite64',
+                         'pwritev',
+                         'pwritev2',
+                         'pwritev64',
+                         'pwritev64v2',
+                         'read',
+                         'readahead',
+                         'readv',
+                         'recvfrom',
+                         'sendfile',
+                         'sendfile64',
+                         'sendto',
+                         'setsockopt',
+                         'shutdown',
+                         'signalfd4',
+                         'splice',
+                         'syncfs',
+                         'tee',
+                         'utime',
+                         'utimensat',
+                         'vmsplice',
+                         'write',
+                         'writev']),
+ 'syncfs': set(['accept4',
+                'bind',
+                'bpf',
+                'connect',
+                'copy_file_range',
+                'epoll_ctl',
+                'epoll_wait',
+                'fadvise64_64',
+                'fallocate',
+                'fchdir',
+                'fchmod',
+                'fchown',
+                'fcntl',
+                'fcntl64',
+                'fdatasync',
+                'fgetxattr',
+                'flistxattr',
+                'flock',
+                'fremovexattr',
+                'fsetxattr',
+                'fstatfs',
+                'fstatfs64',
+                'fsync',
+                'ftruncate',
+                'futimesat',
+                'getdents',
+                'getdents64',
+                'getpeername',
+                'getsockname',
+                'getsockopt',
+                'inotify_add_watch',
+                'inotify_rm_watch',
+                'ioctl',
+                'listen',
+                'llseek',
+                'lseek',
+                'mq_getsetattr',
+                'mq_notify',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'old_readdir',
+                'perf_event_open',
+                'pread64',
+                'preadv',
+                'preadv2',
+                'preadv64',
+                'preadv64v2',
+                'pwrite64',
+                'pwritev',
+                'pwritev2',
+                'pwritev64',
+                'pwritev64v2',
+                'read',
+                'readahead',
+                'readv',
+                'recvfrom',
+                'sendfile',
+                'sendfile64',
+                'sendto',
+                'setsockopt',
+                'shutdown',
+                'signalfd4',
+                'splice',
+                'sync_file_range',
+                'tee',
+                'utime',
+                'utimensat',
+                'vmsplice',
+                'write',
+                'writev']),
+ 'sysfs': set(['acct',
+               'mq_open',
+               'mq_unlink',
+               'open',
+               'openat',
+               'quotactl',
+               'renameat2',
+               'rmdir',
+               'swapoff',
+               'swapon',
+               'symlinkat',
+               'unlink',
+               'unlinkat',
+               'uselib']),
+ 'sysinfo': set(['capget',
+                 'clock_nanosleep',
+                 'clone',
+                 'epoll_wait',
+                 'faccessat',
+                 'fadvise64_64',
+                 'fchmod',
+                 'fchmodat',
+                 'fchown',
+                 'fchownat',
+                 'fork',
+                 'ftruncate',
+                 'futex',
+                 'futimesat',
+                 'get_robust_list',
+                 'getitimer',
+                 'getpgid',
+                 'getppid',
+                 'getpriority',
+                 'getrusage',
+                 'getsid',
+                 'inotify_add_watch',
+                 'io_getevents',
+                 'ioctl',
+                 'ioperm',
+                 'iopl',
+                 'ioprio_get',
+                 'ioprio_set',
+                 'keyctl',
+                 'kill',
+                 'linkat',
+                 'memfd_create',
+                 'migrate_pages',
+                 'move_pages',
+                 'mq_getsetattr',
+                 'mq_notify',
+                 'mq_timedreceive',
+                 'mq_timedsend',
+                 'mq_unlink',
+                 'msgrcv',
+                 'nanosleep',
+                 'perf_event_open',
+                 'poll',
+                 'ppoll',
+                 'prctl',
+                 'prlimit64',
+                 'pselect6',
+                 'ptrace',
+                 'readlinkat',
+                 'recvmmsg',
+                 'rt_sigaction',
+                 'rt_sigprocmask',
+                 'rt_sigtimedwait',
+                 'sched_getaffinity',
+                 'sched_getattr',
+                 'sched_getparam',
+                 'sched_getscheduler',
+                 'sched_rr_get_interval',
+                 'sched_setaffinity',
+                 'sched_setattr',
+                 'sched_setparam',
+                 'sched_setscheduler',
+                 'select',
+                 'semtimedop',
+                 'sendfile',
+                 'sendfile64',
+                 'setitimer',
+                 'setns',
+                 'setpgid',
+                 'setpriority',
+                 'setsid',
+                 'settimeofday',
+                 'sigaction',
+                 'sigaltstack',
+                 'signal',
+                 'stime',
+                 'swapoff',
+                 'swapon',
+                 'timer_gettime',
+                 'timer_settime',
+                 'timerfd_gettime',
+                 'timerfd_settime',
+                 'umount',
+                 'unlink',
+                 'unlinkat',
+                 'uselib',
+                 'utime',
+                 'vfork']),
+ 'syslog': set(['capget',
+                'clone',
+                'fork',
+                'get_robust_list',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioperm',
+                'iopl',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'msgrcv',
+                'perf_event_open',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setsid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'umount',
+                'vfork']),
+ 'tee': set(['accept4',
+             'acct',
+             'bind',
+             'bpf',
+             'connect',
+             'copy_file_range',
+             'dup',
+             'dup3',
+             'epoll_create1',
+             'epoll_ctl',
+             'epoll_wait',
+             'eventfd2',
+             'fadvise64_64',
+             'fallocate',
+             'fchdir',
+             'fchmod',
+             'fchown',
+             'fcntl',
+             'fcntl64',
+             'fdatasync',
+             'fgetxattr',
+             'flistxattr',
+             'flock',
+             'fremovexattr',
+             'fsetxattr',
+             'fstatfs',
+             'fstatfs64',
+             'fsync',
+             'ftruncate',
+             'futimesat',
+             'getdents',
+             'getdents64',
+             'getpeername',
+             'getsockname',
+             'getsockopt',
+             'inotify_add_watch',
+             'inotify_rm_watch',
+             'ioctl',
+             'listen',
+             'llseek',
+             'lseek',
+             'memfd_create',
+             'mmap_pgoff',
+             'mq_getsetattr',
+             'mq_notify',
+             'mq_open',
+             'mq_timedreceive',
+             'mq_timedsend',
+             'msync',
+             'old_readdir',
+             'open',
+             'open_by_handle_at',
+             'openat',
+             'perf_event_open',
+             'pipe2',
+             'pread64',
+             'preadv',
+             'preadv2',
+             'preadv64',
+             'preadv64v2',
+             'pwrite64',
+             'pwritev',
+             'pwritev2',
+             'pwritev64',
+             'pwritev64v2',
+             'read',
+             'readahead',
+             'readv',
+             'recvfrom',
+             'remap_file_pages',
+             'sendfile',
+             'sendfile64',
+             'sendto',
+             'setns',
+             'setsockopt',
+             'shmat',
+             'shmctl',
+             'shmdt',
+             'shutdown',
+             'signalfd4',
+             'socket',
+             'socketpair',
+             'splice',
+             'swapoff',
+             'swapon',
+             'sync_file_range',
+             'syncfs',
+             'uselib',
+             'utime',
+             'utimensat',
+             'vmsplice',
+             'write',
+             'writev']),
+ 'timer_create': set(['clock_adjtime',
+                      'clock_getres',
+                      'clock_gettime',
+                      'clock_nanosleep',
+                      'clock_settime',
+                      'timer_delete',
+                      'timer_gettime',
+                      'timer_settime']),
+ 'timer_delete': set(['clock_adjtime',
+                      'clock_getres',
+                      'clock_gettime',
+                      'clock_nanosleep',
+                      'clock_settime',
+                      'timer_create',
+                      'timer_gettime',
+                      'timer_settime']),
+ 'timer_gettime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_settime']),
+ 'timer_settime': set(['clock_adjtime',
+                       'clock_getres',
+                       'clock_gettime',
+                       'clock_nanosleep',
+                       'clock_settime',
+                       'timer_create',
+                       'timer_delete',
+                       'timer_gettime']),
+ 'timerfd_create': set(['timerfd_gettime', 'timerfd_settime']),
+ 'timerfd_gettime': set(['timerfd_create', 'timerfd_settime']),
+ 'timerfd_settime': set(['timerfd_create', 'timerfd_gettime']),
+ 'umount': set(['acct',
+                'capget',
+                'clone',
+                'fadvise64_64',
+                'fork',
+                'get_robust_list',
+                'getcwd',
+                'getitimer',
+                'getpgid',
+                'getppid',
+                'getpriority',
+                'getrusage',
+                'getsid',
+                'ioprio_get',
+                'ioprio_set',
+                'keyctl',
+                'kill',
+                'migrate_pages',
+                'move_pages',
+                'mq_open',
+                'mq_timedreceive',
+                'mq_timedsend',
+                'mq_unlink',
+                'msgrcv',
+                'perf_event_open',
+                'pivot_root',
+                'prctl',
+                'prlimit64',
+                'ptrace',
+                'quotactl',
+                'rt_sigaction',
+                'rt_sigprocmask',
+                'rt_sigtimedwait',
+                'sched_getaffinity',
+                'sched_getattr',
+                'sched_getparam',
+                'sched_getscheduler',
+                'sched_rr_get_interval',
+                'sched_setaffinity',
+                'sched_setattr',
+                'sched_setparam',
+                'sched_setscheduler',
+                'semtimedop',
+                'setitimer',
+                'setns',
+                'setpgid',
+                'setpriority',
+                'setresuid',
+                'setreuid',
+                'setsid',
+                'setuid',
+                'sigaction',
+                'sigaltstack',
+                'signal',
+                'swapon',
+                'syncfs',
+                'ustat',
+                'vfork']),
+ 'uname': set(['capget',
+               'clone',
+               'fork',
+               'get_robust_list',
+               'getitimer',
+               'getpgid',
+               'getppid',
+               'getpriority',
+               'getrusage',
+               'getsid',
+               'ioprio_get',
+               'ioprio_set',
+               'keyctl',
+               'kill',
+               'migrate_pages',
+               'move_pages',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'msgrcv',
+               'perf_event_open',
+               'personality',
+               'prctl',
+               'prlimit64',
+               'ptrace',
+               'rt_sigaction',
+               'rt_sigprocmask',
+               'rt_sigtimedwait',
+               'sched_getaffinity',
+               'sched_getattr',
+               'sched_getparam',
+               'sched_getscheduler',
+               'sched_rr_get_interval',
+               'sched_setaffinity',
+               'sched_setattr',
+               'sched_setparam',
+               'sched_setscheduler',
+               'semtimedop',
+               'setitimer',
+               'setns',
+               'setpgid',
+               'setpriority',
+               'setsid',
+               'sigaction',
+               'sigaltstack',
+               'signal',
+               'umount',
+               'vfork']),
+ 'uselib': set(['acct',
+                'fadvise64_64',
+                'getcwd',
+                'mq_open',
+                'mq_unlink',
+                'pivot_root',
+                'quotactl',
+                'swapon',
+                'syncfs',
+                'umount',
+                'ustat']),
+ 'utime': set(['clock_nanosleep',
+               'epoll_wait',
+               'faccessat',
+               'fadvise64_64',
+               'fchmod',
+               'fchmodat',
+               'fchown',
+               'fchownat',
+               'ftruncate',
+               'futex',
+               'futimesat',
+               'inotify_add_watch',
+               'io_getevents',
+               'ioctl',
+               'linkat',
+               'memfd_create',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'mq_unlink',
+               'nanosleep',
+               'poll',
+               'ppoll',
+               'pselect6',
+               'readlinkat',
+               'recvmmsg',
+               'rt_sigtimedwait',
+               'sched_rr_get_interval',
+               'select',
+               'semtimedop',
+               'sendfile',
+               'sendfile64',
+               'settimeofday',
+               'stime',
+               'swapoff',
+               'swapon',
+               'timer_gettime',
+               'timer_settime',
+               'timerfd_gettime',
+               'timerfd_settime',
+               'unlink',
+               'unlinkat',
+               'uselib']),
+ 'utimensat': set(['clock_nanosleep',
+                   'epoll_wait',
+                   'faccessat',
+                   'fadvise64_64',
+                   'fchmod',
+                   'fchmodat',
+                   'fchown',
+                   'fchownat',
+                   'ftruncate',
+                   'futex',
+                   'futimesat',
+                   'inotify_add_watch',
+                   'io_getevents',
+                   'ioctl',
+                   'linkat',
+                   'memfd_create',
+                   'mq_getsetattr',
+                   'mq_notify',
+                   'mq_timedreceive',
+                   'mq_timedsend',
+                   'mq_unlink',
+                   'nanosleep',
+                   'poll',
+                   'ppoll',
+                   'pselect6',
+                   'readlinkat',
+                   'recvmmsg',
+                   'rt_sigtimedwait',
+                   'sched_rr_get_interval',
+                   'select',
+                   'semtimedop',
+                   'sendfile',
+                   'sendfile64',
+                   'settimeofday',
+                   'stime',
+                   'swapoff',
+                   'swapon',
+                   'timer_gettime',
+                   'timer_settime',
+                   'timerfd_gettime',
+                   'timerfd_settime',
+                   'unlink',
+                   'unlinkat',
+                   'uselib',
+                   'utime']),
+ 'vmsplice': set(['accept4',
+                  'acct',
+                  'bind',
+                  'bpf',
+                  'connect',
+                  'copy_file_range',
+                  'dup',
+                  'dup3',
+                  'epoll_create1',
+                  'epoll_ctl',
+                  'epoll_wait',
+                  'eventfd2',
+                  'fadvise64_64',
+                  'fallocate',
+                  'fchdir',
+                  'fchmod',
+                  'fchown',
+                  'fcntl',
+                  'fcntl64',
+                  'fdatasync',
+                  'fgetxattr',
+                  'flistxattr',
+                  'flock',
+                  'fremovexattr',
+                  'fsetxattr',
+                  'fstatfs',
+                  'fstatfs64',
+                  'fsync',
+                  'ftruncate',
+                  'futimesat',
+                  'getdents',
+                  'getdents64',
+                  'getpeername',
+                  'getsockname',
+                  'getsockopt',
+                  'inotify_add_watch',
+                  'inotify_rm_watch',
+                  'ioctl',
+                  'listen',
+                  'llseek',
+                  'lseek',
+                  'memfd_create',
+                  'mmap_pgoff',
+                  'mq_getsetattr',
+                  'mq_notify',
+                  'mq_open',
+                  'mq_timedreceive',
+                  'mq_timedsend',
+                  'msync',
+                  'old_readdir',
+                  'open',
+                  'open_by_handle_at',
+                  'openat',
+                  'perf_event_open',
+                  'pipe2',
+                  'pread64',
+                  'preadv',
+                  'preadv2',
+                  'preadv64',
+                  'preadv64v2',
+                  'pwrite64',
+                  'pwritev',
+                  'pwritev2',
+                  'pwritev64',
+                  'pwritev64v2',
+                  'read',
+                  'readahead',
+                  'readv',
+                  'recvfrom',
+                  'remap_file_pages',
+                  'sendfile',
+                  'sendfile64',
+                  'sendto',
+                  'setns',
+                  'setsockopt',
+                  'shmat',
+                  'shmctl',
+                  'shmdt',
+                  'shutdown',
+                  'signalfd4',
+                  'socket',
+                  'socketpair',
+                  'splice',
+                  'swapoff',
+                  'swapon',
+                  'sync_file_range',
+                  'syncfs',
+                  'tee',
+                  'uselib',
+                  'utime',
+                  'utimensat',
+                  'write',
+                  'writev']),
+ 'write': set(['accept4',
+               'bind',
+               'bpf',
+               'connect',
+               'copy_file_range',
+               'epoll_ctl',
+               'epoll_wait',
+               'fadvise64_64',
+               'fallocate',
+               'fchdir',
+               'fchmod',
+               'fchown',
+               'fcntl',
+               'fcntl64',
+               'fdatasync',
+               'fgetxattr',
+               'flistxattr',
+               'flock',
+               'fremovexattr',
+               'fsetxattr',
+               'fstatfs',
+               'fstatfs64',
+               'fsync',
+               'ftruncate',
+               'futimesat',
+               'getdents',
+               'getdents64',
+               'getpeername',
+               'getsockname',
+               'getsockopt',
+               'inotify_add_watch',
+               'inotify_rm_watch',
+               'ioctl',
+               'listen',
+               'llseek',
+               'lseek',
+               'mq_getsetattr',
+               'mq_notify',
+               'mq_timedreceive',
+               'mq_timedsend',
+               'old_readdir',
+               'perf_event_open',
+               'pread64',
+               'preadv',
+               'preadv2',
+               'preadv64',
+               'preadv64v2',
+               'pwrite64',
+               'pwritev',
+               'pwritev2',
+               'pwritev64',
+               'pwritev64v2',
+               'read',
+               'readahead',
+               'readv',
+               'recvfrom',
+               'sendfile',
+               'sendfile64',
+               'sendto',
+               'setsockopt',
+               'shutdown',
+               'signalfd4',
+               'splice',
+               'sync_file_range',
+               'syncfs',
+               'tee',
+               'utime',
+               'utimensat',
+               'vmsplice',
+               'writev'])}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies_verbose.json b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies_verbose.json
new file mode 100644
index 0000000000..775324459b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies_verbose.json
@@ -0,0 +1 @@
+{"lseek": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "syncfs": [{"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "epoll_ctl": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["epoll_event->events", "epitem->nwait"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "rt_sigtimedwait": [{"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "msgrcv"}, {"reason": ["siginfo->si_code", "task_struct->timer_slack_ns", "mm_segment_t->seg", "siginfo->si_signo"], "call": "kill"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "capget"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "signal"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "umount"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "timer_create"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_rr_get_interval"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "rt_sigqueueinfo"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "tgkill"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setsid"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getsid"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sigaction"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "rt_tgsigqueueinfo"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setns"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "fork"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "vfork"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "prctl"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "move_pages"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "rt_sigreturn"}, {"reason": ["siginfo->si_signo", "siginfo->si_code"], "call": "tkill"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "clone"}, {"reason": ["mm_segment_t->seg", "task_struct->timer_slack_ns"], "call": "sched_getparam"}], "vmsplice": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "msgrcv": [{"reason": ["msg_msg->m_ts"], "call": "mq_timedreceive"}, {"reason": ["msg_msg->m_ts"], "call": "mq_timedsend"}, {"reason": ["msg_msg->m_ts"], "call": "msgsnd"}], "uname": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}], "io_getevents": [{"reason": ["task_struct->timer_slack_ns"], "call": "keyctl"}, {"reason": ["task_struct->timer_slack_ns"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->timer_slack_ns"], "call": "msgrcv"}, {"reason": ["task_struct->timer_slack_ns"], "call": "kill"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_getaffinity"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_setparam"}, {"reason": ["task_struct->timer_slack_ns"], "call": "ioprio_set"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getppid"}, {"reason": ["task_struct->timer_slack_ns"], "call": "mq_timedreceive"}, {"reason": ["task_struct->timer_slack_ns"], "call": "capget"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_setaffinity"}, {"reason": ["task_struct->timer_slack_ns"], "call": "signal"}, {"reason": ["task_struct->timer_slack_ns"], "call": "semtimedop"}, {"reason": ["task_struct->timer_slack_ns"], "call": "umount"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->timer_slack_ns"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setsid"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sigaltstack"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_setattr"}, {"reason": ["task_struct->timer_slack_ns"], "call": "migrate_pages"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getitimer"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setpgid"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getsid"}, {"reason": ["task_struct->timer_slack_ns"], "call": "prlimit64"}, {"reason": ["task_struct->timer_slack_ns"], "call": "perf_event_open"}, {"reason": ["task_struct->timer_slack_ns"], "call": "rt_sigaction"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getpgid"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getpriority"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sigaction"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setns"}, {"reason": ["task_struct->timer_slack_ns"], "call": "fork"}, {"reason": ["kioctx->user_id"], "call": "io_submit"}, {"reason": ["task_struct->timer_slack_ns"], "call": "get_robust_list"}, {"reason": ["task_struct->timer_slack_ns"], "call": "mq_timedsend"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_getscheduler"}, {"reason": ["task_struct->timer_slack_ns"], "call": "ptrace"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_getattr"}, {"reason": ["task_struct->timer_slack_ns"], "call": "getrusage"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_setscheduler"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setitimer"}, {"reason": ["task_struct->timer_slack_ns"], "call": "ioprio_get"}, {"reason": ["task_struct->timer_slack_ns"], "call": "vfork"}, {"reason": ["kioctx_table->nr", "kioctx->user_id"], "call": "io_setup"}, {"reason": ["kioctx_table->nr", "kioctx->user_id"], "call": "io_destroy"}, {"reason": ["task_struct->timer_slack_ns"], "call": "prctl"}, {"reason": ["task_struct->timer_slack_ns"], "call": "move_pages"}, {"reason": ["task_struct->timer_slack_ns"], "call": "setpriority"}, {"reason": ["task_struct->timer_slack_ns"], "call": "clone"}, {"reason": ["task_struct->timer_slack_ns"], "call": "sched_getparam"}, {"reason": ["kioctx_table->nr", "kioctx->user_id"], "call": "io_cancel"}], "swapoff": [{"reason": ["swap_info_struct->swap_map", "swap_info_struct->flags", "swap_info_struct->inuse_pages", "swap_info_struct->prio", "page->private", "swap_info_struct->pages"], "call": "swapon"}], "newlstat": [{"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newfstatat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newstat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newfstat"}], "pkey_alloc": [{"reason": ["mm_context_t->pkey_allocation_map"], "call": "swapoff"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "remap_file_pages"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "io_getevents"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "pkey_free"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "migrate_pages"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "shmdt"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "brk"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "get_mempolicy"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "getrusage"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "io_setup"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "mremap"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "io_destroy"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "mbind"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "prctl"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "move_pages"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "modify_ldt"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "mincore"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "msync"}, {"reason": ["mm_context_t->pkey_allocation_map"], "call": "io_cancel"}], "readahead": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "newfstatat": [{"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newlstat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newstat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newfstat"}], "preadv": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "getdents": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "timer_delete": [{"reason": ["k_clock->timer_del"], "call": "clock_getres"}, {"reason": ["k_clock->timer_del"], "call": "timer_create"}, {"reason": ["k_clock->timer_del"], "call": "clock_gettime"}, {"reason": ["k_clock->timer_del"], "call": "timer_settime"}, {"reason": ["k_clock->timer_del"], "call": "timer_gettime"}, {"reason": ["k_clock->timer_del"], "call": "clock_settime"}, {"reason": ["k_clock->timer_del"], "call": "clock_nanosleep"}, {"reason": ["k_clock->timer_del"], "call": "clock_adjtime"}], "pwritev2": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "fchmod": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "pivot_root": [{"reason": ["vfsmount->mnt_flags"], "call": "mq_unlink"}, {"reason": ["vfsmount->mnt_flags"], "call": "umount"}, {"reason": ["vfsmount->mnt_flags"], "call": "getcwd"}, {"reason": ["vfsmount->mnt_flags"], "call": "acct"}, {"reason": ["vfsmount->mnt_flags"], "call": "mq_open"}], "signalfd4": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "epoll_wait": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "fstat": [{"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "lstat"}, {"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "stat"}], "setgroups16": [{"reason": ["group_info->ngroups"], "call": "setgroups"}], "delete_module": [{"reason": ["module->exit", "module->init", "module->state"], "call": "init_module"}, {"reason": ["module->exit", "module->init", "module->state"], "call": "finit_module"}], "remap_file_pages": [{"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "msync"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mlockall"}], "dup3": [{"reason": ["files_struct->resize_in_progress", "fdtable->max_fds"], "call": "unshare"}, {"reason": ["fdtable->max_fds"], "call": "select"}, {"reason": ["files_struct->resize_in_progress", "fdtable->max_fds"], "call": "dup2"}], "read": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "preadv64": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "fchown": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "ioperm": [{"reason": ["thread_struct->io_bitmap_ptr"], "call": "keyctl"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "rt_sigtimedwait"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "iopl"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "msgrcv"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "kill"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_getaffinity"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_setparam"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "ioprio_set"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getppid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "mq_timedreceive"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "capget"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_setaffinity"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "signal"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "semtimedop"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "umount"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_rr_get_interval"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "rt_sigprocmask"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setsid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sigaltstack"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_setattr"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "migrate_pages"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getitimer"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setpgid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getsid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "prlimit64"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "perf_event_open"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "rt_sigaction"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getpgid"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getpriority"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sigaction"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setns"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "fork"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "get_robust_list"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "mq_timedsend"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_getscheduler"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "ptrace"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_getattr"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "getrusage"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_setscheduler"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setitimer"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "ioprio_get"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "vfork"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "prctl"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "move_pages"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "setpriority"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "clone"}, {"reason": ["thread_struct->io_bitmap_ptr"], "call": "sched_getparam"}], "mq_timedreceive": [{"reason": ["msg_msg->m_ts"], "call": "msgrcv"}, {"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup3"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "flock"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "openat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "uselib"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "accept4"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socket"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "acct"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open"}, {"reason": ["mq_attr->mq_curmsgs", "file->f_flags", "mq_attr->mq_msgsize"], "call": "mq_getsetattr"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "setns"}, {"reason": ["mq_attr->mq_curmsgs", "msg_msg->m_ts", "mq_attr->mq_msgsize"], "call": "mq_timedsend"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["msg_msg->m_ts"], "call": "msgsnd"}, {"reason": ["mq_attr->mq_curmsgs", "mq_attr->mq_msgsize"], "call": "mq_notify"}, {"reason": ["mq_attr->mq_curmsgs", "mq_attr->mq_msgsize", "file->f_flags", "file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "msync"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open_by_handle_at"}], "utime": [{"reason": ["timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_nsec"], "call": "ppoll"}], "sched_setaffinity": [{"reason": ["task_struct->flags"], "call": "keyctl"}, {"reason": ["task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->flags"], "call": "msgrcv"}, {"reason": ["task_struct->flags"], "call": "kill"}, {"reason": ["task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["task_struct->flags"], "call": "sched_setparam"}, {"reason": ["task_struct->flags"], "call": "ioprio_set"}, {"reason": ["task_struct->flags"], "call": "getppid"}, {"reason": ["task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["task_struct->flags"], "call": "capget"}, {"reason": ["task_struct->flags"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->flags"], "call": "semtimedop"}, {"reason": ["task_struct->flags"], "call": "umount"}, {"reason": ["task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->flags"], "call": "setsid"}, {"reason": ["task_struct->flags"], "call": "sigaltstack"}, {"reason": ["task_struct->flags"], "call": "sched_setattr"}, {"reason": ["task_struct->flags"], "call": "migrate_pages"}, {"reason": ["task_struct->flags"], "call": "getitimer"}, {"reason": ["task_struct->flags"], "call": "setpgid"}, {"reason": ["task_struct->flags"], "call": "getsid"}, {"reason": ["task_struct->flags"], "call": "prlimit64"}, {"reason": ["task_struct->flags"], "call": "perf_event_open"}, {"reason": ["task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["task_struct->flags"], "call": "getpgid"}, {"reason": ["task_struct->flags"], "call": "getpriority"}, {"reason": ["task_struct->flags"], "call": "sigaction"}, {"reason": ["task_struct->flags"], "call": "setns"}, {"reason": ["task_struct->flags"], "call": "fork"}, {"reason": ["task_struct->flags"], "call": "get_robust_list"}, {"reason": ["task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["task_struct->flags"], "call": "ptrace"}, {"reason": ["task_struct->flags"], "call": "sched_getattr"}, {"reason": ["task_struct->flags"], "call": "getrusage"}, {"reason": ["task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->flags"], "call": "setitimer"}, {"reason": ["task_struct->flags"], "call": "ioprio_get"}, {"reason": ["task_struct->flags"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["task_struct->flags"], "call": "prctl"}, {"reason": ["task_struct->flags"], "call": "move_pages"}, {"reason": ["task_struct->flags"], "call": "setpriority"}, {"reason": ["task_struct->flags"], "call": "clone"}, {"reason": ["task_struct->flags"], "call": "sched_getparam"}], "bpf": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["file->private_data"], "call": "swapoff"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["file->private_data"], "call": "memfd_create"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["file->private_data"], "call": "remap_file_pages"}, {"reason": ["file->private_data"], "call": "dup3"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["file->private_data"], "call": "socketpair"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["file->private_data"], "call": "epoll_create1"}, {"reason": ["file->private_data"], "call": "epoll_ctl"}, {"reason": ["file->private_data"], "call": "flock"}, {"reason": ["file->private_data"], "call": "openat"}, {"reason": ["file->private_data"], "call": "uselib"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["file->private_data"], "call": "accept4"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["file->private_data"], "call": "shmat"}, {"reason": ["file->private_data"], "call": "socket"}, {"reason": ["file->private_data"], "call": "pipe2"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg", "file->private_data"], "call": "perf_event_open"}, {"reason": ["file->private_data"], "call": "shmdt"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["file->private_data"], "call": "acct"}, {"reason": ["file->private_data"], "call": "open"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["file->private_data"], "call": "dup"}, {"reason": ["mm_segment_t->seg", "file->private_data"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["file->private_data"], "call": "shmctl"}, {"reason": ["file->private_data"], "call": "swapon"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["file->private_data"], "call": "eventfd2"}, {"reason": ["file->private_data"], "call": "mmap_pgoff"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["file->private_data"], "call": "mq_open"}, {"reason": ["file->private_data"], "call": "msync"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["file->private_data"], "call": "open_by_handle_at"}], "newstat": [{"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newlstat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newfstatat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newfstat"}], "semtimedop": [{"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["kern_ipc_perm->deleted"], "call": "msgrcv"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["sem_array->sem_nsems", "kern_ipc_perm->deleted", "sem_array->use_global_lock", "sem_undo->semid", "sem_array->complex_count"], "call": "semctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["kern_ipc_perm->deleted"], "call": "msgctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["kern_ipc_perm->deleted"], "call": "shmat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["kern_ipc_perm->deleted"], "call": "shmctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["kern_ipc_perm->deleted"], "call": "msgsnd"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "umount": [{"reason": ["super_block->s_flags"], "call": "syncfs"}, {"reason": ["task_struct->flags"], "call": "keyctl"}, {"reason": ["task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->flags"], "call": "msgrcv"}, {"reason": ["super_block->s_flags"], "call": "fadvise64_64"}, {"reason": ["vfsmount->mnt_flags"], "call": "mq_unlink"}, {"reason": ["task_struct->flags"], "call": "kill"}, {"reason": ["task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["task_struct->flags"], "call": "sched_setparam"}, {"reason": ["vfsmount->mnt_flags"], "call": "pivot_root"}, {"reason": ["task_struct->flags"], "call": "ioprio_set"}, {"reason": ["task_struct->flags"], "call": "getppid"}, {"reason": ["task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["task_struct->flags"], "call": "capget"}, {"reason": ["task_struct->flags"], "call": "sched_setaffinity"}, {"reason": ["super_block->s_flags"], "call": "ustat"}, {"reason": ["task_struct->flags"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->flags"], "call": "semtimedop"}, {"reason": ["task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->flags"], "call": "setsid"}, {"reason": ["task_struct->flags"], "call": "sigaltstack"}, {"reason": ["task_struct->flags"], "call": "sched_setattr"}, {"reason": ["task_struct->flags"], "call": "migrate_pages"}, {"reason": ["task_struct->flags"], "call": "getitimer"}, {"reason": ["task_struct->flags"], "call": "setpgid"}, {"reason": ["vfsmount->mnt_flags"], "call": "getcwd"}, {"reason": ["task_struct->flags"], "call": "getsid"}, {"reason": ["task_struct->flags"], "call": "prlimit64"}, {"reason": ["task_struct->flags"], "call": "perf_event_open"}, {"reason": ["super_block->s_flags"], "call": "quotactl"}, {"reason": ["task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["task_struct->flags"], "call": "getpgid"}, {"reason": ["vfsmount->mnt_flags"], "call": "acct"}, {"reason": ["task_struct->flags"], "call": "getpriority"}, {"reason": ["task_struct->flags"], "call": "sigaction"}, {"reason": ["task_struct->flags"], "call": "setns"}, {"reason": ["task_struct->flags"], "call": "fork"}, {"reason": ["task_struct->flags"], "call": "get_robust_list"}, {"reason": ["task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["task_struct->flags"], "call": "ptrace"}, {"reason": ["super_block->s_flags"], "call": "swapon"}, {"reason": ["task_struct->flags"], "call": "sched_getattr"}, {"reason": ["task_struct->flags"], "call": "getrusage"}, {"reason": ["task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->flags"], "call": "setitimer"}, {"reason": ["task_struct->flags"], "call": "ioprio_get"}, {"reason": ["task_struct->flags"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["task_struct->flags"], "call": "prctl"}, {"reason": ["task_struct->flags"], "call": "move_pages"}, {"reason": ["task_struct->flags"], "call": "setpriority"}, {"reason": ["task_struct->flags"], "call": "clone"}, {"reason": ["vfsmount->mnt_flags"], "call": "mq_open"}, {"reason": ["task_struct->flags"], "call": "sched_getparam"}], "recvfrom": [{"reason": ["file->f_flags"], "call": "swapoff"}, {"reason": ["file->f_flags"], "call": "memfd_create"}, {"reason": ["file->f_flags"], "call": "remap_file_pages"}, {"reason": ["file->f_flags"], "call": "dup3"}, {"reason": ["file->f_flags"], "call": "socketpair"}, {"reason": ["file->f_flags"], "call": "epoll_create1"}, {"reason": ["file->f_flags"], "call": "epoll_ctl"}, {"reason": ["file->f_flags"], "call": "flock"}, {"reason": ["file->f_flags"], "call": "openat"}, {"reason": ["file->f_flags"], "call": "uselib"}, {"reason": ["file->f_flags"], "call": "accept4"}, {"reason": ["file->f_flags"], "call": "shmat"}, {"reason": ["file->f_flags"], "call": "socket"}, {"reason": ["file->f_flags"], "call": "pipe2"}, {"reason": ["file->f_flags"], "call": "perf_event_open"}, {"reason": ["file->f_flags"], "call": "shmdt"}, {"reason": ["file->f_flags"], "call": "acct"}, {"reason": ["file->f_flags"], "call": "open"}, {"reason": ["file->f_flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_flags"], "call": "dup"}, {"reason": ["file->f_flags"], "call": "setns"}, {"reason": ["file->f_flags"], "call": "shmctl"}, {"reason": ["file->f_flags"], "call": "swapon"}, {"reason": ["file->f_flags"], "call": "eventfd2"}, {"reason": ["file->f_flags"], "call": "mmap_pgoff"}, {"reason": ["file->f_flags"], "call": "mq_open"}, {"reason": ["file->f_flags"], "call": "msync"}, {"reason": ["file->f_flags"], "call": "open_by_handle_at"}], "old_readdir": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "settimeofday": [{"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "adjtimex"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "waitid"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "select"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "wait4"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getrusage"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "setitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "clock_adjtime"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "alarm"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "ppoll"}], "timer_create": [{"reason": ["k_clock->timer_create"], "call": "clock_getres"}, {"reason": ["k_clock->timer_create"], "call": "timer_delete"}, {"reason": ["k_clock->timer_create"], "call": "clock_gettime"}, {"reason": ["k_clock->timer_create"], "call": "timer_settime"}, {"reason": ["k_clock->timer_create"], "call": "timer_gettime"}, {"reason": ["k_clock->timer_create"], "call": "clock_settime"}, {"reason": ["k_clock->timer_create"], "call": "clock_nanosleep"}, {"reason": ["k_clock->timer_create"], "call": "clock_adjtime"}], "sendto": [{"reason": ["file->f_flags"], "call": "swapoff"}, {"reason": ["file->f_flags"], "call": "memfd_create"}, {"reason": ["file->f_flags"], "call": "remap_file_pages"}, {"reason": ["file->f_flags"], "call": "dup3"}, {"reason": ["file->f_flags"], "call": "socketpair"}, {"reason": ["file->f_flags"], "call": "epoll_create1"}, {"reason": ["file->f_flags"], "call": "epoll_ctl"}, {"reason": ["file->f_flags"], "call": "flock"}, {"reason": ["file->f_flags"], "call": "openat"}, {"reason": ["file->f_flags"], "call": "uselib"}, {"reason": ["file->f_flags"], "call": "accept4"}, {"reason": ["file->f_flags"], "call": "shmat"}, {"reason": ["file->f_flags"], "call": "socket"}, {"reason": ["file->f_flags"], "call": "pipe2"}, {"reason": ["file->f_flags"], "call": "perf_event_open"}, {"reason": ["file->f_flags"], "call": "shmdt"}, {"reason": ["file->f_flags"], "call": "acct"}, {"reason": ["file->f_flags"], "call": "open"}, {"reason": ["file->f_flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_flags"], "call": "dup"}, {"reason": ["file->f_flags"], "call": "setns"}, {"reason": ["file->f_flags"], "call": "shmctl"}, {"reason": ["file->f_flags"], "call": "swapon"}, {"reason": ["file->f_flags"], "call": "eventfd2"}, {"reason": ["file->f_flags"], "call": "mmap_pgoff"}, {"reason": ["file->f_flags"], "call": "mq_open"}, {"reason": ["file->f_flags"], "call": "msync"}, {"reason": ["file->f_flags"], "call": "open_by_handle_at"}], "mkdirat": [{"reason": ["super_block->s_flags"], "call": "syncfs"}, {"reason": ["super_block->s_flags"], "call": "fadvise64_64"}, {"reason": ["super_block->s_flags"], "call": "ustat"}, {"reason": ["super_block->s_flags"], "call": "umount"}, {"reason": ["super_block->s_flags"], "call": "quotactl"}, {"reason": ["super_block->s_flags"], "call": "swapon"}], "newuname": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}], "olduname": [{"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "kill"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "capget"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "signal"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "umount"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setsid"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getsid"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setns"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "fork"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "vfork"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "prctl"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "clone"}, {"reason": ["task_struct->personality", "mm_segment_t->seg"], "call": "sched_getparam"}], "tee": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "semctl": [{"reason": ["sem_array->sem_nsems"], "call": "semtimedop"}], "syslog": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "rt_sigqueueinfo": [{"reason": ["siginfo->si_code"], "call": "rt_sigtimedwait"}, {"reason": ["siginfo->si_code"], "call": "kill"}, {"reason": ["siginfo->si_code"], "call": "timer_create"}, {"reason": ["siginfo->si_code"], "call": "tgkill"}, {"reason": ["siginfo->si_code"], "call": "rt_tgsigqueueinfo"}, {"reason": ["siginfo->si_code"], "call": "rt_sigreturn"}, {"reason": ["siginfo->si_code"], "call": "tkill"}], "sync_file_range": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "fadvise64_64": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["inode->i_flags"], "call": "mq_unlink"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["inode->i_flags"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["inode->i_flags"], "call": "memfd_create"}, {"reason": ["inode->i_flags"], "call": "readlinkat"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "fchown"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["inode->i_flags"], "call": "uselib"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["inode->i_flags"], "call": "fchmodat"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["inode->i_flags"], "call": "linkat"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["inode->i_flags"], "call": "unlink"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "mq_getsetattr"}, {"reason": ["inode->i_flags"], "call": "faccessat"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["inode->i_flags"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["inode->i_flags"], "call": "fchownat"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "mq_notify"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "sendfile"}, {"reason": ["inode->i_flags"], "call": "unlinkat"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["inode->i_flags", "fd->flags"], "call": "sendfile64"}], "llseek": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "flock": [{"reason": ["fd->flags", "super_block->s_flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags", "super_block->s_flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["super_block->s_flags"], "call": "ustat"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["super_block->s_flags"], "call": "umount"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["super_block->s_flags"], "call": "quotactl"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["super_block->s_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "pwritev": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "pselect6": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "uselib": [{"reason": ["super_block->s_iflags"], "call": "syncfs"}, {"reason": ["super_block->s_iflags"], "call": "fadvise64_64"}, {"reason": ["vfsmount->mnt_flags"], "call": "mq_unlink"}, {"reason": ["vfsmount->mnt_flags"], "call": "pivot_root"}, {"reason": ["super_block->s_iflags"], "call": "ustat"}, {"reason": ["vfsmount->mnt_flags", "super_block->s_iflags"], "call": "umount"}, {"reason": ["vfsmount->mnt_flags"], "call": "getcwd"}, {"reason": ["super_block->s_iflags"], "call": "quotactl"}, {"reason": ["vfsmount->mnt_flags"], "call": "acct"}, {"reason": ["super_block->s_iflags"], "call": "swapon"}, {"reason": ["vfsmount->mnt_flags"], "call": "mq_open"}], "sysfs": [{"reason": ["filename->name"], "call": "mq_unlink"}, {"reason": ["filename->name"], "call": "swapoff"}, {"reason": ["filename->name"], "call": "openat"}, {"reason": ["filename->name"], "call": "uselib"}, {"reason": ["filename->name"], "call": "renameat2"}, {"reason": ["filename->name"], "call": "symlinkat"}, {"reason": ["filename->name"], "call": "quotactl"}, {"reason": ["filename->name"], "call": "acct"}, {"reason": ["filename->name"], "call": "open"}, {"reason": ["filename->name"], "call": "unlink"}, {"reason": ["filename->name"], "call": "rmdir"}, {"reason": ["filename->name"], "call": "swapon"}, {"reason": ["filename->name"], "call": "mq_open"}, {"reason": ["filename->name"], "call": "unlinkat"}], "msgctl": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["ipc_namespace->msg_ctlmnb", "mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "mq_unlink"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "msgget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["ipc_namespace->msg_ctlmnb", "mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "semctl"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "shmget"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "semget"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "shmat"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["ipc_namespace->msg_ctlmnb", "mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "shmctl"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "msgsnd"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["ipc_namespace->msg_ctlmnb"], "call": "mq_open"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "fremovexattr": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "clock_adjtime": [{"reason": ["k_clock->clock_adj"], "call": "clock_getres"}, {"reason": ["k_clock->clock_adj"], "call": "timer_delete"}, {"reason": ["k_clock->clock_adj"], "call": "timer_create"}, {"reason": ["k_clock->clock_adj"], "call": "clock_gettime"}, {"reason": ["k_clock->clock_adj"], "call": "timer_settime"}, {"reason": ["k_clock->clock_adj"], "call": "timer_gettime"}, {"reason": ["k_clock->clock_adj"], "call": "clock_settime"}, {"reason": ["k_clock->clock_adj"], "call": "clock_nanosleep"}], "setsid": [{"reason": ["signal_struct->leader"], "call": "timer_create"}, {"reason": ["signal_struct->leader"], "call": "exit_group"}], "timerfd_create": [{"reason": ["timerfd_ctx->clockid"], "call": "timerfd_gettime"}, {"reason": ["timerfd_ctx->clockid"], "call": "timerfd_settime"}], "set_trip_temp": [{"reason": ["pkg_device->cpu", "pkg_device->tj_max"], "call": "get_trip_temp"}, {"reason": ["pkg_device->cpu", "pkg_device->tj_max"], "call": "get_curr_temp"}], "sched_setattr": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg", "sched_attr->sched_policy"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "inotify_rm_watch": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "renameat2": [{"reason": ["filename->refcnt", "filename->name"], "call": "sysfs"}, {"reason": ["filename->refcnt", "filename->name"], "call": "mq_unlink"}, {"reason": ["filename->refcnt", "filename->name"], "call": "swapoff"}, {"reason": ["filename->refcnt", "filename->name"], "call": "openat"}, {"reason": ["filename->refcnt", "filename->name"], "call": "uselib"}, {"reason": ["filename->refcnt", "filename->name"], "call": "symlinkat"}, {"reason": ["filename->refcnt", "filename->name"], "call": "quotactl"}, {"reason": ["filename->refcnt", "filename->name"], "call": "acct"}, {"reason": ["filename->refcnt", "filename->name"], "call": "open"}, {"reason": ["filename->refcnt", "filename->name"], "call": "unlink"}, {"reason": ["filename->refcnt", "filename->name"], "call": "rmdir"}, {"reason": ["filename->refcnt", "filename->name"], "call": "swapon"}, {"reason": ["filename->refcnt", "filename->name"], "call": "mq_open"}, {"reason": ["filename->refcnt", "filename->name"], "call": "unlinkat"}], "keyctl": [{"reason": ["task_struct->pid"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->pid"], "call": "msgrcv"}, {"reason": ["task_struct->pid"], "call": "kill"}, {"reason": ["task_struct->pid"], "call": "sched_getaffinity"}, {"reason": ["task_struct->pid"], "call": "sched_setparam"}, {"reason": ["task_struct->pid"], "call": "ioprio_set"}, {"reason": ["task_struct->pid"], "call": "getppid"}, {"reason": ["task_struct->pid"], "call": "mq_timedreceive"}, {"reason": ["task_struct->pid"], "call": "capget"}, {"reason": ["task_struct->pid"], "call": "sched_setaffinity"}, {"reason": ["task_struct->pid"], "call": "signal"}, {"reason": ["task_struct->pid"], "call": "semtimedop"}, {"reason": ["task_struct->pid"], "call": "umount"}, {"reason": ["task_struct->pid"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->pid"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->pid"], "call": "setsid"}, {"reason": ["task_struct->pid"], "call": "sigaltstack"}, {"reason": ["task_struct->pid"], "call": "sched_setattr"}, {"reason": ["task_struct->pid"], "call": "migrate_pages"}, {"reason": ["task_struct->pid"], "call": "getitimer"}, {"reason": ["task_struct->pid"], "call": "setpgid"}, {"reason": ["task_struct->pid"], "call": "getsid"}, {"reason": ["task_struct->pid"], "call": "prlimit64"}, {"reason": ["task_struct->pid"], "call": "perf_event_open"}, {"reason": ["task_struct->pid"], "call": "rt_sigaction"}, {"reason": ["key_type->read", "key_type->name", "key->quotalen", "key->serial", "key->description", "key->perm"], "call": "request_key"}, {"reason": ["task_struct->pid"], "call": "getpgid"}, {"reason": ["task_struct->pid"], "call": "getpriority"}, {"reason": ["task_struct->pid"], "call": "sigaction"}, {"reason": ["task_struct->pid"], "call": "setns"}, {"reason": ["task_struct->pid"], "call": "fork"}, {"reason": ["task_struct->pid"], "call": "get_robust_list"}, {"reason": ["task_struct->pid"], "call": "mq_timedsend"}, {"reason": ["task_struct->pid"], "call": "sched_getscheduler"}, {"reason": ["task_struct->pid"], "call": "ptrace"}, {"reason": ["task_struct->pid"], "call": "sched_getattr"}, {"reason": ["task_struct->pid"], "call": "getrusage"}, {"reason": ["task_struct->pid"], "call": "sched_setscheduler"}, {"reason": ["task_struct->pid"], "call": "setitimer"}, {"reason": ["task_struct->pid"], "call": "ioprio_get"}, {"reason": ["task_struct->pid"], "call": "vfork"}, {"reason": ["task_struct->pid"], "call": "prctl"}, {"reason": ["task_struct->pid"], "call": "move_pages"}, {"reason": ["task_struct->pid"], "call": "setpriority"}, {"reason": ["task_struct->pid"], "call": "clone"}, {"reason": ["task_struct->pid"], "call": "sched_getparam"}], "setrlimit": [{"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "old_getrlimit"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "prlimit64"}, {"reason": ["compat_rlimit->rlim_cur", "compat_rlimit->rlim_max"], "call": "getrlimit"}], "fcntl": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "migrate_pages": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "getitimer": [{"reason": ["signal_struct->it_real_incr"], "call": "timer_create"}, {"reason": ["signal_struct->it_real_incr"], "call": "exit_group"}, {"reason": ["signal_struct->it_real_incr"], "call": "setitimer"}], "setpgid": [{"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "keyctl"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "msgrcv"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "kill"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sched_setparam"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "ioprio_set"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "getppid"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "capget"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sched_setaffinity"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "semtimedop"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "umount"}, {"reason": ["signal_struct->leader"], "call": "timer_create"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->exit_signal", "task_struct->flags", "signal_struct->leader"], "call": "setsid"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sigaltstack"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sched_setattr"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "migrate_pages"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "getitimer"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "getsid"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "prlimit64"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "perf_event_open"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "getpgid"}, {"reason": ["signal_struct->leader"], "call": "exit_group"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "getpriority"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sigaction"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "setns"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "fork"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "get_robust_list"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "ptrace"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sched_getattr"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "getrusage"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "setitimer"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "ioprio_get"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "prctl"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "move_pages"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "setpriority"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "clone"}, {"reason": ["task_struct->exit_signal", "task_struct->flags"], "call": "sched_getparam"}], "init_module": [{"reason": ["module->args", "module->num_kp", "module_layout->base", "module_layout->size"], "call": "delete_module"}, {"reason": ["module->args", "load_info->num_debug", "module->num_kp", "load_info->len", "module_layout->size", "module_layout->base"], "call": "finit_module"}], "inotify_add_watch": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "preadv2": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "timer_settime": [{"reason": ["k_clock->timer_set"], "call": "clock_getres"}, {"reason": ["k_clock->timer_set"], "call": "timer_delete"}, {"reason": ["k_clock->timer_set"], "call": "timer_create"}, {"reason": ["k_clock->timer_set"], "call": "clock_gettime"}, {"reason": ["k_clock->timer_set"], "call": "timer_gettime"}, {"reason": ["k_clock->timer_set"], "call": "clock_settime"}, {"reason": ["k_clock->timer_set"], "call": "clock_nanosleep"}, {"reason": ["k_clock->timer_set"], "call": "clock_adjtime"}], "fchdir": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "timer_gettime": [{"reason": ["k_clock->timer_get"], "call": "clock_getres"}, {"reason": ["k_clock->timer_get"], "call": "timer_delete"}, {"reason": ["k_clock->timer_get"], "call": "timer_create"}, {"reason": ["k_clock->timer_get"], "call": "clock_gettime"}, {"reason": ["k_clock->timer_get"], "call": "timer_settime"}, {"reason": ["k_clock->timer_get"], "call": "clock_settime"}, {"reason": ["k_clock->timer_get"], "call": "clock_nanosleep"}, {"reason": ["k_clock->timer_get"], "call": "clock_adjtime"}], "msgsnd": [{"reason": ["ipc_namespace->msg_ctlmax"], "call": "msgrcv"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "mq_unlink"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "msgget"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "semtimedop"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "semctl"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "shmget"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "msgctl"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "semget"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "shmat"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "setns"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "shmctl"}, {"reason": ["ipc_namespace->msg_ctlmax"], "call": "mq_open"}], "sysinfo": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["timespec->tv_nsec"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["timespec->tv_nsec"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_nsec"], "call": "uselib"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_nsec"], "call": "stime"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_nsec"], "call": "unlink"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_nsec"], "call": "ppoll"}], "mknodat": [{"reason": ["super_block->s_flags"], "call": "syncfs"}, {"reason": ["super_block->s_flags"], "call": "fadvise64_64"}, {"reason": ["super_block->s_flags"], "call": "ustat"}, {"reason": ["super_block->s_flags"], "call": "umount"}, {"reason": ["super_block->s_flags"], "call": "quotactl"}, {"reason": ["super_block->s_flags"], "call": "swapon"}], "setsockopt": [{"reason": ["proto_ops->compat_setsockopt"], "call": "accept4"}], "munlockall": [{"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "msync"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mlockall"}], "msync": [{"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "remap_file_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "brk"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "madvise"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "mlockall"}], "ioctl": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "prlimit64": [{"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "setrlimit"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "old_getrlimit"}], "set_mempolicy": [{"reason": ["mempolicy->mode"], "call": "get_mempolicy"}, {"reason": ["mempolicy->mode"], "call": "mbind"}], "pwrite64": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "perf_event_open": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "msgrcv"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "kill"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sched_setparam"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "ioprio_set"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "getppid"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "fd->flags", "task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "capget"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sched_setaffinity"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "setsid"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sched_setattr"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "setpgid"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "getsid"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "prlimit64"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "getpgid"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sigaction"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "fork"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "get_robust_list"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["mm_segment_t->seg", "fd->flags", "task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "ptrace"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "prctl"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "move_pages"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "setpriority"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "clone"}, {"reason": ["mm_segment_t->seg", "task_struct->flags"], "call": "sched_getparam"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "lstat": [{"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "stat"}, {"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "fstat"}], "flistxattr": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "rt_tgsigqueueinfo": [{"reason": ["siginfo->si_code"], "call": "rt_sigtimedwait"}, {"reason": ["siginfo->si_code"], "call": "kill"}, {"reason": ["siginfo->si_code"], "call": "timer_create"}, {"reason": ["siginfo->si_code"], "call": "rt_sigqueueinfo"}, {"reason": ["siginfo->si_code"], "call": "tgkill"}, {"reason": ["siginfo->si_code"], "call": "rt_sigreturn"}, {"reason": ["siginfo->si_code"], "call": "tkill"}], "pwritev64v2": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "splice": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "openat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socket"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "acct"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags", "file->f_flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "msync"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "symlinkat": [{"reason": ["filename->refcnt", "filename->name"], "call": "sysfs"}, {"reason": ["filename->refcnt", "filename->name"], "call": "mq_unlink"}, {"reason": ["filename->refcnt", "filename->name"], "call": "swapoff"}, {"reason": ["filename->refcnt", "filename->name"], "call": "openat"}, {"reason": ["filename->refcnt", "filename->name"], "call": "uselib"}, {"reason": ["filename->refcnt", "filename->name"], "call": "renameat2"}, {"reason": ["filename->refcnt", "filename->name"], "call": "quotactl"}, {"reason": ["filename->refcnt", "filename->name"], "call": "acct"}, {"reason": ["filename->refcnt", "filename->name"], "call": "open"}, {"reason": ["filename->refcnt", "filename->name"], "call": "unlink"}, {"reason": ["filename->refcnt", "filename->name"], "call": "rmdir"}, {"reason": ["filename->refcnt", "filename->name"], "call": "swapon"}, {"reason": ["filename->refcnt", "filename->name"], "call": "mq_open"}, {"reason": ["filename->refcnt", "filename->name"], "call": "unlinkat"}], "brk": [{"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "swapoff"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "remap_file_pages"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "io_getevents"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "migrate_pages"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->def_flags"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "madvise"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "getrusage"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "io_setup"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "mremap"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "io_destroy"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "mbind"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "prctl"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "move_pages"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "modify_ldt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->brk", "mm_struct->start_brk", "vm_area_struct->vm_flags", "mm_struct->start_data"], "call": "msync"}, {"reason": ["mm_struct->brk", "mm_struct->start_brk", "mm_struct->def_flags", "mm_struct->end_data", "mm_struct->start_data"], "call": "io_cancel"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->def_flags"], "call": "mlockall"}], "fsetxattr": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "acct": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "poll": [{"reason": ["poll_list->len"], "call": "ppoll"}], "clock_settime": [{"reason": ["k_clock->clock_set"], "call": "clock_getres"}, {"reason": ["k_clock->clock_set"], "call": "timer_delete"}, {"reason": ["k_clock->clock_set"], "call": "timer_create"}, {"reason": ["k_clock->clock_set"], "call": "clock_gettime"}, {"reason": ["k_clock->clock_set"], "call": "timer_settime"}, {"reason": ["k_clock->clock_set"], "call": "timer_gettime"}, {"reason": ["k_clock->clock_set"], "call": "clock_nanosleep"}, {"reason": ["k_clock->clock_set"], "call": "clock_adjtime"}], "select": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "getsockopt": [{"reason": ["proto_ops->compat_getsockopt"], "call": "accept4"}], "sigaction": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "nanosleep": [{"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "quotactl": [{"reason": ["super_block->s_quota_types", "super_block->s_flags"], "call": "syncfs"}, {"reason": ["filename->name"], "call": "sysfs"}, {"reason": ["super_block->s_quota_types", "super_block->s_flags"], "call": "fadvise64_64"}, {"reason": ["filename->name"], "call": "mq_unlink"}, {"reason": ["filename->name"], "call": "swapoff"}, {"reason": ["super_block->s_quota_types", "super_block->s_flags"], "call": "ustat"}, {"reason": ["super_block->s_quota_types", "super_block->s_flags"], "call": "umount"}, {"reason": ["filename->name"], "call": "openat"}, {"reason": ["filename->name"], "call": "uselib"}, {"reason": ["filename->name"], "call": "renameat2"}, {"reason": ["filename->name"], "call": "symlinkat"}, {"reason": ["filename->name"], "call": "acct"}, {"reason": ["filename->name"], "call": "open"}, {"reason": ["filename->name"], "call": "unlink"}, {"reason": ["filename->name"], "call": "rmdir"}, {"reason": ["filename->name", "super_block->s_quota_types", "super_block->s_flags"], "call": "swapon"}, {"reason": ["filename->name"], "call": "mq_open"}, {"reason": ["filename->name"], "call": "unlinkat"}], "mq_getsetattr": [{"reason": ["mq_attr->mq_flags"], "call": "mq_timedreceive"}, {"reason": ["mq_attr->mq_flags"], "call": "mq_timedsend"}, {"reason": ["mq_attr->mq_flags"], "call": "mq_notify"}, {"reason": ["mq_attr->mq_flags"], "call": "mq_open"}], "fallocate": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "getdents64": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["mm_segment_t->seg", "fd->flags"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "get_mempolicy": [{"reason": ["task_struct->il_prev"], "call": "keyctl"}, {"reason": ["task_struct->il_prev"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->il_prev"], "call": "msgrcv"}, {"reason": ["task_struct->il_prev"], "call": "kill"}, {"reason": ["task_struct->il_prev"], "call": "sched_getaffinity"}, {"reason": ["task_struct->il_prev"], "call": "sched_setparam"}, {"reason": ["task_struct->il_prev"], "call": "ioprio_set"}, {"reason": ["task_struct->il_prev"], "call": "getppid"}, {"reason": ["task_struct->il_prev"], "call": "mq_timedreceive"}, {"reason": ["task_struct->il_prev"], "call": "capget"}, {"reason": ["task_struct->il_prev"], "call": "sched_setaffinity"}, {"reason": ["task_struct->il_prev"], "call": "signal"}, {"reason": ["task_struct->il_prev"], "call": "semtimedop"}, {"reason": ["task_struct->il_prev"], "call": "umount"}, {"reason": ["task_struct->il_prev"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->il_prev"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->il_prev"], "call": "setsid"}, {"reason": ["task_struct->il_prev"], "call": "sigaltstack"}, {"reason": ["task_struct->il_prev"], "call": "sched_setattr"}, {"reason": ["task_struct->il_prev"], "call": "migrate_pages"}, {"reason": ["task_struct->il_prev"], "call": "getitimer"}, {"reason": ["task_struct->il_prev"], "call": "setpgid"}, {"reason": ["task_struct->il_prev"], "call": "getsid"}, {"reason": ["task_struct->il_prev"], "call": "prlimit64"}, {"reason": ["task_struct->il_prev", "mempolicy->mode"], "call": "set_mempolicy"}, {"reason": ["task_struct->il_prev"], "call": "perf_event_open"}, {"reason": ["task_struct->il_prev"], "call": "rt_sigaction"}, {"reason": ["task_struct->il_prev"], "call": "getpgid"}, {"reason": ["task_struct->il_prev"], "call": "getpriority"}, {"reason": ["task_struct->il_prev"], "call": "sigaction"}, {"reason": ["task_struct->il_prev"], "call": "setns"}, {"reason": ["task_struct->il_prev"], "call": "fork"}, {"reason": ["task_struct->il_prev"], "call": "get_robust_list"}, {"reason": ["task_struct->il_prev"], "call": "mq_timedsend"}, {"reason": ["task_struct->il_prev"], "call": "sched_getscheduler"}, {"reason": ["task_struct->il_prev"], "call": "ptrace"}, {"reason": ["task_struct->il_prev"], "call": "sched_getattr"}, {"reason": ["task_struct->il_prev"], "call": "getrusage"}, {"reason": ["task_struct->il_prev"], "call": "sched_setscheduler"}, {"reason": ["task_struct->il_prev"], "call": "setitimer"}, {"reason": ["task_struct->il_prev"], "call": "ioprio_get"}, {"reason": ["task_struct->il_prev"], "call": "vfork"}, {"reason": ["mempolicy->mode"], "call": "mbind"}, {"reason": ["task_struct->il_prev"], "call": "prctl"}, {"reason": ["task_struct->il_prev"], "call": "move_pages"}, {"reason": ["task_struct->il_prev"], "call": "setpriority"}, {"reason": ["task_struct->il_prev"], "call": "clone"}, {"reason": ["task_struct->il_prev"], "call": "sched_getparam"}], "io_submit": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "futimesat": [{"reason": ["timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timeval->tv_usec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timeval->tv_usec"], "call": "adjtimex"}, {"reason": ["timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timeval->tv_usec"], "call": "waitid"}, {"reason": ["timeval->tv_usec"], "call": "getitimer"}, {"reason": ["timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_nsec"], "call": "poll"}, {"reason": ["timeval->tv_usec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timeval->tv_usec"], "call": "wait4"}, {"reason": ["timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timeval->tv_usec"], "call": "getrusage"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timeval->tv_usec"], "call": "setitimer"}, {"reason": ["timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timeval->tv_usec"], "call": "clock_adjtime"}, {"reason": ["timeval->tv_usec"], "call": "alarm"}, {"reason": ["timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timeval->tv_usec", "timespec->tv_nsec"], "call": "ppoll"}], "mq_timedsend": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup3"}, {"reason": ["mq_attr->mq_curmsgs", "mq_attr->mq_maxmsg", "mq_attr->mq_msgsize"], "call": "mq_timedreceive"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "flock"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "openat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "uselib"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "accept4"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socket"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "acct"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open"}, {"reason": ["mq_attr->mq_curmsgs", "mq_attr->mq_maxmsg", "file->f_flags", "mq_attr->mq_msgsize"], "call": "mq_getsetattr"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "setns"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["mq_attr->mq_curmsgs", "mq_attr->mq_maxmsg", "mq_attr->mq_msgsize"], "call": "mq_notify"}, {"reason": ["mq_attr->mq_maxmsg", "mq_attr->mq_msgsize", "mq_attr->mq_curmsgs", "file->f_flags", "file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "msync"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open_by_handle_at"}], "sched_getscheduler": [{"reason": ["task_struct->sched_reset_on_fork"], "call": "keyctl"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "msgrcv"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "kill"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_getaffinity"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_setparam"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "ioprio_set"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getppid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "mq_timedreceive"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "capget"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_setaffinity"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "signal"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "semtimedop"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "umount"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setsid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sigaltstack"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_setattr"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "migrate_pages"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getitimer"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setpgid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getsid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "prlimit64"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "perf_event_open"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "rt_sigaction"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getpgid"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getpriority"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sigaction"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setns"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "fork"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "get_robust_list"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "mq_timedsend"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "ptrace"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_getattr"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "getrusage"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_setscheduler"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setitimer"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "ioprio_get"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "vfork"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "prctl"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "move_pages"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "setpriority"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "clone"}, {"reason": ["task_struct->sched_reset_on_fork"], "call": "sched_getparam"}], "fgetxattr": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "ptrace": [{"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "keyctl"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "msgrcv"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "kill"}, {"reason": ["task_struct->state"], "call": "pause"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sched_getaffinity"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sched_setparam"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "ioprio_set"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "getppid"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "mq_timedreceive"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "capget"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sched_setaffinity"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "semtimedop"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "umount"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "setsid"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sigaltstack"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sched_setattr"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "migrate_pages"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "getitimer"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "setpgid"}, {"reason": ["task_struct->state"], "call": "rt_sigsuspend"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "getsid"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "prlimit64"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "perf_event_open"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "rt_sigaction"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "getpgid"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "getpriority"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sigaction"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "setns"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "fork"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "get_robust_list"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "mq_timedsend"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sched_getscheduler"}, {"reason": ["task_struct->state"], "call": "epoll_wait"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sched_getattr"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "getrusage"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "setitimer"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "ioprio_get"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "prctl"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "move_pages"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "setpriority"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "clone"}, {"reason": ["task_struct->state"], "call": "sigsuspend"}, {"reason": ["task_struct->exit_state", "task_struct->ptrace", "task_struct->flags", "task_struct->state"], "call": "sched_getparam"}], "shmctl": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["kern_ipc_perm->mode", "mm_segment_t->seg", "kern_ipc_perm->deleted"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["kern_ipc_perm->mode", "mm_segment_t->seg", "kern_ipc_perm->deleted"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["kern_ipc_perm->mode", "kern_ipc_perm->deleted"], "call": "semctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["kern_ipc_perm->mode", "kern_ipc_perm->deleted"], "call": "msgctl"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["kern_ipc_perm->mode", "kern_ipc_perm->deleted"], "call": "shmat"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["kern_ipc_perm->mode", "kern_ipc_perm->deleted"], "call": "msgsnd"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}], "fcntl64": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags", "flock->l_len", "flock->l_start"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "old_getrlimit": [{"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "setrlimit"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "prlimit64"}], "swapon": [{"reason": ["inode->i_flags"], "call": "fadvise64_64"}, {"reason": ["inode->i_flags"], "call": "mq_unlink"}, {"reason": ["inode->i_flags", "swap_info_struct->flags", "swap_info_struct->type"], "call": "swapoff"}, {"reason": ["inode->i_flags"], "call": "fchmod"}, {"reason": ["inode->i_flags"], "call": "memfd_create"}, {"reason": ["inode->i_flags"], "call": "readlinkat"}, {"reason": ["inode->i_flags"], "call": "fchown"}, {"reason": ["inode->i_flags"], "call": "mq_timedreceive"}, {"reason": ["inode->i_flags"], "call": "uselib"}, {"reason": ["inode->i_flags"], "call": "fchmodat"}, {"reason": ["inode->i_flags"], "call": "inotify_add_watch"}, {"reason": ["inode->i_flags"], "call": "ftruncate"}, {"reason": ["inode->i_flags"], "call": "ioctl"}, {"reason": ["inode->i_flags"], "call": "linkat"}, {"reason": ["inode->i_flags"], "call": "unlink"}, {"reason": ["inode->i_flags"], "call": "mq_getsetattr"}, {"reason": ["inode->i_flags"], "call": "faccessat"}, {"reason": ["inode->i_flags"], "call": "mq_timedsend"}, {"reason": ["inode->i_flags"], "call": "fchownat"}, {"reason": ["inode->i_flags"], "call": "mq_notify"}, {"reason": ["inode->i_flags"], "call": "sendfile"}, {"reason": ["inode->i_flags"], "call": "unlinkat"}, {"reason": ["inode->i_flags"], "call": "sendfile64"}], "pkey_mprotect": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["task_struct->personality", "vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "msync"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mlockall"}], "madvise": [{"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "msync"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mlockall"}], "statfs": [{"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "ustat"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs64"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs64"}], "mount": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}], "sched_getattr": [{"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "kill"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "capget"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "signal"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "umount"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setsid"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg", "sched_attr->size"], "call": "sched_setattr"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getsid"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setns"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "fork"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "vfork"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "prctl"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "clone"}, {"reason": ["task_struct->policy", "task_struct->sched_reset_on_fork", "mm_segment_t->seg"], "call": "sched_getparam"}], "getrusage": [{"reason": ["signal_struct->maxrss"], "call": "timer_create"}, {"reason": ["signal_struct->maxrss"], "call": "exit_group"}], "timerfd_settime": [{"reason": ["timerfd_ctx->tintv", "timerfd_ctx->expired"], "call": "timerfd_gettime"}, {"reason": ["timerfd_ctx->tintv", "timerfd_ctx->expired"], "call": "timerfd_create"}], "utimensat": [{"reason": ["timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_nsec"], "call": "ppoll"}], "ftruncate": [{"reason": ["inode->i_flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["inode->i_flags"], "call": "mq_unlink"}, {"reason": ["inode->i_flags", "file->f_flags", "file->f_mode"], "call": "swapoff"}, {"reason": ["inode->i_flags"], "call": "fchmod"}, {"reason": ["inode->i_flags", "file->f_flags", "file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup3"}, {"reason": ["inode->i_flags"], "call": "readlinkat"}, {"reason": ["inode->i_flags"], "call": "fchown"}, {"reason": ["inode->i_flags"], "call": "mq_timedreceive"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "flock"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "openat"}, {"reason": ["inode->i_flags", "file->f_flags", "file->f_mode"], "call": "uselib"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "accept4"}, {"reason": ["inode->i_flags"], "call": "fchmodat"}, {"reason": ["inode->i_flags"], "call": "inotify_add_watch"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "socket"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "pipe2"}, {"reason": ["inode->i_flags"], "call": "ioctl"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["inode->i_flags"], "call": "linkat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "acct"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open"}, {"reason": ["inode->i_flags"], "call": "unlink"}, {"reason": ["inode->i_flags", "file->f_flags"], "call": "mq_getsetattr"}, {"reason": ["inode->i_flags"], "call": "faccessat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "dup"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "setns"}, {"reason": ["inode->i_flags"], "call": "mq_timedsend"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "shmctl"}, {"reason": ["inode->i_flags", "file->f_flags", "file->f_mode"], "call": "swapon"}, {"reason": ["inode->i_flags"], "call": "fchownat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["inode->i_flags"], "call": "mq_notify"}, {"reason": ["inode->i_flags"], "call": "sendfile"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "msync"}, {"reason": ["inode->i_flags"], "call": "unlinkat"}, {"reason": ["file->f_flags", "file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["inode->i_flags"], "call": "sendfile64"}], "io_setup": [{"reason": ["kioctx->max_reqs", "kioctx->mmap_base", "kioctx->mmap_size", "kioctx->req_batch"], "call": "io_getevents"}, {"reason": ["kioctx->max_reqs", "kioctx->mmap_base", "kioctx->mmap_size", "kioctx->req_batch"], "call": "io_submit"}, {"reason": ["kioctx->max_reqs", "kioctx->mmap_base", "kioctx->mmap_size", "kioctx->req_batch"], "call": "io_destroy"}, {"reason": ["kioctx->max_reqs", "kioctx->mmap_base", "kioctx->mmap_size", "kioctx->req_batch"], "call": "io_cancel"}], "mprotect": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["task_struct->personality", "vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "msync"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_end"], "call": "mlockall"}], "mremap": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["mm_struct->map_count"], "call": "swapoff"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["mm_struct->map_count"], "call": "io_getevents"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality", "mm_struct->map_count"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality", "mm_struct->map_count"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["mm_struct->map_count"], "call": "io_setup"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["mm_struct->map_count"], "call": "io_destroy"}, {"reason": ["mm_struct->map_count"], "call": "mbind"}, {"reason": ["vm_area_struct->vm_start", "task_struct->personality", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["task_struct->personality", "mm_struct->map_count"], "call": "move_pages"}, {"reason": ["mm_struct->map_count"], "call": "modify_ldt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "mm_struct->map_count", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "msync"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["mm_struct->map_count"], "call": "io_cancel"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_flags", "vm_area_struct->vm_pgoff", "vm_area_struct->vm_end"], "call": "mlockall"}], "io_destroy": [{"reason": ["kioctx->max_reqs", "kioctx_table->nr", "kioctx->user_id", "kioctx->mmap_base", "kioctx->mmap_size"], "call": "io_getevents"}, {"reason": ["kioctx->max_reqs", "kioctx->user_id", "kioctx->mmap_base", "kioctx->mmap_size"], "call": "io_submit"}, {"reason": ["kioctx->max_reqs", "kioctx_table->nr", "kioctx->user_id", "kioctx->mmap_base", "kioctx->mmap_size"], "call": "io_setup"}, {"reason": ["kioctx->max_reqs", "kioctx_table->nr", "kioctx->user_id", "kioctx->mmap_base", "kioctx->mmap_size"], "call": "io_cancel"}], "pread64": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags", "file->f_mode"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags", "file->f_mode"], "call": "epoll_ctl"}, {"reason": ["fd->flags", "file->f_mode"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["fd->flags", "file->f_mode"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags", "file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "preadv64v2": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "prctl": [{"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "keyctl"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "msgrcv"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "kill"}, {"reason": ["mm_struct->flags"], "call": "swapoff"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_setparam"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["mm_struct->flags"], "call": "remap_file_pages"}, {"reason": ["mm_struct->flags"], "call": "io_getevents"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getppid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "capget"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "signal"}, {"reason": ["task_struct->flags"], "call": "setreuid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "semtimedop"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "umount"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setsid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sigaltstack"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_setattr"}, {"reason": ["mm_struct->flags", "task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "migrate_pages"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getitimer"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setpgid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getsid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "prlimit64"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "perf_event_open"}, {"reason": ["mm_struct->flags"], "call": "shmdt"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getpgid"}, {"reason": ["mm_struct->flags"], "call": "brk"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getpriority"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sigaction"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setns"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "fork"}, {"reason": ["mm_struct->flags"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "ptrace"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_getattr"}, {"reason": ["mm_struct->flags", "task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "getrusage"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_setscheduler"}, {"reason": ["task_struct->flags"], "call": "setresuid"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setitimer"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "ioprio_get"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "vfork"}, {"reason": ["task_struct->flags"], "call": "setuid"}, {"reason": ["mm_struct->flags"], "call": "io_setup"}, {"reason": ["mm_struct->flags"], "call": "mremap"}, {"reason": ["mm_struct->flags"], "call": "io_destroy"}, {"reason": ["mm_struct->flags"], "call": "mbind"}, {"reason": ["mm_struct->flags", "task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "move_pages"}, {"reason": ["mm_struct->flags"], "call": "modify_ldt"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "setpriority"}, {"reason": ["mm_struct->flags"], "call": "mincore"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "clone"}, {"reason": ["mm_struct->flags"], "call": "msync"}, {"reason": ["task_struct->personality", "task_struct->timer_slack_ns", "task_struct->flags"], "call": "sched_getparam"}, {"reason": ["mm_struct->flags"], "call": "io_cancel"}], "copy_file_range": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "write"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "fstatfs": [{"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "ustat"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs64"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs64"}], "modify_ldt": [{"reason": ["user_desc->limit_in_pages", "user_desc->read_exec_only", "user_desc->limit", "user_desc->useable", "user_desc->contents", "user_desc->seg_32bit", "user_desc->seg_not_present", "user_desc->entry_number", "user_desc->base_addr"], "call": "get_thread_area"}, {"reason": ["user_desc->limit_in_pages", "user_desc->read_exec_only", "user_desc->limit", "user_desc->useable", "user_desc->contents", "user_desc->seg_32bit", "user_desc->seg_not_present", "user_desc->entry_number", "user_desc->base_addr"], "call": "set_thread_area"}], "sched_getparam": [{"reason": ["task_struct->policy"], "call": "keyctl"}, {"reason": ["task_struct->policy"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->policy"], "call": "msgrcv"}, {"reason": ["task_struct->policy"], "call": "kill"}, {"reason": ["task_struct->policy"], "call": "sched_getaffinity"}, {"reason": ["task_struct->policy"], "call": "sched_setparam"}, {"reason": ["task_struct->policy"], "call": "ioprio_set"}, {"reason": ["task_struct->policy"], "call": "getppid"}, {"reason": ["task_struct->policy"], "call": "mq_timedreceive"}, {"reason": ["task_struct->policy"], "call": "capget"}, {"reason": ["task_struct->policy"], "call": "sched_setaffinity"}, {"reason": ["task_struct->policy"], "call": "signal"}, {"reason": ["task_struct->policy"], "call": "semtimedop"}, {"reason": ["task_struct->policy"], "call": "umount"}, {"reason": ["task_struct->policy"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->policy"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->policy"], "call": "setsid"}, {"reason": ["task_struct->policy"], "call": "sigaltstack"}, {"reason": ["task_struct->policy"], "call": "sched_setattr"}, {"reason": ["task_struct->policy"], "call": "migrate_pages"}, {"reason": ["task_struct->policy"], "call": "getitimer"}, {"reason": ["task_struct->policy"], "call": "setpgid"}, {"reason": ["task_struct->policy"], "call": "getsid"}, {"reason": ["task_struct->policy"], "call": "prlimit64"}, {"reason": ["task_struct->policy"], "call": "perf_event_open"}, {"reason": ["task_struct->policy"], "call": "rt_sigaction"}, {"reason": ["task_struct->policy"], "call": "getpgid"}, {"reason": ["task_struct->policy"], "call": "getpriority"}, {"reason": ["task_struct->policy"], "call": "sigaction"}, {"reason": ["task_struct->policy"], "call": "setns"}, {"reason": ["task_struct->policy"], "call": "fork"}, {"reason": ["task_struct->policy"], "call": "get_robust_list"}, {"reason": ["task_struct->policy"], "call": "mq_timedsend"}, {"reason": ["task_struct->policy"], "call": "sched_getscheduler"}, {"reason": ["task_struct->policy"], "call": "ptrace"}, {"reason": ["task_struct->policy"], "call": "sched_getattr"}, {"reason": ["task_struct->policy"], "call": "getrusage"}, {"reason": ["task_struct->policy"], "call": "sched_setscheduler"}, {"reason": ["task_struct->policy"], "call": "setitimer"}, {"reason": ["task_struct->policy"], "call": "ioprio_get"}, {"reason": ["task_struct->policy"], "call": "vfork"}, {"reason": ["task_struct->policy"], "call": "prctl"}, {"reason": ["task_struct->policy"], "call": "move_pages"}, {"reason": ["task_struct->policy"], "call": "setpriority"}, {"reason": ["task_struct->policy"], "call": "clone"}], "fstatfs64": [{"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "ustat"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs64"}], "rt_sigreturn": [{"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "iopl"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "kill"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "ioprio_set"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getppid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "capget"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "signal"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "umount"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setsid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getsid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "perf_event_open"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getpgid"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setns"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "fork"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "ptrace"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "vfork"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "prctl"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "move_pages"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "clone"}, {"reason": ["mm_segment_t->seg", "thread_struct->uaccess_err"], "call": "sched_getparam"}], "write": [{"reason": ["fd->flags"], "call": "syncfs"}, {"reason": ["fd->flags"], "call": "vmsplice"}, {"reason": ["fd->flags"], "call": "fadvise64_64"}, {"reason": ["fd->flags"], "call": "pwritev64"}, {"reason": ["fd->flags"], "call": "fremovexattr"}, {"reason": ["fd->flags"], "call": "readahead"}, {"reason": ["fd->flags"], "call": "getdents"}, {"reason": ["fd->flags"], "call": "writev"}, {"reason": ["fd->flags"], "call": "preadv64"}, {"reason": ["fd->flags"], "call": "fchmod"}, {"reason": ["fd->flags"], "call": "pread64"}, {"reason": ["fd->flags"], "call": "signalfd4"}, {"reason": ["fd->flags"], "call": "read"}, {"reason": ["fd->flags"], "call": "fchown"}, {"reason": ["fd->flags"], "call": "mq_timedreceive"}, {"reason": ["fd->flags"], "call": "utime"}, {"reason": ["fd->flags"], "call": "fsync"}, {"reason": ["fd->flags"], "call": "bpf"}, {"reason": ["fd->flags"], "call": "recvfrom"}, {"reason": ["fd->flags"], "call": "fsetxattr"}, {"reason": ["fd->flags"], "call": "sendto"}, {"reason": ["fd->flags"], "call": "tee"}, {"reason": ["fd->flags"], "call": "sync_file_range"}, {"reason": ["fd->flags"], "call": "lseek"}, {"reason": ["fd->flags"], "call": "connect"}, {"reason": ["fd->flags"], "call": "getsockname"}, {"reason": ["fd->flags"], "call": "epoll_ctl"}, {"reason": ["fd->flags"], "call": "flock"}, {"reason": ["fd->flags"], "call": "pwritev"}, {"reason": ["fd->flags"], "call": "fchdir"}, {"reason": ["fd->flags"], "call": "accept4"}, {"reason": ["fd->flags"], "call": "old_readdir"}, {"reason": ["fd->flags"], "call": "inotify_rm_watch"}, {"reason": ["fd->flags"], "call": "utimensat"}, {"reason": ["fd->flags"], "call": "inotify_add_watch"}, {"reason": ["fd->flags"], "call": "preadv2"}, {"reason": ["fd->flags"], "call": "splice"}, {"reason": ["fd->flags"], "call": "ftruncate"}, {"reason": ["fd->flags"], "call": "preadv"}, {"reason": ["fd->flags"], "call": "getpeername"}, {"reason": ["fd->flags"], "call": "setsockopt"}, {"reason": ["fd->flags"], "call": "fcntl"}, {"reason": ["fd->flags"], "call": "ioctl"}, {"reason": ["fd->flags"], "call": "pwrite64"}, {"reason": ["fd->flags"], "call": "perf_event_open"}, {"reason": ["fd->flags"], "call": "pwritev64v2"}, {"reason": ["fd->flags"], "call": "futimesat"}, {"reason": ["fd->flags"], "call": "pwritev2"}, {"reason": ["fd->flags"], "call": "shutdown"}, {"reason": ["fd->flags"], "call": "getsockopt"}, {"reason": ["fd->flags"], "call": "mq_getsetattr"}, {"reason": ["fd->flags"], "call": "fdatasync"}, {"reason": ["fd->flags"], "call": "getdents64"}, {"reason": ["fd->flags"], "call": "listen"}, {"reason": ["fd->flags"], "call": "copy_file_range"}, {"reason": ["fd->flags"], "call": "mq_timedsend"}, {"reason": ["fd->flags"], "call": "fgetxattr"}, {"reason": ["fd->flags"], "call": "fcntl64"}, {"reason": ["fd->flags"], "call": "fallocate"}, {"reason": ["fd->flags"], "call": "epoll_wait"}, {"reason": ["fd->flags"], "call": "llseek"}, {"reason": ["fd->flags"], "call": "preadv64v2"}, {"reason": ["fd->flags"], "call": "readv"}, {"reason": ["fd->flags"], "call": "fstatfs"}, {"reason": ["fd->flags"], "call": "fstatfs64"}, {"reason": ["fd->flags"], "call": "mq_notify"}, {"reason": ["fd->flags"], "call": "sendfile"}, {"reason": ["fd->flags"], "call": "bind"}, {"reason": ["fd->flags"], "call": "flistxattr"}, {"reason": ["fd->flags"], "call": "sendfile64"}], "munlock": [{"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "msync"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mlockall"}], "shmdt": [{"reason": ["vm_area_struct->vm_pgoff"], "call": "remap_file_pages"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "brk"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "get_mempolicy"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "madvise"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "prctl"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "munlock"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "mincore"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "msync"}, {"reason": ["vm_area_struct->vm_pgoff"], "call": "mlockall"}], "getrlimit": [{"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "setrlimit"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "old_getrlimit"}, {"reason": ["rlimit->rlim_max", "rlimit->rlim_cur"], "call": "prlimit64"}], "mincore": [{"reason": ["mm_segment_t->seg"], "call": "keyctl"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigtimedwait"}, {"reason": ["mm_segment_t->seg"], "call": "iopl"}, {"reason": ["mm_segment_t->seg"], "call": "msgrcv"}, {"reason": ["mm_segment_t->seg"], "call": "kill"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setparam"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_set"}, {"reason": ["vm_area_struct->vm_start"], "call": "remap_file_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getppid"}, {"reason": ["mm_segment_t->seg"], "call": "ioperm"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedreceive"}, {"reason": ["mm_segment_t->seg"], "call": "capget"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setaffinity"}, {"reason": ["mm_segment_t->seg"], "call": "signal"}, {"reason": ["mm_segment_t->seg"], "call": "semtimedop"}, {"reason": ["mm_segment_t->seg"], "call": "umount"}, {"reason": ["mm_segment_t->seg"], "call": "sched_rr_get_interval"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigprocmask"}, {"reason": ["mm_segment_t->seg"], "call": "setsid"}, {"reason": ["mm_segment_t->seg"], "call": "sigaltstack"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setattr"}, {"reason": ["mm_segment_t->seg"], "call": "migrate_pages"}, {"reason": ["mm_segment_t->seg"], "call": "getitimer"}, {"reason": ["mm_segment_t->seg"], "call": "setpgid"}, {"reason": ["mm_segment_t->seg"], "call": "getsid"}, {"reason": ["mm_segment_t->seg"], "call": "prlimit64"}, {"reason": ["mm_segment_t->seg"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start"], "call": "shmdt"}, {"reason": ["mm_segment_t->seg"], "call": "rt_sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start"], "call": "brk"}, {"reason": ["mm_segment_t->seg"], "call": "getpriority"}, {"reason": ["mm_segment_t->seg"], "call": "sigaction"}, {"reason": ["mm_segment_t->seg"], "call": "setns"}, {"reason": ["mm_segment_t->seg"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start"], "call": "get_mempolicy"}, {"reason": ["mm_segment_t->seg"], "call": "get_robust_list"}, {"reason": ["mm_segment_t->seg"], "call": "mq_timedsend"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start"], "call": "madvise"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getattr"}, {"reason": ["mm_segment_t->seg"], "call": "getrusage"}, {"reason": ["mm_segment_t->seg"], "call": "sched_setscheduler"}, {"reason": ["mm_segment_t->seg"], "call": "setitimer"}, {"reason": ["mm_segment_t->seg"], "call": "ioprio_get"}, {"reason": ["mm_segment_t->seg"], "call": "vfork"}, {"reason": ["vm_area_struct->vm_start"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start"], "call": "mremap"}, {"reason": ["vm_area_struct->vm_start", "mm_segment_t->seg"], "call": "prctl"}, {"reason": ["mm_segment_t->seg"], "call": "move_pages"}, {"reason": ["vm_area_struct->vm_start"], "call": "munlock"}, {"reason": ["mm_segment_t->seg"], "call": "setpriority"}, {"reason": ["mm_segment_t->seg"], "call": "clone"}, {"reason": ["vm_area_struct->vm_start"], "call": "msync"}, {"reason": ["mm_segment_t->seg"], "call": "sched_getparam"}, {"reason": ["vm_area_struct->vm_start"], "call": "mlockall"}], "mq_notify": [{"reason": ["sigval->sival_ptr"], "call": "rt_sigtimedwait"}, {"reason": ["sigevent->sigev_signo", "sigval->sival_ptr", "sigevent->sigev_notify"], "call": "mq_timedreceive"}, {"reason": ["sigevent->sigev_signo", "sigval->sival_ptr", "sigevent->sigev_notify"], "call": "timer_create"}, {"reason": ["sigval->sival_ptr"], "call": "rt_sigqueueinfo"}, {"reason": ["sigval->sival_ptr"], "call": "tgkill"}, {"reason": ["sigval->sival_ptr"], "call": "rt_tgsigqueueinfo"}, {"reason": ["sigevent->sigev_signo", "sigval->sival_ptr", "sigevent->sigev_notify"], "call": "mq_getsetattr"}, {"reason": ["sigevent->sigev_signo", "sigval->sival_ptr", "sigevent->sigev_notify"], "call": "mq_timedsend"}, {"reason": ["sigval->sival_ptr"], "call": "rt_sigreturn"}, {"reason": ["sigval->sival_ptr"], "call": "tkill"}], "sendfile": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "stat": [{"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "lstat"}, {"reason": ["__old_kernel_stat->st_nlink", "__old_kernel_stat->st_ino"], "call": "fstat"}], "newfstat": [{"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newlstat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newfstatat"}, {"reason": ["stat->st_nlink", "stat->st_ino", "compat_stat->st_nlink", "compat_stat->st_ino"], "call": "newstat"}], "timerfd_gettime": [{"reason": ["timerfd_ctx->tintv", "timerfd_ctx->expired"], "call": "timerfd_settime"}, {"reason": ["timerfd_ctx->tintv", "timerfd_ctx->expired"], "call": "timerfd_create"}], "pwritev64": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "mq_open": [{"reason": ["filename->name"], "call": "sysfs"}, {"reason": ["filename->name"], "call": "mq_unlink"}, {"reason": ["filename->name"], "call": "swapoff"}, {"reason": ["filename->name"], "call": "openat"}, {"reason": ["filename->name"], "call": "uselib"}, {"reason": ["filename->name"], "call": "renameat2"}, {"reason": ["filename->name"], "call": "symlinkat"}, {"reason": ["filename->name"], "call": "quotactl"}, {"reason": ["filename->name"], "call": "acct"}, {"reason": ["filename->name"], "call": "open"}, {"reason": ["filename->name"], "call": "unlink"}, {"reason": ["filename->name"], "call": "rmdir"}, {"reason": ["filename->name"], "call": "swapon"}, {"reason": ["filename->name"], "call": "unlinkat"}], "statfs64": [{"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "ustat"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "statfs"}, {"reason": ["kstatfs->f_ffree", "kstatfs->f_files"], "call": "fstatfs64"}], "set_thread_area": [{"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "keyctl"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "rt_sigtimedwait"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "iopl"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "msgrcv"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "kill"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_getaffinity"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "arch_prctl"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_setparam"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "ioprio_set"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getppid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "ioperm"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "mq_timedreceive"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "capget"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_setaffinity"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "signal"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "semtimedop"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "umount"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_rr_get_interval"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "rt_sigprocmask"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setsid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sigaltstack"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_setattr"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "migrate_pages"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getitimer"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setpgid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getsid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "prlimit64"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "perf_event_open"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "rt_sigaction"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getpgid"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getpriority"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sigaction"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setns"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "fork"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "get_robust_list"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "mq_timedsend"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_getscheduler"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "ptrace"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_getattr"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "getrusage"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_setscheduler"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setitimer"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "ioprio_get"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "vfork"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "prctl"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "move_pages"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "setpriority"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "clone"}, {"reason": ["thread_struct->fsindex", "thread_struct->gsindex"], "call": "sched_getparam"}], "clock_nanosleep": [{"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["k_clock->nsleep"], "call": "clock_getres"}, {"reason": ["k_clock->nsleep"], "call": "timer_delete"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["k_clock->nsleep"], "call": "timer_create"}, {"reason": ["k_clock->nsleep"], "call": "clock_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec", "k_clock->nsleep"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec", "k_clock->nsleep"], "call": "timer_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["k_clock->nsleep"], "call": "clock_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["k_clock->nsleep"], "call": "clock_adjtime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "getgroups16": [{"reason": ["group_info->ngroups"], "call": "setgroups16"}, {"reason": ["group_info->ngroups"], "call": "setgroups"}], "io_cancel": [{"reason": ["kioctx_table->nr", "kioctx->user_id"], "call": "io_getevents"}, {"reason": ["kioctx->user_id"], "call": "io_submit"}, {"reason": ["kioctx_table->nr", "kioctx->user_id"], "call": "io_setup"}, {"reason": ["kioctx_table->nr", "kioctx->user_id"], "call": "io_destroy"}], "setitimer": [{"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "settimeofday"}, {"reason": ["signal_struct->it_real_incr"], "call": "timer_create"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "adjtimex"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "waitid"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "select"}, {"reason": ["signal_struct->it_real_incr"], "call": "exit_group"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "wait4"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getrusage"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "clock_adjtime"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "alarm"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "ppoll"}], "alarm": [{"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "settimeofday"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "adjtimex"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "waitid"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "select"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "wait4"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "getrusage"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "setitimer"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "clock_adjtime"}, {"reason": ["timeval->tv_usec", "timeval->tv_sec"], "call": "ppoll"}], "futex": [{"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "recvmmsg": [{"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["msghdr->msg_flags"], "call": "recvfrom"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["msghdr->msg_flags"], "call": "sendto"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ppoll"}], "finit_module": [{"reason": ["module->args", "module->num_kp", "module_layout->base", "module_layout->size"], "call": "delete_module"}, {"reason": ["module->args", "module->num_kp", "module_layout->base", "load_info->num_debug", "module_layout->size"], "call": "init_module"}], "sendfile64": [{"reason": ["file->f_mode"], "call": "fadvise64_64"}, {"reason": ["file->f_mode"], "call": "swapoff"}, {"reason": ["file->f_mode"], "call": "memfd_create"}, {"reason": ["file->f_mode"], "call": "remap_file_pages"}, {"reason": ["file->f_mode"], "call": "dup3"}, {"reason": ["file->f_mode"], "call": "socketpair"}, {"reason": ["file->f_mode"], "call": "epoll_create1"}, {"reason": ["file->f_mode"], "call": "epoll_ctl"}, {"reason": ["file->f_mode"], "call": "flock"}, {"reason": ["file->f_mode"], "call": "openat"}, {"reason": ["file->f_mode"], "call": "uselib"}, {"reason": ["file->f_mode"], "call": "accept4"}, {"reason": ["file->f_mode"], "call": "shmat"}, {"reason": ["file->f_mode"], "call": "socket"}, {"reason": ["file->f_mode"], "call": "pipe2"}, {"reason": ["file->f_mode"], "call": "perf_event_open"}, {"reason": ["file->f_mode"], "call": "shmdt"}, {"reason": ["file->f_mode"], "call": "acct"}, {"reason": ["file->f_mode"], "call": "open"}, {"reason": ["file->f_mode"], "call": "dup"}, {"reason": ["file->f_mode"], "call": "setns"}, {"reason": ["file->f_mode"], "call": "shmctl"}, {"reason": ["file->f_mode"], "call": "swapon"}, {"reason": ["file->f_mode"], "call": "eventfd2"}, {"reason": ["file->f_mode"], "call": "mmap_pgoff"}, {"reason": ["file->f_mode"], "call": "mq_open"}, {"reason": ["file->f_mode"], "call": "msync"}, {"reason": ["file->f_mode"], "call": "open_by_handle_at"}], "mlockall": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["mm_struct->total_vm"], "call": "swapoff"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "remap_file_pages"}, {"reason": ["mm_struct->total_vm"], "call": "io_getevents"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["task_struct->personality"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["task_struct->personality"], "call": "sched_rr_get_interval"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality", "mm_struct->total_vm"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "shmdt"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "brk"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "get_mempolicy"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlockall"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "pkey_mprotect"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "madvise"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["task_struct->personality", "mm_struct->total_vm"], "call": "getrusage"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["mm_struct->total_vm"], "call": "io_setup"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "mprotect"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "mremap"}, {"reason": ["mm_struct->total_vm"], "call": "io_destroy"}, {"reason": ["mm_struct->total_vm"], "call": "mbind"}, {"reason": ["vm_area_struct->vm_start", "task_struct->personality", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "prctl"}, {"reason": ["task_struct->personality", "mm_struct->total_vm"], "call": "move_pages"}, {"reason": ["mm_struct->total_vm"], "call": "modify_ldt"}, {"reason": ["vm_area_struct->vm_start", "vm_area_struct->vm_end"], "call": "munlock"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "mincore"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["vm_area_struct->vm_start", "mm_struct->total_vm", "vm_area_struct->vm_end"], "call": "msync"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["mm_struct->total_vm"], "call": "io_cancel"}], "ppoll": [{"reason": ["task_struct->personality"], "call": "keyctl"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "rt_sigtimedwait"}, {"reason": ["task_struct->personality"], "call": "msgrcv"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fadvise64_64"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_unlink"}, {"reason": ["task_struct->personality"], "call": "kill"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapoff"}, {"reason": ["task_struct->personality"], "call": "sched_getaffinity"}, {"reason": ["task_struct->personality"], "call": "sched_setparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmod"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "memfd_create"}, {"reason": ["task_struct->personality"], "call": "ioprio_set"}, {"reason": ["task_struct->personality"], "call": "personality"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "readlinkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "io_getevents"}, {"reason": ["task_struct->personality"], "call": "getppid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchown"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedreceive"}, {"reason": ["task_struct->personality"], "call": "capget"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "utime"}, {"reason": ["task_struct->personality"], "call": "sched_setaffinity"}, {"reason": ["task_struct->personality"], "call": "signal"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "semtimedop"}, {"reason": ["task_struct->personality"], "call": "umount"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "settimeofday"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "sched_rr_get_interval"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_gettime"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "pselect6"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "uselib"}, {"reason": ["task_struct->personality"], "call": "rt_sigprocmask"}, {"reason": ["task_struct->personality"], "call": "setsid"}, {"reason": ["task_struct->personality"], "call": "sigaltstack"}, {"reason": ["task_struct->personality"], "call": "sched_setattr"}, {"reason": ["task_struct->personality"], "call": "migrate_pages"}, {"reason": ["task_struct->personality"], "call": "getitimer"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchmodat"}, {"reason": ["task_struct->personality"], "call": "setpgid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "inotify_add_watch"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_settime"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ftruncate"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timer_gettime"}, {"reason": ["task_struct->personality"], "call": "getsid"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "ioctl"}, {"reason": ["task_struct->personality"], "call": "prlimit64"}, {"reason": ["task_struct->personality"], "call": "perf_event_open"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "linkat"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "stime"}, {"reason": ["task_struct->personality"], "call": "rt_sigaction"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futimesat"}, {"reason": ["task_struct->personality"], "call": "getpgid"}, {"reason": ["poll_list->len", "timespec->tv_sec", "timespec->tv_nsec"], "call": "poll"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "select"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlink"}, {"reason": ["task_struct->personality"], "call": "getpriority"}, {"reason": ["task_struct->personality"], "call": "sigaction"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_getsetattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "faccessat"}, {"reason": ["task_struct->personality"], "call": "setns"}, {"reason": ["task_struct->personality"], "call": "fork"}, {"reason": ["task_struct->personality"], "call": "get_robust_list"}, {"reason": ["task_struct->personality", "timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_timedsend"}, {"reason": ["task_struct->personality"], "call": "sched_getscheduler"}, {"reason": ["task_struct->personality"], "call": "ptrace"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "swapon"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "epoll_wait"}, {"reason": ["task_struct->personality"], "call": "sched_getattr"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "fchownat"}, {"reason": ["task_struct->personality"], "call": "getrusage"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "timerfd_settime"}, {"reason": ["task_struct->personality"], "call": "sched_setscheduler"}, {"reason": ["task_struct->personality"], "call": "setitimer"}, {"reason": ["task_struct->personality"], "call": "ioprio_get"}, {"reason": ["task_struct->personality"], "call": "vfork"}, {"reason": ["task_struct->personality"], "call": "prctl"}, {"reason": ["task_struct->personality"], "call": "move_pages"}, {"reason": ["task_struct->personality"], "call": "setpriority"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "mq_notify"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile"}, {"reason": ["task_struct->personality"], "call": "clone"}, {"reason": ["compat_timespec->tv_sec", "compat_timespec->tv_nsec", "timespec->tv_sec", "timespec->tv_nsec"], "call": "clock_nanosleep"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "unlinkat"}, {"reason": ["task_struct->personality"], "call": "sched_getparam"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "futex"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "recvmmsg"}, {"reason": ["timespec->tv_sec", "timespec->tv_nsec"], "call": "sendfile64"}]}
\ No newline at end of file
diff --git a/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies_verbose.pretty b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies_verbose.pretty
new file mode 100644
index 0000000000..ee08b10e44
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/implicit_dependencies/without_structs/implicit_dependencies_verbose.pretty
@@ -0,0 +1,10478 @@
+{'acct': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+          {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+          {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+          {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+          {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+          {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+          {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+          {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+          {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+          {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+          {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+          {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+          {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+          {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+          {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+          {'call': 'perf_event_open', 'reason': set([('file', 'f_mode')])},
+          {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+          {'call': 'open', 'reason': set([('file', 'f_mode')])},
+          {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+          {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+          {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+          {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+          {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+          {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+          {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+          {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+          {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])}],
+ 'alarm': [{'call': 'settimeofday',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'adjtimex',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'waitid',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'getitimer',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'select',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'wait4',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'getrusage',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'setitimer',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'clock_adjtime',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])},
+           {'call': 'ppoll',
+            'reason': set([('timeval', 'tv_sec'), ('timeval', 'tv_usec')])}],
+ 'bpf': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'rt_sigtimedwait',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'swapoff', 'reason': set([('file', 'private_data')])},
+         {'call': 'sched_getaffinity',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setparam', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'memfd_create', 'reason': set([('file', 'private_data')])},
+         {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'remap_file_pages',
+          'reason': set([('file', 'private_data')])},
+         {'call': 'dup3', 'reason': set([('file', 'private_data')])},
+         {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_timedreceive',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setaffinity',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'semtimedop', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'socketpair', 'reason': set([('file', 'private_data')])},
+         {'call': 'sched_rr_get_interval',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'epoll_create1', 'reason': set([('file', 'private_data')])},
+         {'call': 'epoll_ctl', 'reason': set([('file', 'private_data')])},
+         {'call': 'flock', 'reason': set([('file', 'private_data')])},
+         {'call': 'openat', 'reason': set([('file', 'private_data')])},
+         {'call': 'uselib', 'reason': set([('file', 'private_data')])},
+         {'call': 'rt_sigprocmask', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'accept4', 'reason': set([('file', 'private_data')])},
+         {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setattr', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'migrate_pages', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'shmat', 'reason': set([('file', 'private_data')])},
+         {'call': 'socket', 'reason': set([('file', 'private_data')])},
+         {'call': 'pipe2', 'reason': set([('file', 'private_data')])},
+         {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'perf_event_open',
+          'reason': set([('file', 'private_data'), ('mm_segment_t', 'seg')])},
+         {'call': 'shmdt', 'reason': set([('file', 'private_data')])},
+         {'call': 'rt_sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'acct', 'reason': set([('file', 'private_data')])},
+         {'call': 'open', 'reason': set([('file', 'private_data')])},
+         {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'dup', 'reason': set([('file', 'private_data')])},
+         {'call': 'setns',
+          'reason': set([('file', 'private_data'), ('mm_segment_t', 'seg')])},
+         {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'get_robust_list',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_timedsend', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_getscheduler',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'shmctl', 'reason': set([('file', 'private_data')])},
+         {'call': 'swapon', 'reason': set([('file', 'private_data')])},
+         {'call': 'sched_getattr', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'sched_setscheduler',
+          'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'eventfd2', 'reason': set([('file', 'private_data')])},
+         {'call': 'mmap_pgoff', 'reason': set([('file', 'private_data')])},
+         {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'mq_open', 'reason': set([('file', 'private_data')])},
+         {'call': 'msync', 'reason': set([('file', 'private_data')])},
+         {'call': 'sched_getparam', 'reason': set([('mm_segment_t', 'seg')])},
+         {'call': 'open_by_handle_at',
+          'reason': set([('file', 'private_data')])}],
+ 'brk': [{'call': 'swapoff',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'remap_file_pages',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'io_getevents',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'migrate_pages',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'shmdt',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'get_mempolicy',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'munlockall',
+          'reason': set([('mm_struct', 'def_flags'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'pkey_mprotect',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'madvise',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'getrusage',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'io_setup',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'mprotect',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'mremap',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'io_destroy',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'mbind',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'prctl',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'move_pages',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'modify_ldt',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'munlock',
+          'reason': set([('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'mincore',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'msync',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])},
+         {'call': 'io_cancel',
+          'reason': set([('mm_struct', 'brk'),
+                         ('mm_struct', 'def_flags'),
+                         ('mm_struct', 'end_data'),
+                         ('mm_struct', 'start_brk'),
+                         ('mm_struct', 'start_data')])},
+         {'call': 'mlockall',
+          'reason': set([('mm_struct', 'def_flags'),
+                         ('vm_area_struct', 'vm_flags'),
+                         ('vm_area_struct', 'vm_start')])}],
+ 'clock_adjtime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'clock_adj')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'clock_adj')])}],
+ 'clock_nanosleep': [{'call': 'rt_sigtimedwait',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fadvise64_64',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_unlink',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'swapoff',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_getres',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'timer_delete',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'fchmod',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'memfd_create',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'readlinkat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'io_getevents',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fchown',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'utime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'settimeofday',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timer_create',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'clock_gettime',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timerfd_gettime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'pselect6',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'uselib',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fchmodat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timer_settime',
+                      'reason': set([('k_clock', 'nsleep'),
+                                     ('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'ftruncate',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timer_gettime',
+                      'reason': set([('k_clock', 'nsleep'),
+                                     ('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'ioctl',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'linkat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'stime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'futimesat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'poll',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_settime',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'select',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'unlink',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'nanosleep',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'faccessat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'swapon',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'epoll_wait',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'fchownat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'timerfd_settime',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'sendfile',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'unlinkat',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'clock_adjtime',
+                      'reason': set([('k_clock', 'nsleep')])},
+                     {'call': 'futex',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'recvmmsg',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'sendfile64',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])},
+                     {'call': 'ppoll',
+                      'reason': set([('timespec', 'tv_nsec'),
+                                     ('timespec', 'tv_sec')])}],
+ 'clock_settime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'clock_set')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'clock_set')])}],
+ 'copy_file_range': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fadvise64_64',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                     {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'read', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                     {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                     {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sync_file_range',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockname',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                     {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'old_readdir',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getpeername',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64v2',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                     {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'write', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'delete_module': [{'call': 'init_module',
+                    'reason': set([('module', 'exit'),
+                                   ('module', 'init'),
+                                   ('module', 'state')])},
+                   {'call': 'finit_module',
+                    'reason': set([('module', 'exit'),
+                                   ('module', 'init'),
+                                   ('module', 'state')])}],
+ 'dup3': [{'call': 'unshare',
+           'reason': set([('fdtable', 'max_fds'),
+                          ('files_struct', 'resize_in_progress')])},
+          {'call': 'select', 'reason': set([('fdtable', 'max_fds')])},
+          {'call': 'dup2',
+           'reason': set([('fdtable', 'max_fds'),
+                          ('files_struct', 'resize_in_progress')])}],
+ 'epoll_ctl': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_create1',
+                'reason': set([('epitem', 'nwait'),
+                               ('epoll_event', 'events')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'flock', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'epoll_wait': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'read', 'reason': set([('fd', 'flags')])},
+                {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'semtimedop',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'prlimit64',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                {'call': 'write', 'reason': set([('fd', 'flags')])},
+                {'call': 'setpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fadvise64_64': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                  {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_unlink',
+                   'reason': set([('inode', 'i_flags')])},
+                  {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'swapoff', 'reason': set([('inode', 'i_flags')])},
+                  {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                  {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchmod',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                  {'call': 'memfd_create',
+                   'reason': set([('inode', 'i_flags')])},
+                  {'call': 'readlinkat',
+                   'reason': set([('inode', 'i_flags')])},
+                  {'call': 'read', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchown',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                  {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                  {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                  {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sync_file_range',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                  {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                  {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                  {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                  {'call': 'uselib', 'reason': set([('inode', 'i_flags')])},
+                  {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                  {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+                  {'call': 'inotify_rm_watch',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchmodat', 'reason': set([('inode', 'i_flags')])},
+                  {'call': 'inotify_add_watch',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                  {'call': 'ftruncate',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                  {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                  {'call': 'ioctl',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'linkat', 'reason': set([('inode', 'i_flags')])},
+                  {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                  {'call': 'unlink', 'reason': set([('inode', 'i_flags')])},
+                  {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_getsetattr',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'faccessat',
+                   'reason': set([('inode', 'i_flags')])},
+                  {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                  {'call': 'copy_file_range',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'swapon', 'reason': set([('inode', 'i_flags')])},
+                  {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                  {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchownat', 'reason': set([('inode', 'i_flags')])},
+                  {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'write', 'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_notify',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'sendfile',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])},
+                  {'call': 'unlinkat', 'reason': set([('inode', 'i_flags')])},
+                  {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                  {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sendfile64',
+                   'reason': set([('fd', 'flags'), ('inode', 'i_flags')])}],
+ 'fallocate': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'flock', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fchdir': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'flock', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fchmod': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'flock', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fchown': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'flock', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fcntl': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'fadvise64_64',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+           {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+           {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'flock',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+           {'call': 'accept4',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'write', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fcntl64': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+             {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+             {'call': 'fadvise64_64',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+             {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+             {'call': 'writev', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+             {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+             {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'read', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+             {'call': 'utime', 'reason': set([('fd', 'flags')])},
+             {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+             {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+             {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'tee', 'reason': set([('fd', 'flags')])},
+             {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+             {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+             {'call': 'connect', 'reason': set([('fd', 'flags')])},
+             {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_ctl',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'flock',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+             {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+             {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+             {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+             {'call': 'splice', 'reason': set([('fd', 'flags')])},
+             {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+             {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl',
+              'reason': set([('fd', 'flags'),
+                             ('flock', 'l_len'),
+                             ('flock', 'l_start')])},
+             {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+             {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+             {'call': 'perf_event_open',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+             {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+             {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+             {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+             {'call': 'listen', 'reason': set([('fd', 'flags')])},
+             {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+             {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+             {'call': 'readv', 'reason': set([('fd', 'flags')])},
+             {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+             {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+             {'call': 'write', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'bind', 'reason': set([('fd', 'flags')])},
+             {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fgetxattr': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'flock', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'finit_module': [{'call': 'delete_module',
+                   'reason': set([('module', 'args'),
+                                  ('module', 'num_kp'),
+                                  ('module_layout', 'base'),
+                                  ('module_layout', 'size')])},
+                  {'call': 'init_module',
+                   'reason': set([('load_info', 'num_debug'),
+                                  ('module', 'args'),
+                                  ('module', 'num_kp'),
+                                  ('module_layout', 'base'),
+                                  ('module_layout', 'size')])}],
+ 'flistxattr': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                {'call': 'read', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+                {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                {'call': 'write', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'flock': [{'call': 'syncfs',
+            'reason': set([('fd', 'flags'), ('super_block', 's_flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'fadvise64_64',
+            'reason': set([('fd', 'flags'),
+                           ('file', 'f_mode'),
+                           ('super_block', 's_flags')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+           {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+           {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'umount', 'reason': set([('super_block', 's_flags')])},
+           {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+           {'call': 'accept4',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open',
+            'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+           {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'quotactl', 'reason': set([('super_block', 's_flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'swapon',
+            'reason': set([('file', 'f_mode'), ('super_block', 's_flags')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'write', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+           {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+           {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fremovexattr': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                  {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                  {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                  {'call': 'read', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                  {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                  {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                  {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sync_file_range',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                  {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                  {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                  {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                  {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                  {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+                  {'call': 'inotify_rm_watch',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                  {'call': 'inotify_add_watch',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                  {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                  {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                  {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                  {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                  {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                  {'call': 'copy_file_range',
+                   'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                  {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                  {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                  {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                  {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                  {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                  {'call': 'write', 'reason': set([('fd', 'flags')])},
+                  {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                  {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                  {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                  {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fsetxattr': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'flock', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'fstat': [{'call': 'lstat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])},
+           {'call': 'stat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])}],
+ 'fstatfs': [{'call': 'ustat',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'statfs',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'fstatfs64',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])},
+             {'call': 'statfs64',
+              'reason': set([('kstatfs', 'f_ffree'),
+                             ('kstatfs', 'f_files')])}],
+ 'fstatfs64': [{'call': 'ustat',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'fstatfs',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'statfs',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])},
+               {'call': 'statfs64',
+                'reason': set([('kstatfs', 'f_ffree'),
+                               ('kstatfs', 'f_files')])}],
+ 'ftruncate': [{'call': 'fadvise64_64',
+                'reason': set([('file', 'f_mode'), ('inode', 'i_flags')])},
+               {'call': 'mq_unlink', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'swapoff',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags')])},
+               {'call': 'fchmod', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'memfd_create',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'dup3',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'readlinkat', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'fchown', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('inode', 'i_flags')])},
+               {'call': 'socketpair',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'epoll_create1',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'flock',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'openat',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'uselib',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags')])},
+               {'call': 'accept4',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'fchmodat', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('inode', 'i_flags')])},
+               {'call': 'shmat',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'socket',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'pipe2',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'ioctl', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'linkat', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'shmdt',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'acct',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'open',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'unlink', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('file', 'f_flags'), ('inode', 'i_flags')])},
+               {'call': 'faccessat', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'dup',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'setns',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('inode', 'i_flags')])},
+               {'call': 'shmctl',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'swapon',
+                'reason': set([('file', 'f_flags'),
+                               ('file', 'f_mode'),
+                               ('inode', 'i_flags')])},
+               {'call': 'fchownat', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'eventfd2',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'mmap_pgoff',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'mq_notify', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'sendfile', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'mq_open',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'msync',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'unlinkat', 'reason': set([('inode', 'i_flags')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+               {'call': 'sendfile64', 'reason': set([('inode', 'i_flags')])}],
+ 'futex': [{'call': 'rt_sigtimedwait',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fadvise64_64',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'swapoff',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchmod',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'memfd_create',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'readlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'io_getevents',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchown',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'utime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'semtimedop',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'settimeofday',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'pselect6',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'uselib',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchmodat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ftruncate',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ioctl',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'linkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'stime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'futimesat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'poll',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'select',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'nanosleep',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'faccessat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'swapon',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'epoll_wait',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'fchownat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_notify',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'clock_nanosleep',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'unlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'recvmmsg',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile64',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ppoll',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])}],
+ 'futimesat': [{'call': 'rt_sigtimedwait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fadvise64_64',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_unlink',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchmod', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'memfd_create',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'readlinkat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'io_getevents',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchown', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'utime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'semtimedop',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'settimeofday',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'adjtimex', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'waitid', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'getitimer', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timer_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ftruncate',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timer_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ioctl', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'select',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'faccessat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'wait4', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'epoll_wait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'getrusage', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'setitimer', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'mq_notify',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'clock_nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'clock_adjtime',
+                'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'alarm', 'reason': set([('timeval', 'tv_usec')])},
+               {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile64',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ppoll',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timeval', 'tv_usec')])}],
+ 'get_mempolicy': [{'call': 'keyctl',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'kill',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'set_mempolicy',
+                    'reason': set([('mempolicy', 'mode'),
+                                   ('task_struct', 'il_prev')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'getpriority',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'fork',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'mbind', 'reason': set([('mempolicy', 'mode')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'setpriority',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'il_prev')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'il_prev')])}],
+ 'getdents': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+              {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+              {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'writev', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_setparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+              {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioprio_set',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'read', 'reason': set([('fd', 'flags')])},
+              {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+              {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'utime', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+              {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+              {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'semtimedop',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'tee', 'reason': set([('fd', 'flags')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'connect', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+              {'call': 'flock', 'reason': set([('fd', 'flags')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+              {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaltstack',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+              {'call': 'splice', 'reason': set([('fd', 'flags')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+              {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+              {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+              {'call': 'listen', 'reason': set([('fd', 'flags')])},
+              {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'get_robust_list',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+              {'call': 'sched_getattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ioprio_get',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'readv', 'reason': set([('fd', 'flags')])},
+              {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+              {'call': 'write', 'reason': set([('fd', 'flags')])},
+              {'call': 'setpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+              {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_getparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'bind', 'reason': set([('fd', 'flags')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'getdents64': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'rt_sigtimedwait',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_getaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_setparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioprio_set',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'read', 'reason': set([('fd', 'flags')])},
+                {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_setaffinity',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'semtimedop',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'rt_sigprocmask',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaltstack',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+                {'call': 'inotify_rm_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                {'call': 'prlimit64',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'rt_sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                {'call': 'getpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sigaction',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'get_robust_list',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('fd', 'flags'), ('mm_segment_t', 'seg')])},
+                {'call': 'sched_getscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                {'call': 'sched_getattr',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_setscheduler',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'setitimer',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'ioprio_get',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                {'call': 'write', 'reason': set([('fd', 'flags')])},
+                {'call': 'setpriority',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'sched_getparam',
+                 'reason': set([('mm_segment_t', 'seg')])},
+                {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'getgroups16': [{'call': 'setgroups16',
+                  'reason': set([('group_info', 'ngroups')])},
+                 {'call': 'setgroups',
+                  'reason': set([('group_info', 'ngroups')])}],
+ 'getitimer': [{'call': 'timer_create',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'exit_group',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'setitimer',
+                'reason': set([('signal_struct', 'it_real_incr')])}],
+ 'getrlimit': [{'call': 'setrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'old_getrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'prlimit64',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])}],
+ 'getrusage': [{'call': 'timer_create',
+                'reason': set([('signal_struct', 'maxrss')])},
+               {'call': 'exit_group',
+                'reason': set([('signal_struct', 'maxrss')])}],
+ 'getsockopt': [{'call': 'accept4',
+                 'reason': set([('proto_ops', 'compat_getsockopt')])}],
+ 'init_module': [{'call': 'delete_module',
+                  'reason': set([('module', 'args'),
+                                 ('module', 'num_kp'),
+                                 ('module_layout', 'base'),
+                                 ('module_layout', 'size')])},
+                 {'call': 'finit_module',
+                  'reason': set([('load_info', 'len'),
+                                 ('load_info', 'num_debug'),
+                                 ('module', 'args'),
+                                 ('module', 'num_kp'),
+                                 ('module_layout', 'base'),
+                                 ('module_layout', 'size')])}],
+ 'inotify_add_watch': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                       {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fadvise64_64',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'pwritev64',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'fremovexattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'readahead',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                       {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                       {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                       {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                       {'call': 'signalfd4',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'read', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                       {'call': 'mq_timedreceive',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                       {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                       {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fsetxattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                       {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                       {'call': 'sync_file_range',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                       {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                       {'call': 'getsockname',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'epoll_ctl',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                       {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                       {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                       {'call': 'old_readdir',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'inotify_rm_watch',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'utimensat',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                       {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                       {'call': 'ftruncate',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                       {'call': 'getpeername',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'setsockopt',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                       {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                       {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'pwritev64v2',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'futimesat',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                       {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                       {'call': 'getsockopt',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'mq_getsetattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'fdatasync',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'getdents64',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                       {'call': 'copy_file_range',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'mq_timedsend',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'fgetxattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fallocate',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'epoll_wait',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                       {'call': 'preadv64v2',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                       {'call': 'fstatfs64',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'write', 'reason': set([('fd', 'flags')])},
+                       {'call': 'mq_notify',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                       {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                       {'call': 'flistxattr',
+                        'reason': set([('fd', 'flags')])},
+                       {'call': 'sendfile64',
+                        'reason': set([('fd', 'flags')])}],
+ 'inotify_rm_watch': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                      {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fadvise64_64',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fremovexattr',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                      {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                      {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                      {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                      {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                      {'call': 'read', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                      {'call': 'mq_timedreceive',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                      {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                      {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                      {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                      {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                      {'call': 'sync_file_range',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                      {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                      {'call': 'getsockname',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                      {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                      {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                      {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                      {'call': 'old_readdir',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                      {'call': 'inotify_add_watch',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                      {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                      {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                      {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                      {'call': 'getpeername',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'setsockopt',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                      {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                      {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'perf_event_open',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'pwritev64v2',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                      {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                      {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                      {'call': 'getsockopt',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'mq_getsetattr',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                      {'call': 'getdents64',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                      {'call': 'copy_file_range',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'mq_timedsend',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                      {'call': 'epoll_wait',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                      {'call': 'preadv64v2',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                      {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                      {'call': 'write', 'reason': set([('fd', 'flags')])},
+                      {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                      {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                      {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                      {'call': 'flistxattr',
+                       'reason': set([('fd', 'flags')])},
+                      {'call': 'sendfile64',
+                       'reason': set([('fd', 'flags')])}],
+ 'io_cancel': [{'call': 'io_getevents',
+                'reason': set([('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr')])},
+               {'call': 'io_submit', 'reason': set([('kioctx', 'user_id')])},
+               {'call': 'io_setup',
+                'reason': set([('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr')])},
+               {'call': 'io_destroy',
+                'reason': set([('kioctx', 'user_id'),
+                               ('kioctx_table', 'nr')])}],
+ 'io_destroy': [{'call': 'io_getevents',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr')])},
+                {'call': 'io_submit',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id')])},
+                {'call': 'io_setup',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr')])},
+                {'call': 'io_cancel',
+                 'reason': set([('kioctx', 'max_reqs'),
+                                ('kioctx', 'mmap_base'),
+                                ('kioctx', 'mmap_size'),
+                                ('kioctx', 'user_id'),
+                                ('kioctx_table', 'nr')])}],
+ 'io_getevents': [{'call': 'keyctl',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'rt_sigtimedwait',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'msgrcv',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'kill',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getaffinity',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setparam',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'ioprio_set',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getppid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'capget',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setaffinity',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'signal',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'semtimedop',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'umount',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_rr_get_interval',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'rt_sigprocmask',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setsid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sigaltstack',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setattr',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'migrate_pages',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getitimer',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setpgid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getsid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'prlimit64',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'rt_sigaction',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getpgid',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getpriority',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sigaction',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setns',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'fork',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'io_submit',
+                   'reason': set([('kioctx', 'user_id')])},
+                  {'call': 'get_robust_list',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getscheduler',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'ptrace',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getattr',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'getrusage',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_setscheduler',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setitimer',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'ioprio_get',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'vfork',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'io_setup',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr')])},
+                  {'call': 'io_destroy',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr')])},
+                  {'call': 'prctl',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'move_pages',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'setpriority',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'clone',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'sched_getparam',
+                   'reason': set([('task_struct', 'timer_slack_ns')])},
+                  {'call': 'io_cancel',
+                   'reason': set([('kioctx', 'user_id'),
+                                  ('kioctx_table', 'nr')])}],
+ 'io_setup': [{'call': 'io_getevents',
+               'reason': set([('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_submit',
+               'reason': set([('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_destroy',
+               'reason': set([('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])},
+              {'call': 'io_cancel',
+               'reason': set([('kioctx', 'max_reqs'),
+                              ('kioctx', 'mmap_base'),
+                              ('kioctx', 'mmap_size'),
+                              ('kioctx', 'req_batch')])}],
+ 'io_submit': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setparam',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_set',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'semtimedop',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaltstack',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'migrate_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prlimit64',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'perf_event_open',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'get_robust_list',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getrusage',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_get',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'move_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getparam',
+                'reason': set([('mm_segment_t', 'seg')])}],
+ 'ioctl': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'flock', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'write', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'ioperm': [{'call': 'keyctl',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'iopl',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'msgrcv',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'kill',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setparam',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ioprio_set',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getppid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'capget',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'signal',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'semtimedop',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'umount',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setsid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sigaltstack',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setattr',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'migrate_pages',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getitimer',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setpgid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getsid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'prlimit64',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'perf_event_open',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getpgid',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getpriority',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sigaction',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setns',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'fork',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'get_robust_list',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ptrace',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getattr',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'getrusage',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setitimer',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'ioprio_get',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'vfork',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'prctl',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'move_pages',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'setpriority',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'clone',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])},
+            {'call': 'sched_getparam',
+             'reason': set([('thread_struct', 'io_bitmap_ptr')])}],
+ 'keyctl': [{'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'umount', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sigaltstack', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'rt_sigaction', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'request_key',
+             'reason': set([('key', 'description'),
+                            ('key', 'perm'),
+                            ('key', 'quotalen'),
+                            ('key', 'serial'),
+                            ('key_type', 'name'),
+                            ('key_type', 'read')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'getpriority', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'mq_timedsend', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'pid')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'setpriority', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'pid')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'pid')])}],
+ 'llseek': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'flock', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'lseek': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'flock', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'write', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'lstat': [{'call': 'stat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])},
+           {'call': 'fstat',
+            'reason': set([('__old_kernel_stat', 'st_ino'),
+                           ('__old_kernel_stat', 'st_nlink')])}],
+ 'madvise': [{'call': 'remap_file_pages',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'shmdt',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'brk',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'get_mempolicy',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'munlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'pkey_mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mremap',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'prctl',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'munlock',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mincore',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'msync',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])}],
+ 'migrate_pages': [{'call': 'keyctl',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getppid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioperm',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'capget',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'signal',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'umount',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setsid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getitimer',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setpgid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getsid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getpgid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getpriority',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sigaction',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setns',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ptrace',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getrusage',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setitimer',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'vfork',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'prctl',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'move_pages',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setpriority',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'clone',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('mm_segment_t', 'seg')])}],
+ 'mincore': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setparam',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'semtimedop', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sigaltstack',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setattr',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'migrate_pages',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'perf_event_open',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'shmdt',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'brk', 'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'getpriority',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'get_mempolicy',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'get_robust_list',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'munlockall',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'pkey_mprotect',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'madvise',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'sched_getattr',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mprotect',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'mremap',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'prctl',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'munlock',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'setpriority',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'msync',
+              'reason': set([('vm_area_struct', 'vm_start')])},
+             {'call': 'sched_getparam',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mlockall',
+              'reason': set([('vm_area_struct', 'vm_start')])}],
+ 'mkdirat': [{'call': 'syncfs', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'fadvise64_64',
+              'reason': set([('super_block', 's_flags')])},
+             {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'umount', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'quotactl',
+              'reason': set([('super_block', 's_flags')])},
+             {'call': 'swapon', 'reason': set([('super_block', 's_flags')])}],
+ 'mknodat': [{'call': 'syncfs', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'fadvise64_64',
+              'reason': set([('super_block', 's_flags')])},
+             {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'umount', 'reason': set([('super_block', 's_flags')])},
+             {'call': 'quotactl',
+              'reason': set([('super_block', 's_flags')])},
+             {'call': 'swapon', 'reason': set([('super_block', 's_flags')])}],
+ 'mlockall': [{'call': 'keyctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'swapoff', 'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'io_getevents',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'getppid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'shmdt',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'brk',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'get_mempolicy',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'munlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'pkey_mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'madvise',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'io_setup',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'mremap',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'io_destroy',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'mbind', 'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'prctl',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('task_struct', 'personality')])},
+              {'call': 'modify_ldt',
+               'reason': set([('mm_struct', 'total_vm')])},
+              {'call': 'munlock',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mincore',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'clone',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'msync',
+               'reason': set([('mm_struct', 'total_vm'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'io_cancel',
+               'reason': set([('mm_struct', 'total_vm')])}],
+ 'modify_ldt': [{'call': 'get_thread_area',
+                 'reason': set([('user_desc', 'base_addr'),
+                                ('user_desc', 'contents'),
+                                ('user_desc', 'entry_number'),
+                                ('user_desc', 'limit'),
+                                ('user_desc', 'limit_in_pages'),
+                                ('user_desc', 'read_exec_only'),
+                                ('user_desc', 'seg_32bit'),
+                                ('user_desc', 'seg_not_present'),
+                                ('user_desc', 'useable')])},
+                {'call': 'set_thread_area',
+                 'reason': set([('user_desc', 'base_addr'),
+                                ('user_desc', 'contents'),
+                                ('user_desc', 'entry_number'),
+                                ('user_desc', 'limit'),
+                                ('user_desc', 'limit_in_pages'),
+                                ('user_desc', 'read_exec_only'),
+                                ('user_desc', 'seg_32bit'),
+                                ('user_desc', 'seg_not_present'),
+                                ('user_desc', 'useable')])}],
+ 'mount': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getrusage',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'move_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'personality')])}],
+ 'mprotect': [{'call': 'keyctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'getppid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'shmdt',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'brk',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'get_mempolicy',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'munlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'pkey_mprotect',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'madvise',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mremap',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'prctl',
+               'reason': set([('task_struct', 'personality'),
+                              ('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'munlock',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mincore',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'clone',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'msync',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mlockall',
+               'reason': set([('vm_area_struct', 'vm_end'),
+                              ('vm_area_struct', 'vm_flags'),
+                              ('vm_area_struct', 'vm_start')])}],
+ 'mq_getsetattr': [{'call': 'mq_timedreceive',
+                    'reason': set([('mq_attr', 'mq_flags')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mq_attr', 'mq_flags')])},
+                   {'call': 'mq_notify',
+                    'reason': set([('mq_attr', 'mq_flags')])},
+                   {'call': 'mq_open',
+                    'reason': set([('mq_attr', 'mq_flags')])}],
+ 'mq_notify': [{'call': 'rt_sigtimedwait',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'timer_create',
+                'reason': set([('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'rt_sigqueueinfo',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'tgkill', 'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'rt_tgsigqueueinfo',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('sigevent', 'sigev_notify'),
+                               ('sigevent', 'sigev_signo'),
+                               ('sigval', 'sival_ptr')])},
+               {'call': 'rt_sigreturn',
+                'reason': set([('sigval', 'sival_ptr')])},
+               {'call': 'tkill', 'reason': set([('sigval', 'sival_ptr')])}],
+ 'mq_open': [{'call': 'sysfs', 'reason': set([('filename', 'name')])},
+             {'call': 'mq_unlink', 'reason': set([('filename', 'name')])},
+             {'call': 'swapoff', 'reason': set([('filename', 'name')])},
+             {'call': 'openat', 'reason': set([('filename', 'name')])},
+             {'call': 'uselib', 'reason': set([('filename', 'name')])},
+             {'call': 'renameat2', 'reason': set([('filename', 'name')])},
+             {'call': 'symlinkat', 'reason': set([('filename', 'name')])},
+             {'call': 'quotactl', 'reason': set([('filename', 'name')])},
+             {'call': 'acct', 'reason': set([('filename', 'name')])},
+             {'call': 'open', 'reason': set([('filename', 'name')])},
+             {'call': 'unlink', 'reason': set([('filename', 'name')])},
+             {'call': 'rmdir', 'reason': set([('filename', 'name')])},
+             {'call': 'swapon', 'reason': set([('filename', 'name')])},
+             {'call': 'unlinkat', 'reason': set([('filename', 'name')])}],
+ 'mq_timedreceive': [{'call': 'msgrcv', 'reason': set([('msg_msg', 'm_ts')])},
+                     {'call': 'fadvise64_64',
+                      'reason': set([('file', 'f_mode')])},
+                     {'call': 'swapoff',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'memfd_create',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'remap_file_pages',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'dup3',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'socketpair',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'epoll_create1',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'epoll_ctl',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'flock',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'openat',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'uselib',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'accept4',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'shmat',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'socket',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'pipe2',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'shmdt',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'acct',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'open',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('file', 'f_flags'),
+                                     ('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize')])},
+                     {'call': 'dup',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'setns',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize'),
+                                     ('msg_msg', 'm_ts')])},
+                     {'call': 'shmctl',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'swapon',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'eventfd2',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'mmap_pgoff',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'msgsnd', 'reason': set([('msg_msg', 'm_ts')])},
+                     {'call': 'mq_notify',
+                      'reason': set([('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize')])},
+                     {'call': 'mq_open',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode'),
+                                     ('mq_attr', 'mq_curmsgs'),
+                                     ('mq_attr', 'mq_msgsize')])},
+                     {'call': 'msync',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])},
+                     {'call': 'open_by_handle_at',
+                      'reason': set([('file', 'f_flags'),
+                                     ('file', 'f_mode')])}],
+ 'mq_timedsend': [{'call': 'fadvise64_64',
+                   'reason': set([('file', 'f_mode')])},
+                  {'call': 'swapoff',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'memfd_create',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'remap_file_pages',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'dup3',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize')])},
+                  {'call': 'socketpair',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'epoll_create1',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'epoll_ctl',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'flock',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'openat',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'uselib',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'accept4',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'shmat',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'socket',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'pipe2',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'shmdt',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'acct',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'open',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'mq_getsetattr',
+                   'reason': set([('file', 'f_flags'),
+                                  ('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize')])},
+                  {'call': 'dup',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'setns',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'shmctl',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'swapon',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'eventfd2',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'mmap_pgoff',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'mq_notify',
+                   'reason': set([('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize')])},
+                  {'call': 'mq_open',
+                   'reason': set([('file', 'f_flags'),
+                                  ('file', 'f_mode'),
+                                  ('mq_attr', 'mq_curmsgs'),
+                                  ('mq_attr', 'mq_maxmsg'),
+                                  ('mq_attr', 'mq_msgsize')])},
+                  {'call': 'msync',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+                  {'call': 'open_by_handle_at',
+                   'reason': set([('file', 'f_flags'), ('file', 'f_mode')])}],
+ 'mremap': [{'call': 'keyctl',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'swapoff', 'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioprio_set',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'personality',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'io_getevents',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'prlimit64',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'shmdt',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'brk',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'get_mempolicy',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ptrace',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'munlockall',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'pkey_mprotect',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'madvise',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getrusage',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioprio_get',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'io_setup', 'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'mprotect',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'io_destroy',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'mbind', 'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'prctl',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'move_pages',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('task_struct', 'personality')])},
+            {'call': 'modify_ldt',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'munlock',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mincore',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'msync',
+             'reason': set([('mm_struct', 'map_count'),
+                            ('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'io_cancel',
+             'reason': set([('mm_struct', 'map_count')])},
+            {'call': 'mlockall',
+             'reason': set([('vm_area_struct', 'vm_end'),
+                            ('vm_area_struct', 'vm_flags'),
+                            ('vm_area_struct', 'vm_pgoff'),
+                            ('vm_area_struct', 'vm_start')])}],
+ 'msgctl': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgrcv',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'mq_unlink',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgget',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setparam',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semtimedop',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'shmget',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semget',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'shmat',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'perf_event_open',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setns',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'get_robust_list',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'shmctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'sched_getattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgsnd',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_open',
+             'reason': set([('ipc_namespace', 'msg_ctlmnb')])},
+            {'call': 'sched_getparam',
+             'reason': set([('mm_segment_t', 'seg')])}],
+ 'msgrcv': [{'call': 'mq_timedreceive', 'reason': set([('msg_msg', 'm_ts')])},
+            {'call': 'mq_timedsend', 'reason': set([('msg_msg', 'm_ts')])},
+            {'call': 'msgsnd', 'reason': set([('msg_msg', 'm_ts')])}],
+ 'msgsnd': [{'call': 'msgrcv',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'mq_unlink',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'msgget',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'semtimedop',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'semctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'shmget',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'msgctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'semget',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'shmat',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'setns',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'shmctl',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])},
+            {'call': 'mq_open',
+             'reason': set([('ipc_namespace', 'msg_ctlmax')])}],
+ 'msync': [{'call': 'remap_file_pages',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'shmdt',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'brk',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'get_mempolicy',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'munlockall',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'pkey_mprotect',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'madvise',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'mprotect',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'mremap',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'prctl',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'munlock',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'mincore',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])},
+           {'call': 'mlockall',
+            'reason': set([('vm_area_struct', 'vm_flags'),
+                           ('vm_area_struct', 'vm_start')])}],
+ 'munlock': [{'call': 'remap_file_pages',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'shmdt',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'brk',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'get_mempolicy',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'munlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'pkey_mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'madvise',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mprotect',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mremap',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'prctl',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mincore',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'msync',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])},
+             {'call': 'mlockall',
+              'reason': set([('vm_area_struct', 'vm_end'),
+                             ('vm_area_struct', 'vm_start')])}],
+ 'munlockall': [{'call': 'remap_file_pages',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'shmdt',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'brk',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'pkey_mprotect',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'madvise',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mprotect',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mremap',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'prctl',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'munlock',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mincore',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'msync',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])},
+                {'call': 'mlockall',
+                 'reason': set([('vm_area_struct', 'vm_end'),
+                                ('vm_area_struct', 'vm_start')])}],
+ 'nanosleep': [{'call': 'rt_sigtimedwait',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fadvise64_64',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_unlink',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'swapoff',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchmod',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'memfd_create',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'readlinkat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'io_getevents',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchown',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'utime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'semtimedop',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'settimeofday',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'pselect6',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'uselib',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchmodat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timer_settime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'ftruncate',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timer_gettime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'ioctl',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'linkat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'stime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'futimesat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'poll',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'select',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'unlink',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'faccessat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'swapon',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'epoll_wait',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'fchownat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'mq_notify',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'sendfile',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'clock_nanosleep',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'unlinkat',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'futex',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'recvmmsg',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'sendfile64',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])},
+               {'call': 'ppoll',
+                'reason': set([('timespec', 'tv_nsec'),
+                               ('timespec', 'tv_sec')])}],
+ 'newfstat': [{'call': 'newlstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newfstatat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])}],
+ 'newfstatat': [{'call': 'newlstat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])},
+                {'call': 'newstat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])},
+                {'call': 'newfstat',
+                 'reason': set([('compat_stat', 'st_ino'),
+                                ('compat_stat', 'st_nlink'),
+                                ('stat', 'st_ino'),
+                                ('stat', 'st_nlink')])}],
+ 'newlstat': [{'call': 'newfstatat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])},
+              {'call': 'newfstat',
+               'reason': set([('compat_stat', 'st_ino'),
+                              ('compat_stat', 'st_nlink'),
+                              ('stat', 'st_ino'),
+                              ('stat', 'st_nlink')])}],
+ 'newstat': [{'call': 'newlstat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])},
+             {'call': 'newfstatat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])},
+             {'call': 'newfstat',
+              'reason': set([('compat_stat', 'st_ino'),
+                             ('compat_stat', 'st_nlink'),
+                             ('stat', 'st_ino'),
+                             ('stat', 'st_nlink')])}],
+ 'newuname': [{'call': 'keyctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'msgrcv',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getppid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'get_robust_list',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getattr',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'prctl',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'move_pages',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'setpriority',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'clone',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('task_struct', 'personality')])}],
+ 'old_getrlimit': [{'call': 'setrlimit',
+                    'reason': set([('rlimit', 'rlim_cur'),
+                                   ('rlimit', 'rlim_max')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('rlimit', 'rlim_cur'),
+                                   ('rlimit', 'rlim_max')])}],
+ 'old_readdir': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                 {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                 {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                 {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                 {'call': 'read', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                 {'call': 'mq_timedreceive',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                 {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                 {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                 {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                 {'call': 'sync_file_range',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                 {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+                 {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                 {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                 {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                 {'call': 'inotify_rm_watch',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                 {'call': 'inotify_add_watch',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                 {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                 {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                 {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+                 {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                 {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+                 {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                 {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                 {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                 {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                 {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                 {'call': 'copy_file_range',
+                  'reason': set([('fd', 'flags')])},
+                 {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                 {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                 {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                 {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                 {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                 {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                 {'call': 'write', 'reason': set([('fd', 'flags')])},
+                 {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                 {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                 {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                 {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                 {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'olduname': [{'call': 'keyctl',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'msgrcv',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'kill',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setparam',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_set',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'personality',
+               'reason': set([('task_struct', 'personality')])},
+              {'call': 'getppid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'capget',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'signal',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'semtimedop',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'umount',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setsid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaltstack',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setattr',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getitimer',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setpgid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getsid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'prlimit64',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'perf_event_open',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getpgid',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getpriority',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sigaction',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setns',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'fork',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'get_robust_list',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ptrace',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getattr',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'getrusage',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setitimer',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'ioprio_get',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'vfork',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'prctl',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'setpriority',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'clone',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])},
+              {'call': 'sched_getparam',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('task_struct', 'personality')])}],
+ 'perf_event_open': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'keyctl',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'rt_sigtimedwait',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'iopl',
+                      'reason': set([('mm_segment_t', 'seg')])},
+                     {'call': 'msgrcv',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fadvise64_64',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'kill',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sched_getaffinity',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sched_setparam',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ioprio_set',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'read', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getppid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ioperm',
+                      'reason': set([('mm_segment_t', 'seg')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'flags'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'capget',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sched_setaffinity',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                     {'call': 'signal',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setreuid',
+                      'reason': set([('task_struct', 'flags')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'umount',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sync_file_range',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockname',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                     {'call': 'rt_sigprocmask',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'setsid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sigaltstack',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sched_setattr',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'old_readdir',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'migrate_pages',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'getitimer',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setpgid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getpeername',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'getsid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'prlimit64',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64v2',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'rt_sigaction',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getpgid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getpriority',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sigaction',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'setns',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fork',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'get_robust_list',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'copy_file_range',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'flags'),
+                                     ('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sched_getscheduler',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ptrace',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sched_getattr',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'getrusage',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sched_setscheduler',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setresuid',
+                      'reason': set([('task_struct', 'flags')])},
+                     {'call': 'setitimer',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'ioprio_get',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'vfork',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'setuid',
+                      'reason': set([('task_struct', 'flags')])},
+                     {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'prctl',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'move_pages',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'write', 'reason': set([('fd', 'flags')])},
+                     {'call': 'setpriority',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                     {'call': 'clone',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'sched_getparam',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'flags')])},
+                     {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'pivot_root': [{'call': 'mq_unlink',
+                 'reason': set([('vfsmount', 'mnt_flags')])},
+                {'call': 'umount',
+                 'reason': set([('vfsmount', 'mnt_flags')])},
+                {'call': 'getcwd',
+                 'reason': set([('vfsmount', 'mnt_flags')])},
+                {'call': 'acct', 'reason': set([('vfsmount', 'mnt_flags')])},
+                {'call': 'mq_open',
+                 'reason': set([('vfsmount', 'mnt_flags')])}],
+ 'pkey_alloc': [{'call': 'swapoff',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_getevents',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'pkey_free',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'migrate_pages',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'shmdt',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'brk',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'get_mempolicy',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'getrusage',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_setup',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'mremap',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_destroy',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'mbind',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'prctl',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'move_pages',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'modify_ldt',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'mincore',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'msync',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])},
+                {'call': 'io_cancel',
+                 'reason': set([('mm_context_t', 'pkey_allocation_map')])}],
+ 'pkey_mprotect': [{'call': 'keyctl',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'kill',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'personality',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'remap_file_pages',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'getppid',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'capget',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'signal',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'umount',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'setsid',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'getitimer',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'setpgid',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'getsid',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'shmdt',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'getpgid',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'brk',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'getpriority',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'sigaction',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'setns',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'fork',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'get_mempolicy',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'ptrace',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'munlockall',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'madvise',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'getrusage',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'setitimer',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'vfork',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'mprotect',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'mremap',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'prctl',
+                    'reason': set([('task_struct', 'personality'),
+                                   ('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'move_pages',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'munlock',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'setpriority',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'mincore',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'clone',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'msync',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('task_struct', 'personality')])},
+                   {'call': 'mlockall',
+                    'reason': set([('vm_area_struct', 'vm_end'),
+                                   ('vm_area_struct', 'vm_flags'),
+                                   ('vm_area_struct', 'vm_start')])}],
+ 'poll': [{'call': 'ppoll', 'reason': set([('poll_list', 'len')])}],
+ 'ppoll': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fadvise64_64',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'swapoff',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchmod',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'memfd_create',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'readlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'io_getevents',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchown',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'utime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'settimeofday',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'timerfd_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'pselect6',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'uselib',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchmodat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'ftruncate',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'timer_gettime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioctl',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'linkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'stime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'futimesat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'poll',
+            'reason': set([('poll_list', 'len'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'select',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'unlink',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'nanosleep',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'faccessat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'personality'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'swapon',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'epoll_wait',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'fchownat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'getrusage',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'timerfd_settime',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'move_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_notify',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'clock_nanosleep',
+            'reason': set([('compat_timespec', 'tv_nsec'),
+                           ('compat_timespec', 'tv_sec'),
+                           ('timespec', 'tv_nsec'),
+                           ('timespec', 'tv_sec')])},
+           {'call': 'unlinkat',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'futex',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'recvmmsg',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])},
+           {'call': 'sendfile64',
+            'reason': set([('timespec', 'tv_nsec'), ('timespec', 'tv_sec')])}],
+ 'prctl': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'kill',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'swapoff', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'remap_file_pages',
+            'reason': set([('mm_struct', 'flags')])},
+           {'call': 'io_getevents', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'migrate_pages',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'shmdt', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'brk', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setns',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'fork',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'get_mempolicy', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'getrusage',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'vfork',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+           {'call': 'io_setup', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'mremap', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'io_destroy', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'mbind', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'move_pages',
+            'reason': set([('mm_struct', 'flags'),
+                           ('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'modify_ldt', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'mincore', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'clone',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'msync', 'reason': set([('mm_struct', 'flags')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'flags'),
+                           ('task_struct', 'personality'),
+                           ('task_struct', 'timer_slack_ns')])},
+           {'call': 'io_cancel', 'reason': set([('mm_struct', 'flags')])}],
+ 'pread64': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+             {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+             {'call': 'fadvise64_64',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+             {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+             {'call': 'writev', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+             {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'read', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+             {'call': 'utime', 'reason': set([('fd', 'flags')])},
+             {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+             {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+             {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'tee', 'reason': set([('fd', 'flags')])},
+             {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+             {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+             {'call': 'connect', 'reason': set([('fd', 'flags')])},
+             {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_ctl',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'flock',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+             {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+             {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+             {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+             {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+             {'call': 'splice', 'reason': set([('fd', 'flags')])},
+             {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+             {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+             {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+             {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+             {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+             {'call': 'perf_event_open',
+              'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+             {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+             {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+             {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+             {'call': 'listen', 'reason': set([('fd', 'flags')])},
+             {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+             {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+             {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+             {'call': 'readv', 'reason': set([('fd', 'flags')])},
+             {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+             {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+             {'call': 'write', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'bind', 'reason': set([('fd', 'flags')])},
+             {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+             {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'preadv': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+            {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+            {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+            {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+            {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+            {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+            {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+            {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+            {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+            {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+            {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+            {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+            {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+            {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+            {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+            {'call': 'perf_event_open', 'reason': set([('file', 'f_mode')])},
+            {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+            {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+            {'call': 'open', 'reason': set([('file', 'f_mode')])},
+            {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+            {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+            {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+            {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+            {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+            {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+            {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+            {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('file', 'f_mode')])}],
+ 'preadv2': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'perf_event_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])}],
+ 'preadv64': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'perf_event_open',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])}],
+ 'preadv64v2': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+                {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+                {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+                {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+                {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+                {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_mode')])}],
+ 'prlimit64': [{'call': 'setrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'old_getrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])}],
+ 'pselect6': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'rt_sigtimedwait',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fadvise64_64',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'swapoff',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchmod',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'memfd_create',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ioprio_set',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'readlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'io_getevents',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchown',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'utime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_setaffinity',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'semtimedop',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'settimeofday',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'uselib',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'rt_sigprocmask',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaltstack',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sched_setattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'migrate_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchmodat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'inotify_add_watch',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ftruncate',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ioctl',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'perf_event_open',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'linkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'stime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'rt_sigaction',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'futimesat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'poll',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'select',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'nanosleep',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'faccessat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'get_robust_list',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('mm_segment_t', 'seg'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'swapon',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'epoll_wait',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getattr',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'fchownat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'timerfd_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_setscheduler',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'ioprio_get',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'move_pages',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'setpriority',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'mq_notify',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'clock_nanosleep',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sched_getparam',
+               'reason': set([('mm_segment_t', 'seg')])},
+              {'call': 'futex',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'recvmmsg',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile64',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ppoll',
+               'reason': set([('compat_timespec', 'tv_nsec'),
+                              ('compat_timespec', 'tv_sec'),
+                              ('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])}],
+ 'ptrace': [{'call': 'keyctl',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'kill',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'pause', 'reason': set([('task_struct', 'state')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'ioprio_set',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigsuspend',
+             'reason': set([('task_struct', 'state')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'prlimit64',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'fork',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'epoll_wait', 'reason': set([('task_struct', 'state')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'getrusage',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'ioprio_get',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'prctl',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'move_pages',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])},
+            {'call': 'sigsuspend', 'reason': set([('task_struct', 'state')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'exit_state'),
+                            ('task_struct', 'flags'),
+                            ('task_struct', 'ptrace'),
+                            ('task_struct', 'state')])}],
+ 'pwrite64': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+              {'call': 'fadvise64_64',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+              {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+              {'call': 'writev', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+              {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'read', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+              {'call': 'utime', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+              {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'tee', 'reason': set([('fd', 'flags')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'connect', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+              {'call': 'splice', 'reason': set([('fd', 'flags')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+              {'call': 'listen', 'reason': set([('fd', 'flags')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'readv', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+              {'call': 'write', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'bind', 'reason': set([('fd', 'flags')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'pwritev': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+             {'call': 'remap_file_pages',
+              'reason': set([('file', 'f_mode')])},
+             {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+             {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+             {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+             {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+             {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+             {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+             {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+             {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'perf_event_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+             {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+             {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+             {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+             {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+             {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+             {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+             {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+             {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+             {'call': 'open_by_handle_at',
+              'reason': set([('file', 'f_mode')])}],
+ 'pwritev2': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'perf_event_open',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])}],
+ 'pwritev64': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+               {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+               {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+               {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+               {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+               {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+               {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'perf_event_open',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+               {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+               {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+               {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+               {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_mode')])}],
+ 'pwritev64v2': [{'call': 'fadvise64_64',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'memfd_create',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'remap_file_pages',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'epoll_create1',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'perf_event_open',
+                  'reason': set([('file', 'f_mode')])},
+                 {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'open', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+                 {'call': 'open_by_handle_at',
+                  'reason': set([('file', 'f_mode')])}],
+ 'quotactl': [{'call': 'syncfs',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'sysfs', 'reason': set([('filename', 'name')])},
+              {'call': 'fadvise64_64',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'mq_unlink', 'reason': set([('filename', 'name')])},
+              {'call': 'swapoff', 'reason': set([('filename', 'name')])},
+              {'call': 'ustat',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'umount',
+               'reason': set([('super_block', 's_flags'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'openat', 'reason': set([('filename', 'name')])},
+              {'call': 'uselib', 'reason': set([('filename', 'name')])},
+              {'call': 'renameat2', 'reason': set([('filename', 'name')])},
+              {'call': 'symlinkat', 'reason': set([('filename', 'name')])},
+              {'call': 'acct', 'reason': set([('filename', 'name')])},
+              {'call': 'open', 'reason': set([('filename', 'name')])},
+              {'call': 'unlink', 'reason': set([('filename', 'name')])},
+              {'call': 'rmdir', 'reason': set([('filename', 'name')])},
+              {'call': 'swapon',
+               'reason': set([('filename', 'name'),
+                              ('super_block', 's_flags'),
+                              ('super_block', 's_quota_types')])},
+              {'call': 'mq_open', 'reason': set([('filename', 'name')])},
+              {'call': 'unlinkat', 'reason': set([('filename', 'name')])}],
+ 'read': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+          {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+          {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+          {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+          {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+          {'call': 'writev', 'reason': set([('fd', 'flags')])},
+          {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+          {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+          {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+          {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+          {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+          {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+          {'call': 'utime', 'reason': set([('fd', 'flags')])},
+          {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+          {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+          {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+          {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+          {'call': 'tee', 'reason': set([('fd', 'flags')])},
+          {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+          {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+          {'call': 'connect', 'reason': set([('fd', 'flags')])},
+          {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+          {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+          {'call': 'flock', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+          {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+          {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+          {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+          {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+          {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+          {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+          {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+          {'call': 'splice', 'reason': set([('fd', 'flags')])},
+          {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+          {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+          {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+          {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+          {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+          {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+          {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+          {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+          {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+          {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+          {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+          {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+          {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+          {'call': 'listen', 'reason': set([('fd', 'flags')])},
+          {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+          {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+          {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+          {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+          {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+          {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+          {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+          {'call': 'readv', 'reason': set([('fd', 'flags')])},
+          {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+          {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+          {'call': 'write', 'reason': set([('fd', 'flags')])},
+          {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+          {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+          {'call': 'bind', 'reason': set([('fd', 'flags')])},
+          {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+          {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'readahead': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'fadvise64_64',
+                'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+               {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+               {'call': 'remap_file_pages',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl',
+                'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+               {'call': 'flock',
+                'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+               {'call': 'accept4',
+                'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open',
+                'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+               {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+               {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+               {'call': 'open_by_handle_at',
+                'reason': set([('file', 'f_mode')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'recvfrom': [{'call': 'swapoff', 'reason': set([('file', 'f_flags')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_flags')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_flags')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_flags')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_flags')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_flags')])},
+              {'call': 'epoll_ctl', 'reason': set([('file', 'f_flags')])},
+              {'call': 'flock', 'reason': set([('file', 'f_flags')])},
+              {'call': 'openat', 'reason': set([('file', 'f_flags')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_flags')])},
+              {'call': 'accept4', 'reason': set([('file', 'f_flags')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_flags')])},
+              {'call': 'socket', 'reason': set([('file', 'f_flags')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('file', 'f_flags')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_flags')])},
+              {'call': 'acct', 'reason': set([('file', 'f_flags')])},
+              {'call': 'open', 'reason': set([('file', 'f_flags')])},
+              {'call': 'mq_getsetattr', 'reason': set([('file', 'f_flags')])},
+              {'call': 'dup', 'reason': set([('file', 'f_flags')])},
+              {'call': 'setns', 'reason': set([('file', 'f_flags')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_flags')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_flags')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_flags')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_flags')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_flags')])},
+              {'call': 'msync', 'reason': set([('file', 'f_flags')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_flags')])}],
+ 'recvmmsg': [{'call': 'rt_sigtimedwait',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fadvise64_64',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'swapoff',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchmod',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'memfd_create',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'readlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'io_getevents',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchown',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_timedreceive',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'utime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'semtimedop',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'recvfrom', 'reason': set([('msghdr', 'msg_flags')])},
+              {'call': 'settimeofday',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendto', 'reason': set([('msghdr', 'msg_flags')])},
+              {'call': 'sched_rr_get_interval',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'pselect6',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'uselib',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchmodat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'inotify_add_watch',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ftruncate',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timer_gettime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ioctl',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'linkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'stime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'futimesat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'poll',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'select',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlink',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'nanosleep',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_getsetattr',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'faccessat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_timedsend',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'swapon',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'epoll_wait',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'fchownat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'timerfd_settime',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'mq_notify',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'clock_nanosleep',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'unlinkat',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'futex',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'sendfile64',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])},
+              {'call': 'ppoll',
+               'reason': set([('timespec', 'tv_nsec'),
+                              ('timespec', 'tv_sec')])}],
+ 'remap_file_pages': [{'call': 'shmdt',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'brk',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'get_mempolicy',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'munlockall',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'pkey_mprotect',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'madvise',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mprotect',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mremap',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'prctl',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'munlock',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mincore',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'msync',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])},
+                      {'call': 'mlockall',
+                       'reason': set([('vm_area_struct', 'vm_end'),
+                                      ('vm_area_struct', 'vm_flags'),
+                                      ('vm_area_struct', 'vm_start')])}],
+ 'renameat2': [{'call': 'sysfs',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'mq_unlink',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapoff',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'openat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'uselib',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'symlinkat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'quotactl',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'acct',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'unlink',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'rmdir',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapon',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'mq_open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'unlinkat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])}],
+ 'rt_sigqueueinfo': [{'call': 'rt_sigtimedwait',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'kill',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'timer_create',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'tgkill',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'rt_tgsigqueueinfo',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'rt_sigreturn',
+                      'reason': set([('siginfo', 'si_code')])},
+                     {'call': 'tkill',
+                      'reason': set([('siginfo', 'si_code')])}],
+ 'rt_sigreturn': [{'call': 'keyctl',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigtimedwait',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'iopl',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'msgrcv',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'kill',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getaffinity',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setparam',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ioprio_set',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getppid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ioperm',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'mq_timedreceive',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'capget',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setaffinity',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'signal',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'semtimedop',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'umount',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_rr_get_interval',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigprocmask',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setsid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sigaltstack',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setattr',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'migrate_pages',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getitimer',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setpgid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getsid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'prlimit64',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'perf_event_open',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'rt_sigaction',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getpgid',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getpriority',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sigaction',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setns',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'fork',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'get_robust_list',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'mq_timedsend',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getscheduler',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ptrace',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getattr',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'getrusage',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_setscheduler',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setitimer',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'ioprio_get',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'vfork',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'prctl',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'move_pages',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'setpriority',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'clone',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])},
+                  {'call': 'sched_getparam',
+                   'reason': set([('mm_segment_t', 'seg'),
+                                  ('thread_struct', 'uaccess_err')])}],
+ 'rt_sigtimedwait': [{'call': 'keyctl',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'iopl',
+                      'reason': set([('mm_segment_t', 'seg')])},
+                     {'call': 'msgrcv',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'kill',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getaffinity',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setparam',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ioprio_set',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getppid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ioperm',
+                      'reason': set([('mm_segment_t', 'seg')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'capget',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setaffinity',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'signal',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'umount',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'timer_create',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigqueueinfo',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'tgkill',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'rt_sigprocmask',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'setsid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sigaltstack',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setattr',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'migrate_pages',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getitimer',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'setpgid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getsid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'prlimit64',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigaction',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getpgid',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getpriority',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sigaction',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_tgsigqueueinfo',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'setns',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'fork',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'get_robust_list',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getscheduler',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ptrace',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getattr',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'getrusage',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_setscheduler',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'setitimer',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'ioprio_get',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'vfork',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'prctl',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'move_pages',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'rt_sigreturn',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'tkill',
+                      'reason': set([('siginfo', 'si_code'),
+                                     ('siginfo', 'si_signo')])},
+                     {'call': 'setpriority',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'clone',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])},
+                     {'call': 'sched_getparam',
+                      'reason': set([('mm_segment_t', 'seg'),
+                                     ('task_struct', 'timer_slack_ns')])}],
+ 'rt_tgsigqueueinfo': [{'call': 'rt_sigtimedwait',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'kill',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'timer_create',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'rt_sigqueueinfo',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'tgkill',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'rt_sigreturn',
+                        'reason': set([('siginfo', 'si_code')])},
+                       {'call': 'tkill',
+                        'reason': set([('siginfo', 'si_code')])}],
+ 'sched_getattr': [{'call': 'keyctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'kill',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getppid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ioperm',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'capget',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'signal',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'umount',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('sched_attr', 'size'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getsid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getpgid',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sigaction',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setns',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'fork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ptrace',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'getrusage',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setitimer',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'vfork',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'prctl',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'move_pages',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'setpriority',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'clone',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('task_struct', 'policy'),
+                                   ('task_struct', 'sched_reset_on_fork')])}],
+ 'sched_getparam': [{'call': 'keyctl',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'rt_sigtimedwait',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'msgrcv',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'kill',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getaffinity',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setparam',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'ioprio_set',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getppid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'mq_timedreceive',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'capget',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setaffinity',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'signal',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'semtimedop',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'umount',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_rr_get_interval',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'rt_sigprocmask',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setsid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sigaltstack',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setattr',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'migrate_pages',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getitimer',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setpgid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getsid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'prlimit64',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'perf_event_open',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'rt_sigaction',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getpgid',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getpriority',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sigaction',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setns',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'fork',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'get_robust_list',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'mq_timedsend',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getscheduler',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'ptrace',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_getattr',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'getrusage',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'sched_setscheduler',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setitimer',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'ioprio_get',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'vfork',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'prctl',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'move_pages',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'setpriority',
+                     'reason': set([('task_struct', 'policy')])},
+                    {'call': 'clone',
+                     'reason': set([('task_struct', 'policy')])}],
+ 'sched_getscheduler': [{'call': 'keyctl',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'rt_sigtimedwait',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'msgrcv',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'kill',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getaffinity',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setparam',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'ioprio_set',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getppid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'mq_timedreceive',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'capget',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setaffinity',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'signal',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'semtimedop',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'umount',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_rr_get_interval',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'rt_sigprocmask',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setsid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sigaltstack',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setattr',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'migrate_pages',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getitimer',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setpgid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getsid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'prlimit64',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'perf_event_open',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'rt_sigaction',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getpgid',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getpriority',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sigaction',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setns',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'fork',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'get_robust_list',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'mq_timedsend',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'ptrace',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getattr',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'getrusage',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_setscheduler',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setitimer',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'ioprio_get',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'vfork',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'prctl',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'move_pages',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'setpriority',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'clone',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])},
+                        {'call': 'sched_getparam',
+                         'reason': set([('task_struct',
+                                         'sched_reset_on_fork')])}],
+ 'sched_setaffinity': [{'call': 'keyctl',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'rt_sigtimedwait',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'msgrcv',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'kill',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sched_getaffinity',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sched_setparam',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'ioprio_set',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'getppid',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'mq_timedreceive',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'capget',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'signal',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'setreuid',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'semtimedop',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'umount',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sched_rr_get_interval',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'rt_sigprocmask',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'setsid',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sigaltstack',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sched_setattr',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'migrate_pages',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'getitimer',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'setpgid',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'getsid',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'prlimit64',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'perf_event_open',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'rt_sigaction',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'getpgid',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'getpriority',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sigaction',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'setns',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'fork',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'get_robust_list',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'mq_timedsend',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sched_getscheduler',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'ptrace',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sched_getattr',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'getrusage',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sched_setscheduler',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'setresuid',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'setitimer',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'ioprio_get',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'vfork',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'setuid',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'prctl',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'move_pages',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'setpriority',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'clone',
+                        'reason': set([('task_struct', 'flags')])},
+                       {'call': 'sched_getparam',
+                        'reason': set([('task_struct', 'flags')])}],
+ 'sched_setattr': [{'call': 'keyctl',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigtimedwait',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'msgrcv',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getaffinity',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setparam',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioprio_set',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getppid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioperm',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedreceive',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'capget',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setaffinity',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'signal',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'semtimedop',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'umount',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_rr_get_interval',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigprocmask',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setsid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sigaltstack',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'migrate_pages',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getitimer',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setpgid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getsid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'prlimit64',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'perf_event_open',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'rt_sigaction',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getpgid',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'getpriority',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sigaction',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setns',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'get_robust_list',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'mq_timedsend',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getscheduler',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ptrace',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getattr',
+                    'reason': set([('mm_segment_t', 'seg'),
+                                   ('sched_attr', 'sched_policy')])},
+                   {'call': 'getrusage',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_setscheduler',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setitimer',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'ioprio_get',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'vfork',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'prctl',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'move_pages',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'setpriority',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'clone',
+                    'reason': set([('mm_segment_t', 'seg')])},
+                   {'call': 'sched_getparam',
+                    'reason': set([('mm_segment_t', 'seg')])}],
+ 'select': [{'call': 'keyctl',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'msgrcv',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fadvise64_64',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'mq_unlink',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'swapoff',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchmod',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'memfd_create',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'ioprio_set',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'personality',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'readlinkat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'io_getevents',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getppid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchown',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'capget',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'utime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'signal',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'semtimedop',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'umount',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'settimeofday',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timerfd_gettime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'pselect6',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'uselib',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'getitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchmodat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'setpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timer_settime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'ftruncate',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'timer_gettime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getsid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioctl',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'prlimit64',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'linkat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'stime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'futimesat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getpgid',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'poll',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'unlink',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'sigaction',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'nanosleep',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'faccessat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'setns',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'personality'),
+                            ('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ptrace',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'swapon',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'epoll_wait',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'fchownat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'getrusage',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'timerfd_settime',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setitimer',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'ioprio_get',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'vfork',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'prctl',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'move_pages',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'mq_notify',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sendfile',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'clone',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'clock_nanosleep',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'unlinkat',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'personality')])},
+            {'call': 'futex',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'recvmmsg',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'sendfile64',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])},
+            {'call': 'ppoll',
+             'reason': set([('timespec', 'tv_nsec'),
+                            ('timespec', 'tv_sec')])}],
+ 'semctl': [{'call': 'semtimedop',
+             'reason': set([('sem_array', 'sem_nsems')])}],
+ 'semtimedop': [{'call': 'rt_sigtimedwait',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'msgrcv',
+                 'reason': set([('kern_ipc_perm', 'deleted')])},
+                {'call': 'fadvise64_64',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mq_unlink',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'swapoff',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'fchmod',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'memfd_create',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'readlinkat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'io_getevents',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'fchown',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mq_timedreceive',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'utime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'settimeofday',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sched_rr_get_interval',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timerfd_gettime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'semctl',
+                 'reason': set([('kern_ipc_perm', 'deleted'),
+                                ('sem_array', 'complex_count'),
+                                ('sem_array', 'sem_nsems'),
+                                ('sem_array', 'use_global_lock'),
+                                ('sem_undo', 'semid')])},
+                {'call': 'pselect6',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'uselib',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'msgctl',
+                 'reason': set([('kern_ipc_perm', 'deleted')])},
+                {'call': 'fchmodat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'inotify_add_watch',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timer_settime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'ftruncate',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timer_gettime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'shmat',
+                 'reason': set([('kern_ipc_perm', 'deleted')])},
+                {'call': 'ioctl',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'linkat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'stime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'futimesat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'poll',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'select',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'unlink',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'nanosleep',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mq_getsetattr',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'faccessat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'mq_timedsend',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'shmctl',
+                 'reason': set([('kern_ipc_perm', 'deleted')])},
+                {'call': 'swapon',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'epoll_wait',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'fchownat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'timerfd_settime',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'msgsnd',
+                 'reason': set([('kern_ipc_perm', 'deleted')])},
+                {'call': 'mq_notify',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sendfile',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'clock_nanosleep',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'unlinkat',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'futex',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'recvmmsg',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'sendfile64',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])},
+                {'call': 'ppoll',
+                 'reason': set([('timespec', 'tv_nsec'),
+                                ('timespec', 'tv_sec')])}],
+ 'sendfile': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'perf_event_open',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])}],
+ 'sendfile64': [{'call': 'fadvise64_64', 'reason': set([('file', 'f_mode')])},
+                {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+                {'call': 'remap_file_pages',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+                {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+                {'call': 'epoll_create1',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'epoll_ctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'flock', 'reason': set([('file', 'f_mode')])},
+                {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+                {'call': 'accept4', 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+                {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+                {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'perf_event_open',
+                 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+                {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+                {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+                {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+                {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+                {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+                {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+                {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+                {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+                {'call': 'open_by_handle_at',
+                 'reason': set([('file', 'f_mode')])}],
+ 'sendto': [{'call': 'swapoff', 'reason': set([('file', 'f_flags')])},
+            {'call': 'memfd_create', 'reason': set([('file', 'f_flags')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('file', 'f_flags')])},
+            {'call': 'dup3', 'reason': set([('file', 'f_flags')])},
+            {'call': 'socketpair', 'reason': set([('file', 'f_flags')])},
+            {'call': 'epoll_create1', 'reason': set([('file', 'f_flags')])},
+            {'call': 'epoll_ctl', 'reason': set([('file', 'f_flags')])},
+            {'call': 'flock', 'reason': set([('file', 'f_flags')])},
+            {'call': 'openat', 'reason': set([('file', 'f_flags')])},
+            {'call': 'uselib', 'reason': set([('file', 'f_flags')])},
+            {'call': 'accept4', 'reason': set([('file', 'f_flags')])},
+            {'call': 'shmat', 'reason': set([('file', 'f_flags')])},
+            {'call': 'socket', 'reason': set([('file', 'f_flags')])},
+            {'call': 'pipe2', 'reason': set([('file', 'f_flags')])},
+            {'call': 'perf_event_open', 'reason': set([('file', 'f_flags')])},
+            {'call': 'shmdt', 'reason': set([('file', 'f_flags')])},
+            {'call': 'acct', 'reason': set([('file', 'f_flags')])},
+            {'call': 'open', 'reason': set([('file', 'f_flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('file', 'f_flags')])},
+            {'call': 'dup', 'reason': set([('file', 'f_flags')])},
+            {'call': 'setns', 'reason': set([('file', 'f_flags')])},
+            {'call': 'shmctl', 'reason': set([('file', 'f_flags')])},
+            {'call': 'swapon', 'reason': set([('file', 'f_flags')])},
+            {'call': 'eventfd2', 'reason': set([('file', 'f_flags')])},
+            {'call': 'mmap_pgoff', 'reason': set([('file', 'f_flags')])},
+            {'call': 'mq_open', 'reason': set([('file', 'f_flags')])},
+            {'call': 'msync', 'reason': set([('file', 'f_flags')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('file', 'f_flags')])}],
+ 'set_mempolicy': [{'call': 'get_mempolicy',
+                    'reason': set([('mempolicy', 'mode')])},
+                   {'call': 'mbind', 'reason': set([('mempolicy', 'mode')])}],
+ 'set_thread_area': [{'call': 'keyctl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'rt_sigtimedwait',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'iopl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'msgrcv',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'kill',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getaffinity',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'arch_prctl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setparam',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ioprio_set',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getppid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ioperm',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'capget',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setaffinity',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'signal',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'semtimedop',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'umount',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_rr_get_interval',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'rt_sigprocmask',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setsid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sigaltstack',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setattr',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'migrate_pages',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getitimer',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setpgid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getsid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'prlimit64',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'rt_sigaction',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getpgid',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getpriority',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sigaction',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setns',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'fork',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'get_robust_list',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getscheduler',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ptrace',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getattr',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'getrusage',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_setscheduler',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setitimer',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'ioprio_get',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'vfork',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'prctl',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'move_pages',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'setpriority',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'clone',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])},
+                     {'call': 'sched_getparam',
+                      'reason': set([('thread_struct', 'fsindex'),
+                                     ('thread_struct', 'gsindex')])}],
+ 'set_trip_temp': [{'call': 'get_trip_temp',
+                    'reason': set([('pkg_device', 'cpu'),
+                                   ('pkg_device', 'tj_max')])},
+                   {'call': 'get_curr_temp',
+                    'reason': set([('pkg_device', 'cpu'),
+                                   ('pkg_device', 'tj_max')])}],
+ 'setgroups16': [{'call': 'setgroups',
+                  'reason': set([('group_info', 'ngroups')])}],
+ 'setitimer': [{'call': 'settimeofday',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'timer_create',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'adjtimex',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'waitid',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'getitimer',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'select',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'exit_group',
+                'reason': set([('signal_struct', 'it_real_incr')])},
+               {'call': 'wait4',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'getrusage',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'clock_adjtime',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'alarm',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])},
+               {'call': 'ppoll',
+                'reason': set([('timeval', 'tv_sec'),
+                               ('timeval', 'tv_usec')])}],
+ 'setpgid': [{'call': 'keyctl',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'msgrcv',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'kill',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sched_setparam',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'ioprio_set',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'getppid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'capget',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'signal',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+             {'call': 'semtimedop',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'umount',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'timer_create',
+              'reason': set([('signal_struct', 'leader')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'setsid',
+              'reason': set([('signal_struct', 'leader'),
+                             ('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sigaltstack',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sched_setattr',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'migrate_pages',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'getitimer',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'getsid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'prlimit64',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'perf_event_open',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'getpgid',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'exit_group',
+              'reason': set([('signal_struct', 'leader')])},
+             {'call': 'getpriority',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sigaction',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'setns',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'fork',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'get_robust_list',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'ptrace',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sched_getattr',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'getrusage',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+             {'call': 'setitimer',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'ioprio_get',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'vfork',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+             {'call': 'prctl',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'move_pages',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'setpriority',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'clone',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])},
+             {'call': 'sched_getparam',
+              'reason': set([('task_struct', 'exit_signal'),
+                             ('task_struct', 'flags')])}],
+ 'setrlimit': [{'call': 'old_getrlimit',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'prlimit64',
+                'reason': set([('rlimit', 'rlim_cur'),
+                               ('rlimit', 'rlim_max')])},
+               {'call': 'getrlimit',
+                'reason': set([('compat_rlimit', 'rlim_cur'),
+                               ('compat_rlimit', 'rlim_max')])}],
+ 'setsid': [{'call': 'timer_create',
+             'reason': set([('signal_struct', 'leader')])},
+            {'call': 'exit_group',
+             'reason': set([('signal_struct', 'leader')])}],
+ 'setsockopt': [{'call': 'accept4',
+                 'reason': set([('proto_ops', 'compat_setsockopt')])}],
+ 'settimeofday': [{'call': 'adjtimex',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'waitid',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'getitimer',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'select',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'wait4',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'getrusage',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'setitimer',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'clock_adjtime',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'alarm',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])},
+                  {'call': 'ppoll',
+                   'reason': set([('timeval', 'tv_sec'),
+                                  ('timeval', 'tv_usec')])}],
+ 'shmctl': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgrcv',
+             'reason': set([('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setparam',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semtimedop',
+             'reason': set([('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode'),
+                            ('mm_segment_t', 'seg')])},
+            {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semctl',
+             'reason': set([('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgctl',
+             'reason': set([('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'shmat',
+             'reason': set([('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'perf_event_open',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'get_robust_list',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgsnd',
+             'reason': set([('kern_ipc_perm', 'deleted'),
+                            ('kern_ipc_perm', 'mode')])},
+            {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getparam',
+             'reason': set([('mm_segment_t', 'seg')])}],
+ 'shmdt': [{'call': 'remap_file_pages',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'brk', 'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'get_mempolicy',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'munlockall',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'pkey_mprotect',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'madvise',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mprotect',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mremap',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'prctl', 'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'munlock',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mincore',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'msync', 'reason': set([('vm_area_struct', 'vm_pgoff')])},
+           {'call': 'mlockall',
+            'reason': set([('vm_area_struct', 'vm_pgoff')])}],
+ 'sigaction': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigtimedwait',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setparam',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_set',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setaffinity',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'semtimedop',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigprocmask',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sigaltstack',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'migrate_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prlimit64',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'perf_event_open',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'rt_sigaction',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'get_robust_list',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getattr',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'getrusage',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_setscheduler',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setitimer',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'ioprio_get',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'move_pages',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'setpriority',
+                'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+               {'call': 'sched_getparam',
+                'reason': set([('mm_segment_t', 'seg')])}],
+ 'signalfd4': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+               {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+               {'call': 'writev', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+               {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+               {'call': 'read', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+               {'call': 'utime', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+               {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+               {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+               {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+               {'call': 'tee', 'reason': set([('fd', 'flags')])},
+               {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'connect', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'flock', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+               {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+               {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+               {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('fd', 'flags')])},
+               {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+               {'call': 'splice', 'reason': set([('fd', 'flags')])},
+               {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+               {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+               {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+               {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+               {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+               {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+               {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+               {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+               {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+               {'call': 'listen', 'reason': set([('fd', 'flags')])},
+               {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+               {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+               {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+               {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+               {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+               {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+               {'call': 'readv', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+               {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+               {'call': 'write', 'reason': set([('fd', 'flags')])},
+               {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+               {'call': 'bind', 'reason': set([('fd', 'flags')])},
+               {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+               {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'splice': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'fadvise64_64',
+             'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapoff',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'memfd_create',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'remap_file_pages',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'dup3',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'socketpair',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_create1',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl',
+             'reason': set([('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'flock',
+             'reason': set([('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'openat',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'uselib',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'accept4',
+             'reason': set([('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmat',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'socket',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'pipe2',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('fd', 'flags'),
+                            ('file', 'f_flags'),
+                            ('file', 'f_mode')])},
+            {'call': 'shmdt',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'acct',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'open',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr',
+             'reason': set([('fd', 'flags'), ('file', 'f_flags')])},
+            {'call': 'dup',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'setns',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'shmctl',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'swapon',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'eventfd2',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'mmap_pgoff',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_open',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'msync',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'open_by_handle_at',
+             'reason': set([('file', 'f_flags'), ('file', 'f_mode')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'stat': [{'call': 'lstat',
+           'reason': set([('__old_kernel_stat', 'st_ino'),
+                          ('__old_kernel_stat', 'st_nlink')])},
+          {'call': 'fstat',
+           'reason': set([('__old_kernel_stat', 'st_ino'),
+                          ('__old_kernel_stat', 'st_nlink')])}],
+ 'statfs': [{'call': 'ustat',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'fstatfs',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'fstatfs64',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])},
+            {'call': 'statfs64',
+             'reason': set([('kstatfs', 'f_ffree'), ('kstatfs', 'f_files')])}],
+ 'statfs64': [{'call': 'ustat',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'fstatfs',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'statfs',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])},
+              {'call': 'fstatfs64',
+               'reason': set([('kstatfs', 'f_ffree'),
+                              ('kstatfs', 'f_files')])}],
+ 'swapoff': [{'call': 'swapon',
+              'reason': set([('page', 'private'),
+                             ('swap_info_struct', 'flags'),
+                             ('swap_info_struct', 'inuse_pages'),
+                             ('swap_info_struct', 'pages'),
+                             ('swap_info_struct', 'prio'),
+                             ('swap_info_struct', 'swap_map')])}],
+ 'swapon': [{'call': 'fadvise64_64', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_unlink', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'swapoff',
+             'reason': set([('inode', 'i_flags'),
+                            ('swap_info_struct', 'flags'),
+                            ('swap_info_struct', 'type')])},
+            {'call': 'fchmod', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'memfd_create', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'readlinkat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'fchown', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('inode', 'i_flags')])},
+            {'call': 'uselib', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'fchmodat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'inotify_add_watch',
+             'reason': set([('inode', 'i_flags')])},
+            {'call': 'ftruncate', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'ioctl', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'linkat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'unlink', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'faccessat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'fchownat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'mq_notify', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'sendfile', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'unlinkat', 'reason': set([('inode', 'i_flags')])},
+            {'call': 'sendfile64', 'reason': set([('inode', 'i_flags')])}],
+ 'symlinkat': [{'call': 'sysfs',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'mq_unlink',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapoff',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'openat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'uselib',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'renameat2',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'quotactl',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'acct',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'unlink',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'rmdir',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'swapon',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'mq_open',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])},
+               {'call': 'unlinkat',
+                'reason': set([('filename', 'name'),
+                               ('filename', 'refcnt')])}],
+ 'sync_file_range': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fadvise64_64',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fremovexattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+                     {'call': 'writev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'read', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedreceive',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'utime', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+                     {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+                     {'call': 'tee', 'reason': set([('fd', 'flags')])},
+                     {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'connect', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockname',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flock', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+                     {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+                     {'call': 'old_readdir',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_rm_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'inotify_add_watch',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'splice', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getpeername',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'perf_event_open',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev64v2',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+                     {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_getsetattr',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+                     {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'listen', 'reason': set([('fd', 'flags')])},
+                     {'call': 'copy_file_range',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_timedsend',
+                      'reason': set([('fd', 'flags')])},
+                     {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+                     {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+                     {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+                     {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+                     {'call': 'readv', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+                     {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+                     {'call': 'write', 'reason': set([('fd', 'flags')])},
+                     {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+                     {'call': 'bind', 'reason': set([('fd', 'flags')])},
+                     {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+                     {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'syncfs': [{'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+            {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+            {'call': 'writev', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+            {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+            {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+            {'call': 'read', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+            {'call': 'utime', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+            {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+            {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+            {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+            {'call': 'tee', 'reason': set([('fd', 'flags')])},
+            {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'connect', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'flock', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+            {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+            {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+            {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+            {'call': 'splice', 'reason': set([('fd', 'flags')])},
+            {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+            {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+            {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+            {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+            {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+            {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+            {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+            {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+            {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+            {'call': 'listen', 'reason': set([('fd', 'flags')])},
+            {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+            {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+            {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+            {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+            {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+            {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+            {'call': 'readv', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+            {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+            {'call': 'write', 'reason': set([('fd', 'flags')])},
+            {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+            {'call': 'bind', 'reason': set([('fd', 'flags')])},
+            {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+            {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'sysfs': [{'call': 'mq_unlink', 'reason': set([('filename', 'name')])},
+           {'call': 'swapoff', 'reason': set([('filename', 'name')])},
+           {'call': 'openat', 'reason': set([('filename', 'name')])},
+           {'call': 'uselib', 'reason': set([('filename', 'name')])},
+           {'call': 'renameat2', 'reason': set([('filename', 'name')])},
+           {'call': 'symlinkat', 'reason': set([('filename', 'name')])},
+           {'call': 'quotactl', 'reason': set([('filename', 'name')])},
+           {'call': 'acct', 'reason': set([('filename', 'name')])},
+           {'call': 'open', 'reason': set([('filename', 'name')])},
+           {'call': 'unlink', 'reason': set([('filename', 'name')])},
+           {'call': 'rmdir', 'reason': set([('filename', 'name')])},
+           {'call': 'swapon', 'reason': set([('filename', 'name')])},
+           {'call': 'mq_open', 'reason': set([('filename', 'name')])},
+           {'call': 'unlinkat', 'reason': set([('filename', 'name')])}],
+ 'sysinfo': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'rt_sigtimedwait',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fadvise64_64',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'mq_unlink', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_getaffinity',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setparam',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchmod', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'memfd_create',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'readlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'io_getevents',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchown', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedreceive',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'utime', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_setaffinity',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'semtimedop',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'settimeofday',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_rr_get_interval',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'timerfd_gettime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'rt_sigprocmask',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sigaltstack',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sched_setattr',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'migrate_pages',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'inotify_add_watch',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'timer_settime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ftruncate', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'timer_gettime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ioctl', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'perf_event_open',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'rt_sigaction',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'futimesat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'select', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getpriority',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'nanosleep', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'mq_getsetattr',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'faccessat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'get_robust_list',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_timedsend',
+              'reason': set([('mm_segment_t', 'seg'),
+                             ('timespec', 'tv_nsec')])},
+             {'call': 'sched_getscheduler',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'epoll_wait', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_getattr',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'timerfd_settime',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_setscheduler',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'setpriority',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'mq_notify', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sendfile', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'clock_nanosleep',
+              'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sched_getparam',
+              'reason': set([('mm_segment_t', 'seg')])},
+             {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'sendfile64', 'reason': set([('timespec', 'tv_nsec')])},
+             {'call': 'ppoll', 'reason': set([('timespec', 'tv_nsec')])}],
+ 'syslog': [{'call': 'keyctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'iopl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'msgrcv', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'kill', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setparam',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_set', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getppid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioperm', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'capget', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'signal', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'semtimedop', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'umount', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaltstack', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'migrate_pages',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getsid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prlimit64', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'perf_event_open',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpgid', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sigaction', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setns', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'fork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'get_robust_list',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ptrace', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getattr',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'getrusage', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setitimer', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'ioprio_get', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'vfork', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'prctl', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'move_pages', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'setpriority', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'clone', 'reason': set([('mm_segment_t', 'seg')])},
+            {'call': 'sched_getparam',
+             'reason': set([('mm_segment_t', 'seg')])}],
+ 'tee': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+         {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+         {'call': 'fadvise64_64',
+          'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+         {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+         {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+         {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+         {'call': 'writev', 'reason': set([('fd', 'flags')])},
+         {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+         {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+         {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+         {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+         {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+         {'call': 'remap_file_pages', 'reason': set([('file', 'f_mode')])},
+         {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+         {'call': 'read', 'reason': set([('fd', 'flags')])},
+         {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+         {'call': 'utime', 'reason': set([('fd', 'flags')])},
+         {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+         {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+         {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+         {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+         {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+         {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+         {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+         {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+         {'call': 'connect', 'reason': set([('fd', 'flags')])},
+         {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+         {'call': 'epoll_ctl',
+          'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+         {'call': 'flock',
+          'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+         {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+         {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+         {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+         {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+         {'call': 'accept4',
+          'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+         {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+         {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+         {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+         {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+         {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+         {'call': 'splice', 'reason': set([('fd', 'flags')])},
+         {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+         {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+         {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+         {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+         {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+         {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+         {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+         {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+         {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+         {'call': 'perf_event_open',
+          'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+         {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+         {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+         {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+         {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+         {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+         {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+         {'call': 'open', 'reason': set([('file', 'f_mode')])},
+         {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+         {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+         {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+         {'call': 'listen', 'reason': set([('fd', 'flags')])},
+         {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+         {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+         {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+         {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+         {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+         {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+         {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+         {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+         {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+         {'call': 'readv', 'reason': set([('fd', 'flags')])},
+         {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+         {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+         {'call': 'write', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+         {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+         {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+         {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+         {'call': 'open_by_handle_at', 'reason': set([('file', 'f_mode')])},
+         {'call': 'bind', 'reason': set([('fd', 'flags')])},
+         {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+         {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'timer_create': [{'call': 'clock_getres',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'timer_delete',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'clock_gettime',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'timer_settime',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'timer_gettime',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'clock_settime',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'clock_nanosleep',
+                   'reason': set([('k_clock', 'timer_create')])},
+                  {'call': 'clock_adjtime',
+                   'reason': set([('k_clock', 'timer_create')])}],
+ 'timer_delete': [{'call': 'clock_getres',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'timer_create',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'clock_gettime',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'timer_settime',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'timer_gettime',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'clock_settime',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'clock_nanosleep',
+                   'reason': set([('k_clock', 'timer_del')])},
+                  {'call': 'clock_adjtime',
+                   'reason': set([('k_clock', 'timer_del')])}],
+ 'timer_gettime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'timer_settime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'timer_get')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'timer_get')])}],
+ 'timer_settime': [{'call': 'clock_getres',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_delete',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_create',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_gettime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'timer_gettime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_settime',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_nanosleep',
+                    'reason': set([('k_clock', 'timer_set')])},
+                   {'call': 'clock_adjtime',
+                    'reason': set([('k_clock', 'timer_set')])}],
+ 'timerfd_create': [{'call': 'timerfd_gettime',
+                     'reason': set([('timerfd_ctx', 'clockid')])},
+                    {'call': 'timerfd_settime',
+                     'reason': set([('timerfd_ctx', 'clockid')])}],
+ 'timerfd_gettime': [{'call': 'timerfd_settime',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])},
+                     {'call': 'timerfd_create',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])}],
+ 'timerfd_settime': [{'call': 'timerfd_gettime',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])},
+                     {'call': 'timerfd_create',
+                      'reason': set([('timerfd_ctx', 'expired'),
+                                     ('timerfd_ctx', 'tintv')])}],
+ 'umount': [{'call': 'syncfs', 'reason': set([('super_block', 's_flags')])},
+            {'call': 'keyctl', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'rt_sigtimedwait',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'msgrcv', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'fadvise64_64',
+             'reason': set([('super_block', 's_flags')])},
+            {'call': 'mq_unlink', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'kill', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_getaffinity',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setparam',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'pivot_root',
+             'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'ioprio_set', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'getppid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'mq_timedreceive',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'capget', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setaffinity',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'ustat', 'reason': set([('super_block', 's_flags')])},
+            {'call': 'signal', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setreuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'semtimedop', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_rr_get_interval',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'rt_sigprocmask',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'setsid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sigaltstack',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setattr',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'migrate_pages',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'getitimer', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setpgid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'getcwd', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'getsid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'prlimit64', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'perf_event_open',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'quotactl', 'reason': set([('super_block', 's_flags')])},
+            {'call': 'rt_sigaction',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'getpgid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'acct', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'getpriority',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sigaction', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setns', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'fork', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'get_robust_list',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'mq_timedsend',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_getscheduler',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'ptrace', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'swapon', 'reason': set([('super_block', 's_flags')])},
+            {'call': 'sched_getattr',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'getrusage', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'sched_setscheduler',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'setresuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setitimer', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'ioprio_get', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'vfork', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setuid', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'prctl', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'move_pages', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'setpriority',
+             'reason': set([('task_struct', 'flags')])},
+            {'call': 'clone', 'reason': set([('task_struct', 'flags')])},
+            {'call': 'mq_open', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'sched_getparam',
+             'reason': set([('task_struct', 'flags')])}],
+ 'uname': [{'call': 'keyctl',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigtimedwait',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'msgrcv',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'kill', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setparam',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_set',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'personality',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getppid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'capget',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setaffinity',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'signal',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'semtimedop',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'umount',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigprocmask',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaltstack',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'migrate_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getsid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'prlimit64',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'perf_event_open',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'rt_sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpgid',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sigaction',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setns', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'fork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'get_robust_list',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'mq_timedsend',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ptrace',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getattr',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'getrusage',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_setscheduler',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setitimer',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'ioprio_get',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'vfork', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'prctl', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'move_pages',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'setpriority',
+            'reason': set([('task_struct', 'personality')])},
+           {'call': 'clone', 'reason': set([('task_struct', 'personality')])},
+           {'call': 'sched_getparam',
+            'reason': set([('task_struct', 'personality')])}],
+ 'uselib': [{'call': 'syncfs', 'reason': set([('super_block', 's_iflags')])},
+            {'call': 'fadvise64_64',
+             'reason': set([('super_block', 's_iflags')])},
+            {'call': 'mq_unlink', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'pivot_root',
+             'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'ustat', 'reason': set([('super_block', 's_iflags')])},
+            {'call': 'umount',
+             'reason': set([('super_block', 's_iflags'),
+                            ('vfsmount', 'mnt_flags')])},
+            {'call': 'getcwd', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'quotactl',
+             'reason': set([('super_block', 's_iflags')])},
+            {'call': 'acct', 'reason': set([('vfsmount', 'mnt_flags')])},
+            {'call': 'swapon', 'reason': set([('super_block', 's_iflags')])},
+            {'call': 'mq_open', 'reason': set([('vfsmount', 'mnt_flags')])}],
+ 'utime': [{'call': 'rt_sigtimedwait',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fadvise64_64', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_unlink', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fchmod', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'memfd_create', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'readlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'io_getevents', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fchown', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_timedreceive',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'semtimedop', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'settimeofday', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'sched_rr_get_interval',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timerfd_gettime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'inotify_add_watch',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timer_settime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'ftruncate', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timer_gettime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'ioctl', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'futimesat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'select', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'nanosleep', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_getsetattr',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'faccessat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_timedsend', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'epoll_wait', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'timerfd_settime',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'mq_notify', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'sendfile', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'clock_nanosleep',
+            'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'sendfile64', 'reason': set([('timespec', 'tv_nsec')])},
+           {'call': 'ppoll', 'reason': set([('timespec', 'tv_nsec')])}],
+ 'utimensat': [{'call': 'rt_sigtimedwait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fadvise64_64',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_unlink',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'swapoff', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchmod', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'memfd_create',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'readlinkat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'io_getevents',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchown', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_timedreceive',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'utime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'semtimedop',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'settimeofday',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sched_rr_get_interval',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'pselect6', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'uselib', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchmodat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'inotify_add_watch',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timer_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ftruncate',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timer_gettime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ioctl', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'linkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'stime', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'futimesat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'poll', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'select', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'unlink', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_getsetattr',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'faccessat',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_timedsend',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'swapon', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'epoll_wait',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'fchownat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'timerfd_settime',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'mq_notify',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'clock_nanosleep',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'unlinkat', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'futex', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'recvmmsg', 'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'sendfile64',
+                'reason': set([('timespec', 'tv_nsec')])},
+               {'call': 'ppoll', 'reason': set([('timespec', 'tv_nsec')])}],
+ 'vmsplice': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'fadvise64_64',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+              {'call': 'swapoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+              {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+              {'call': 'writev', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+              {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+              {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+              {'call': 'memfd_create', 'reason': set([('file', 'f_mode')])},
+              {'call': 'remap_file_pages',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'dup3', 'reason': set([('file', 'f_mode')])},
+              {'call': 'read', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+              {'call': 'utime', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+              {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+              {'call': 'socketpair', 'reason': set([('file', 'f_mode')])},
+              {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+              {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_create1', 'reason': set([('file', 'f_mode')])},
+              {'call': 'tee', 'reason': set([('fd', 'flags')])},
+              {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'connect', 'reason': set([('fd', 'flags')])},
+              {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_ctl',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'flock',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+              {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'openat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'uselib', 'reason': set([('file', 'f_mode')])},
+              {'call': 'accept4',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+              {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+              {'call': 'splice', 'reason': set([('fd', 'flags')])},
+              {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+              {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+              {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+              {'call': 'shmat', 'reason': set([('file', 'f_mode')])},
+              {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'socket', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pipe2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+              {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+              {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+              {'call': 'perf_event_open',
+               'reason': set([('fd', 'flags'), ('file', 'f_mode')])},
+              {'call': 'shmdt', 'reason': set([('file', 'f_mode')])},
+              {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+              {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+              {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+              {'call': 'acct', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'dup', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+              {'call': 'setns', 'reason': set([('file', 'f_mode')])},
+              {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+              {'call': 'listen', 'reason': set([('fd', 'flags')])},
+              {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+              {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'shmctl', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+              {'call': 'swapon', 'reason': set([('file', 'f_mode')])},
+              {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+              {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+              {'call': 'eventfd2', 'reason': set([('file', 'f_mode')])},
+              {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+              {'call': 'mmap_pgoff', 'reason': set([('file', 'f_mode')])},
+              {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+              {'call': 'readv', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+              {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+              {'call': 'write', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+              {'call': 'mq_open', 'reason': set([('file', 'f_mode')])},
+              {'call': 'msync', 'reason': set([('file', 'f_mode')])},
+              {'call': 'open_by_handle_at',
+               'reason': set([('file', 'f_mode')])},
+              {'call': 'bind', 'reason': set([('fd', 'flags')])},
+              {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+              {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}],
+ 'write': [{'call': 'syncfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'vmsplice', 'reason': set([('fd', 'flags')])},
+           {'call': 'fadvise64_64', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fremovexattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'readahead', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents', 'reason': set([('fd', 'flags')])},
+           {'call': 'writev', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchmod', 'reason': set([('fd', 'flags')])},
+           {'call': 'pread64', 'reason': set([('fd', 'flags')])},
+           {'call': 'signalfd4', 'reason': set([('fd', 'flags')])},
+           {'call': 'read', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchown', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedreceive', 'reason': set([('fd', 'flags')])},
+           {'call': 'utime', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsync', 'reason': set([('fd', 'flags')])},
+           {'call': 'bpf', 'reason': set([('fd', 'flags')])},
+           {'call': 'recvfrom', 'reason': set([('fd', 'flags')])},
+           {'call': 'fsetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendto', 'reason': set([('fd', 'flags')])},
+           {'call': 'tee', 'reason': set([('fd', 'flags')])},
+           {'call': 'sync_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'lseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'connect', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockname', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_ctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'flock', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev', 'reason': set([('fd', 'flags')])},
+           {'call': 'fchdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'accept4', 'reason': set([('fd', 'flags')])},
+           {'call': 'old_readdir', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_rm_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'utimensat', 'reason': set([('fd', 'flags')])},
+           {'call': 'inotify_add_watch', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv2', 'reason': set([('fd', 'flags')])},
+           {'call': 'splice', 'reason': set([('fd', 'flags')])},
+           {'call': 'ftruncate', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv', 'reason': set([('fd', 'flags')])},
+           {'call': 'getpeername', 'reason': set([('fd', 'flags')])},
+           {'call': 'setsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl', 'reason': set([('fd', 'flags')])},
+           {'call': 'ioctl', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwrite64', 'reason': set([('fd', 'flags')])},
+           {'call': 'perf_event_open', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'futimesat', 'reason': set([('fd', 'flags')])},
+           {'call': 'pwritev2', 'reason': set([('fd', 'flags')])},
+           {'call': 'shutdown', 'reason': set([('fd', 'flags')])},
+           {'call': 'getsockopt', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_getsetattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fdatasync', 'reason': set([('fd', 'flags')])},
+           {'call': 'getdents64', 'reason': set([('fd', 'flags')])},
+           {'call': 'listen', 'reason': set([('fd', 'flags')])},
+           {'call': 'copy_file_range', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_timedsend', 'reason': set([('fd', 'flags')])},
+           {'call': 'fgetxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'fcntl64', 'reason': set([('fd', 'flags')])},
+           {'call': 'fallocate', 'reason': set([('fd', 'flags')])},
+           {'call': 'epoll_wait', 'reason': set([('fd', 'flags')])},
+           {'call': 'llseek', 'reason': set([('fd', 'flags')])},
+           {'call': 'preadv64v2', 'reason': set([('fd', 'flags')])},
+           {'call': 'readv', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs', 'reason': set([('fd', 'flags')])},
+           {'call': 'fstatfs64', 'reason': set([('fd', 'flags')])},
+           {'call': 'mq_notify', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile', 'reason': set([('fd', 'flags')])},
+           {'call': 'bind', 'reason': set([('fd', 'flags')])},
+           {'call': 'flistxattr', 'reason': set([('fd', 'flags')])},
+           {'call': 'sendfile64', 'reason': set([('fd', 'flags')])}]}
diff --git a/usr/src/tools/smatch/src/smatch_scripts/kchecker b/usr/src/tools/smatch/src/smatch_scripts/kchecker
new file mode 100755
index 0000000000..9754b21f93
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/kchecker
@@ -0,0 +1,73 @@
+#!/bin/bash
+
+function usage {
+    echo "Usage:  $0 [--sparse][--valgrind][--debug] path/to/file.c"
+    exit 1
+}
+
+SCRIPT_DIR=$(dirname $0)
+if [ -e $SCRIPT_DIR/../smatch ] ; then
+    CMD=$SCRIPT_DIR/../smatch
+elif which smatch | grep smatch > /dev/null ; then
+    CMD=smatch
+else
+    echo "Smatch binary not found."
+    exit 1
+fi
+
+while true ; do
+    if [[ "$1" == "--sparse" ]] ; then
+	CMD="sparse"
+	shift
+    elif [[ "$1" == "--test-parsing" ]] ; then
+	CMD="$SCRIPT_DIR/../test-parsing -no-lineno"
+	shift
+    elif echo "$1" | grep -q -- "--outfile=" ; then
+	outfile=$(echo "$1" | cut -d '=' -f 2)
+	if [ "outfile" != "" ] ; then
+	    POST="$POST > $outfile"
+	fi
+	shift
+    elif [[ "$1" == "--valgrind" ]] ; then
+	PRE="valgrind"
+	shift
+    elif [[ "$1" == "--endian" ]] ; then
+        ENDIAN="CF=-D__CHECK_ENDIAN__"
+	shift
+    elif [[ "$1" == "" ]] ; then
+	break
+    else
+	if [[ "$1" == "--help" ]] ; then
+		$CMD --help
+		exit 1
+	fi
+	if echo $1 | grep -q ^- ; then
+		POST="$1 $POST"
+	else
+		break
+	fi
+	shift
+    fi
+done
+if echo $CMD | grep -q smatch ; then
+    POST="--project=kernel --succeed $POST"
+fi
+
+cname=$1
+cname=$(echo ${cname/.o/.c})
+if [[ "$cname" == "" ]] ; then
+    usage
+fi
+if ! test -e $cname ; then
+    usage
+fi
+
+oname=$(echo ${cname/.c/.o})
+if ! echo $oname | grep -q .o$ && ! echo $oname | grep -q /$ ; then
+    usage
+fi
+if  echo $oname | grep -q .o$ ; then
+    rm -f $oname
+fi
+
+make C=2 $ENDIAN CHECK="$PRE $CMD $POST" $oname
diff --git a/usr/src/tools/smatch/src/smatch_scripts/kpatch.sh b/usr/src/tools/smatch/src/smatch_scripts/kpatch.sh
new file mode 100755
index 0000000000..1dcbd93061
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/kpatch.sh
@@ -0,0 +1,102 @@
+#!/bin/bash -e
+
+TMP_DIR=/tmp
+
+help()
+{
+    echo "Usage: $0 [--no-compile|--ammend] <filename>"
+    echo "You must be at the base of the kernel tree to run this."
+    exit 1
+}
+
+continue_yn()
+{
+    echo -n "Do you want to fix these issues now? "
+    read ans
+    if ! echo $ans | grep -iq ^n ; then
+	exit 1;
+    fi
+}
+
+qc()
+{
+    local msg=$1
+    local ans
+
+    echo -n "$msg:  "
+    read ans
+    if ! echo $ans | grep -qi ^y ; then
+	exit 1
+    fi
+}
+
+NO_COMPILE=false
+AMEND=""
+
+while true ; do
+    if [[ "$1" == "--no-compile" ]] ; then
+        NO_COMPILE=true
+        shift
+    elif [[ "$1" == "--ammend" ]] ; then
+        AMEND="--amend"
+        shift
+    else
+        break
+    fi
+done
+
+if [ ! -f $1 ] ; then
+    help
+fi
+
+fullname=$1
+filename=$(basename $fullname)
+oname=$(echo ${fullname/.c/.o})
+
+MAIL_FILE=$TMP_DIR/${filename}.msg
+
+echo "QC checklist"
+qc "Have you handled all the errors properly?"
+if git diff $fullname | grep ^+ | grep -qi alloc ; then
+    qc "Have you freed all your mallocs?"
+fi
+if git diff $fullname | grep ^+ | grep -qi alloc ; then
+    qc "Have you check all your mallocs for NULL returns?"
+fi
+
+if [ "$NO_COMPILE" != "true" ] ; then
+    kchecker --spammy $fullname
+    kchecker --sparse --endian $fullname
+#    rm $oname
+#    make C=1 CHECK="scripts/coccicheck" $oname
+fi
+
+grepmail $fullname ~/var/mail/sent* | grep -i ^subject || echo -n ""
+qc "Looks OK?"
+
+git log --oneline $fullname | head -n 10
+echo "Copy and paste one of these subjects?"
+read unused
+
+git add $fullname
+git commit --signoff $AMEND
+
+to_addr=$(./scripts/get_maintainer.pl -f --noroles --norolestats $fullname | head -n 1)
+cc_addr=$(./scripts/get_maintainer.pl -f --noroles --norolestats $fullname | tail -n +2 | \
+    perl -ne 's/\n$/, /; print')
+cc_addr="$cc_addr, kernel-janitors@vger.kernel.org"
+
+echo -n "To:  "  > $MAIL_FILE
+echo "$to_addr" >> $MAIL_FILE
+echo -n "CC:  " >> $MAIL_FILE
+echo "$cc_addr" >> $MAIL_FILE
+echo "X-Mailer: git-send-email haha only kidding" >> $MAIL_FILE
+
+git format-patch HEAD^ --stdout >> $MAIL_FILE
+
+./scripts/checkpatch.pl $MAIL_FILE || continue_yn
+
+echo "Press ENTER to continue"
+read unused
+
+mutt -H $MAIL_FILE
diff --git a/usr/src/tools/smatch/src/smatch_scripts/new_bugs.sh b/usr/src/tools/smatch/src/smatch_scripts/new_bugs.sh
new file mode 100755
index 0000000000..fd27359665
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/new_bugs.sh
@@ -0,0 +1,37 @@
+#!/bin/bash
+
+new=$1
+old=$2
+
+if [ "$old" = "" ] ; then
+    echo "usage:  $0 <new file> <old file>"
+    exit 1
+fi
+
+#
+# If the $old and $new are very similar then we can 
+# filter out a lot of bug just by doing a diff.
+#
+# But the line numbers change quite frequently so
+# really we only want to see if the line numbers
+# have changed inside the function.
+# The 42 in this message:
+# file.c +123 some_func(42) warn: blah blah blah
+#
+
+IFS="
+"
+for err in $(diff -u $old $new | cut -b 2- | egrep '(warn|error|warning):') ; do
+
+    # we are only interested in the last chunk.
+    # "some_func(42) warn: blah blah blah"
+    last=$(echo $err | cut -d ' ' -f 2-)
+
+    # There are some error message which include a second
+    # line number so we crudely chop that off.
+    last=$(echo $last | sed -e 's/line .*//')
+
+    if ! grep -Fq "$last" $old ; then
+	echo $err
+    fi
+done
diff --git a/usr/src/tools/smatch/src/smatch_scripts/show_errs.sh b/usr/src/tools/smatch/src/smatch_scripts/show_errs.sh
new file mode 100755
index 0000000000..bc6930ffa2
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/show_errs.sh
@@ -0,0 +1,33 @@
+#!/bin/bash
+
+context=6
+while true ; do
+    if [ "$1" = "-C" ] ; then
+	shift
+	context=$1
+	shift
+	continue
+    fi
+    break
+done
+
+
+file=$1
+[ "$file" = "" ] && [ -e err-list ] && file=err-list
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 [-C <lines>] [-b] [-k] <file with smatch messages>"
+    echo "  -C <lines>:  Print <lines> of context"
+    exit 1
+fi
+
+cat $file | while read line ; do
+    code_file=$(echo "$line" | cut -d ':' -f 1)
+    lineno=$(echo "$line" | cut -d ' ' -f 1 | cut -d ':' -f 2)
+    echo "========================================================="
+    echo "$line"
+    echo "---"
+    tail -n +$(($lineno - ($context - 1))) $code_file | head -n $(($context - 1))
+    echo "---------------------------------------------------------"
+    tail -n +${lineno} $code_file | head -n $context
+done
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/show_ifs.sh b/usr/src/tools/smatch/src/smatch_scripts/show_ifs.sh
new file mode 100755
index 0000000000..4f93ca5fa2
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/show_ifs.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+context=1
+if [ "$1" = "-C" ] ; then
+    shift
+    context=$1
+    shift
+fi
+
+file=$1
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 [-C <lines of context>] <file with smatch messages>"
+    exit 1
+fi
+
+grep 'if();' $file | cut -d ' ' -f1 | while read loc; do
+    code_file=$(echo $loc | cut -d ':' -f 1)
+    line=$(echo $loc | cut -d ':' -f 2)
+    echo "========================================================="
+    echo $code_file $line
+    tail -n +$(($line - ($context - 1))) $code_file | head -n $(($context - 1))
+    if [[ $context -gt 1 ]] ; then
+	echo "---------------------------------------------------------"
+    fi
+    tail -n +${line} $code_file | head -n $context
+done
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/show_unreachable.sh b/usr/src/tools/smatch/src/smatch_scripts/show_unreachable.sh
new file mode 100755
index 0000000000..7402615dc6
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/show_unreachable.sh
@@ -0,0 +1,83 @@
+#!/bin/bash
+
+context=6
+while true ; do
+    if [ "$1" = "-C" ] ; then
+        shift
+        context=$1
+        shift
+        continue
+    fi
+    if [ "$1" = "-k" ] ; then
+        shift
+        mode=kernel
+        continue
+    fi
+    if [ "$1" = "-b" ] ; then
+        shift
+        nobreak=yes
+        continue
+    fi
+    break
+done
+
+
+file=$1
+if [[ "$file" = "" ]] ; then
+    echo "Usage:  $0 [-C <lines>] [-b] [-k] <file with smatch messages>"
+    echo "  -C <lines>:  Print <lines> of context"
+    echo "  -b        :  Ignore unreachable break statements"
+    echo "  -k        :  Ignore some kernel defines"
+    exit 1
+fi
+
+kernel_ignore_functions="DLM_ASSERT
+BT_SI_SM_RETURN
+BT_STATE_CHANGE
+PARSE_ERROR1
+PARSE_ERROR
+CMDINSIZE
+PROCESS_SYSTEM_PARAM
+RETURN_STATUS
+ar9170_regwrite_result
+module_put_and_exit
+SEG32
+CASE_PIPExTRE
+"
+
+grep 'ignoring unreachable' $file | cut -d ' ' -f1 | while read loc; do
+    code_file=$(echo $loc | cut -d ':' -f 1)
+    line=$(echo $loc | cut -d ':' -f 2)
+
+    if [ "$mode" = "kernel" ] ; then
+        # BUG() is sometimes defined away on embedded systems
+        if tail -n +$(($line - 1)) $code_file | head -n 1 | \
+            egrep -qw '(BUG|BT_STATE_CHANGE)' ; then
+            continue;
+        fi
+        skip=0
+        line_txt=$(tail -n +$(($line)) $code_file | head -n 1)
+        for func in $kernel_ignore_functions ; do
+            if echo "$line_txt" | egrep -qw $func ; then
+                skip=1
+                break
+            fi
+        done
+        if [ "$skip" == 1 ] ; then
+            continue
+        fi
+    fi
+
+    if [ "$nobreak" = "yes" ] ; then
+        if tail -n +$(($line)) $code_file | head -n 1 | grep -qw 'break' ; then
+            continue;
+        fi
+
+    fi
+    echo "========================================================="
+    echo $code_file:$line
+    tail -n +$(($line - ($context - 1))) $code_file | head -n $(($context - 1))
+    echo "---------------------------------------------------------"
+    tail -n +${line} $code_file | head -n $context
+done
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/strip_whitespace.pl b/usr/src/tools/smatch/src/smatch_scripts/strip_whitespace.pl
new file mode 100755
index 0000000000..6c00e523a7
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/strip_whitespace.pl
@@ -0,0 +1,24 @@
+#!/usr/bin/perl
+
+use strict;
+
+my $file = shift();
+open FILE, "<$file";
+my $txt = do { local $/;  <FILE> };
+
+# strip C99 comments
+$txt =~ s/\/\/.*//g;
+# strip newlines
+$txt =~ s/\n//g;
+# strip remaining comments
+$txt =~ s/\/\*.*?\*\///g;
+# strip tabs
+$txt =~ s/\t//g;
+# strip spaces
+$txt =~ s/ //g;
+# add newlines
+$txt =~ s/;/;\n/g;
+$txt =~ s/{/{\n/g;
+$txt =~ s/}/}\n/g;
+
+print "$txt\n";
diff --git a/usr/src/tools/smatch/src/smatch_scripts/summarize_errs.sh b/usr/src/tools/smatch/src/smatch_scripts/summarize_errs.sh
new file mode 100755
index 0000000000..5b9a66eb5b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/summarize_errs.sh
@@ -0,0 +1,106 @@
+#!/bin/bash
+
+print_help()
+{
+    echo "usage: $0 <warning file>"
+    exit 1;
+}
+
+set_title()
+{
+    echo -ne "\033]0;$*\007"
+    echo ========================================
+    echo $*
+    echo ----------------------------------------
+}
+
+cmd_help()
+{
+    echo "n - skips to next message"
+    echo "f - skips to next file"
+    echo "? - print this message again"
+}
+
+save_thoughts()
+{
+    echo "************"
+    echo $sm_err
+    echo -n "What do you think?:  "
+    read ans
+    if echo $ans | grep ^$ > /dev/null ; then
+        continue
+    fi 
+
+    #store the result
+    echo $sm_err       >> summary
+    echo $ans       >> summary
+    echo ========== >> summary
+}
+
+if [ "$1" = "--new" ] ; then
+    shift
+    NEW=Y
+fi
+
+file=$1
+if [ "$file" = "" ] ; then
+    if [ -e err-list ] ; then
+	file="err-list"
+    else
+	print_help
+    fi
+fi
+
+TXT=$(cat $file | uniq -f 2)
+
+IFS='
+'
+for sm_err in $TXT ; do
+    file=$(echo $sm_err | cut -d ':' -f 1)
+    line=$(echo $sm_err | cut -d ' ' -f 1 | cut -d ':' -f 2)
+
+    if [ "$file" = "$skip_file" ] ; then
+	continue
+    fi
+    skip_file=""
+
+    last=$(echo $sm_err | cut -d ' ' -f 2-)
+    last=$(echo $last | sed -e 's/line .*//')
+
+    if [ "$NEW" = "Y" ] ; then
+	if grep -F "$last" *summary* > /dev/null ; then
+	    echo "skipping $sm_err"
+	    continue
+	fi
+    fi
+
+    set_title $sm_err
+
+    #grep -A1 "$file $line" *summary* 2> /dev/null 
+    grep -A1 -F "$last" *summary* 2> /dev/null
+
+    ans="?"
+    while echo $ans | grep '?' > /dev/null ; do
+	echo -n "[? for help]: "
+	read ans
+	if echo $ans | grep n > /dev/null ; then
+	    continue 2
+	fi
+	if echo $ans | grep f > /dev/null ; then
+	    skip_file=$file
+	    continue 2
+	fi
+	if echo $ans | grep '?' > /dev/null ; then
+	    cmd_help
+	fi
+    done
+
+    # I have this in my .vimrc
+    # map <C-j> :! echo $sm_err<CR>
+    export sm_err
+
+    vim $file +${line}
+
+    save_thoughts
+done	
+IFS=
diff --git a/usr/src/tools/smatch/src/smatch_scripts/test_generic.sh b/usr/src/tools/smatch/src/smatch_scripts/test_generic.sh
new file mode 100755
index 0000000000..4655ba7493
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/test_generic.sh
@@ -0,0 +1,61 @@
+#!/bin/bash
+
+NR_CPU=$(cat /proc/cpuinfo | grep ^processor | wc -l)
+TARGET=""
+WLOG="smatch_warns.txt"
+LOG="smatch_compile.warns"
+function usage {
+    echo
+    echo "Usage:  $0 [smatch options]"
+    echo "Compiles the kernel with -j${NR_CPU}"
+    echo " available options:"
+    echo "	--endian          : enable endianess check"
+    echo "	--target {TARGET} : specify build target, default: $TARGET"
+    echo "	--log {FILE}      : Output compile log to file, default is: $LOG"
+    echo "	--wlog {FILE}     : Output warnigs to file, default is: $WLOG"
+    echo "	--help            : Show this usage"
+    exit 1
+}
+
+
+while true ; do
+    if [[ "$1" == "--endian" ]] ; then
+	ENDIAN="CF=-D__CHECK_ENDIAN__"
+	shift
+    elif [[ "$1" == "--target" ]] ; then
+	shift
+	TARGET="$1"
+	shift
+    elif [[ "$1" == "--log" ]] ; then
+	shift
+	LOG="$1"
+	shift
+    elif [[ "$1" == "--wlog" ]] ; then
+	shift
+	WLOG="$1"
+	shift
+    elif [[ "$1" == "--help" ]] ; then
+	usage
+    else
+	    break
+    fi
+done
+
+SCRIPT_DIR=$(dirname $0)
+if [ -e $SCRIPT_DIR/../smatch ] ; then
+    cp $SCRIPT_DIR/../smatch $SCRIPT_DIR/../bak.smatch
+    CMD=$SCRIPT_DIR/../bak.smatch
+elif which smatch | grep smatch > /dev/null ; then
+    CMD=smatch
+else
+    echo "Smatch binary not found."
+    exit 1
+fi
+
+make clean
+find -name \*.c.smatch -exec rm \{\} \;
+make -j${NR_CPU} $ENDIAN -k CHECK="$CMD --file-output $*" \
+	C=1 $TARGET 2>&1 | tee $LOG
+find -name \*.c.smatch -exec cat \{\} \; -exec rm \{\} \; > $WLOG
+
+echo "Done.  The warnings are saved to $WLOG"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/test_kernel.sh b/usr/src/tools/smatch/src/smatch_scripts/test_kernel.sh
new file mode 100755
index 0000000000..2beaf88e0c
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/test_kernel.sh
@@ -0,0 +1,63 @@
+#!/bin/bash
+
+NR_CPU=$(cat /proc/cpuinfo | grep ^processor | wc -l)
+TARGET="bzImage modules"
+WLOG="smatch_warns.txt"
+LOG="smatch_compile.warns"
+function usage {
+    echo
+    echo "Usage:  $0 [smatch options]"
+    echo "Compiles the kernel with -j${NR_CPU}"
+    echo " available options:"
+    echo "	--endian          : enable endianess check"
+    echo "	--target {TARGET} : specify build target, default: $TARGET"
+    echo "	--log {FILE}      : Output compile log to file, default is: $LOG"
+    echo "	--wlog {FILE}     : Output warnigs to file, default is: $WLOG"
+    echo "	--help            : Show this usage"
+    exit 1
+}
+
+
+while true ; do
+    if [[ "$1" == "--endian" ]] ; then
+	ENDIAN="CF=-D__CHECK_ENDIAN__"
+	shift
+    elif [[ "$1" == "--target" ]] ; then
+	shift
+	TARGET="$1"
+	shift
+    elif [[ "$1" == "--log" ]] ; then
+	shift
+	LOG="$1"
+	shift
+    elif [[ "$1" == "--wlog" ]] ; then
+	shift
+	WLOG="$1"
+	shift
+    elif [[ "$1" == "--help" ]] ; then
+	usage
+    else
+	    break
+    fi
+done
+
+SCRIPT_DIR=$(dirname $0)
+if [ -e $SCRIPT_DIR/../smatch ] ; then
+    cp $SCRIPT_DIR/../smatch $SCRIPT_DIR/../bak.smatch
+    CMD=$SCRIPT_DIR/../bak.smatch
+elif which smatch | grep smatch > /dev/null ; then
+    CMD=smatch
+else
+    echo "Smatch binary not found."
+    exit 1
+fi
+
+make clean
+find -name \*.c.smatch -exec rm \{\} \;
+make -j${NR_CPU} $ENDIAN -k CHECK="$CMD -p=kernel --file-output --succeed $*" \
+	C=1 $TARGET 2>&1 | tee $LOG
+find -name \*.c.smatch -exec cat \{\} \; -exec rm \{\} \; > $WLOG
+find -name \*.c.smatch.sql -exec cat \{\} \; -exec rm \{\} \; > $WLOG.sql
+find -name \*.c.smatch.caller_info -exec cat \{\} \; -exec rm \{\} \; > $WLOG.caller_info
+
+echo "Done.  The warnings are saved to $WLOG"
diff --git a/usr/src/tools/smatch/src/smatch_scripts/trace_params.pl b/usr/src/tools/smatch/src/smatch_scripts/trace_params.pl
new file mode 100755
index 0000000000..f97ae4cac3
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/trace_params.pl
@@ -0,0 +1,112 @@
+#!/usr/bin/perl
+
+# This script is supposed to help use the param_mapper output.
+# Give it a function and parameter and it lists the functions
+# and parameters which are basically equivalent.
+
+use strict;
+
+sub usage()
+{
+    print ("trace_params.pl <smatch output file> <function> <parameter>\n");
+    exit(1);
+}
+
+my %param_map;
+
+my $UNKNOWN  = 1;
+my $NOTFOUND = 2;
+my $FOUND    = 3;
+
+sub recurse($$)
+{
+    my $link = shift;
+    my $target = shift;
+    my $found = 0;
+
+    if ($link =~ /$target/) {
+        $param_map{$link}->{found} = $FOUND;
+        return 1;
+    }
+
+    if ($param_map{$link}->{found} == $FOUND) {
+        return 1;
+    }
+    if ($param_map{$link}->{found} == $NOTFOUND) {
+        return 0;
+    }
+
+    $param_map{$link}->{found} = $NOTFOUND;
+    foreach my $l (@{$param_map{$link}->{links}}){
+        $found = recurse($l, $target);
+        if ($found) {
+            $param_map{$link}->{found} = $FOUND;
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+sub compress_all($$)
+{
+    my $f = shift;
+    my $p = shift;
+    my $target = "$f%$p";
+
+    foreach my $link (keys %param_map){
+        recurse($link, $target);
+    }
+}
+
+sub add_link($$)
+{
+    my $one = shift;
+    my $two = shift;
+
+    if (!defined($param_map{$one})) {
+        $param_map{$one} = {found => $UNKNOWN, links => []};
+    }
+    push @{$param_map{$one}->{links}}, $two;
+}
+
+sub load_all($)
+{
+    my $file = shift;
+
+    open(FILE, "<$file");
+    while (<FILE>) {
+        if (/.*?:\d+ (.*?)\(\) info: param_mapper (\d+) => (.*?) (\d+)/) {
+            add_link("$1%$2", "$3%$4");
+        }
+    }
+}
+
+sub print_found()
+{
+    foreach my $func (keys %param_map){
+        my $tmp = $param_map{$func};
+
+        if ($tmp->{found} == $FOUND) {
+            my ($f, $p) = split(/%/, $func);
+            print("$f $p\n");
+        }
+    }
+}
+
+my $file = shift();
+my $func = shift();
+my $param = shift();
+
+if (!$file or !$func or !defined($param)) {
+    usage();
+}
+
+if (! -e $file) {
+    printf("Error:  $file does not exist.\n");
+    exit(1);
+}
+
+load_all($file);
+compress_all($func, $param);
+print_found();
diff --git a/usr/src/tools/smatch/src/smatch_scripts/unlocked_paths.pl b/usr/src/tools/smatch/src/smatch_scripts/unlocked_paths.pl
new file mode 100755
index 0000000000..f235b87e3c
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/unlocked_paths.pl
@@ -0,0 +1,100 @@
+#!/usr/bin/perl
+
+use strict;
+
+sub usage()
+{
+    print "Usage: unlocked_paths.pl <call tree file> <lock> <function>\n";
+    print "Prints a list of paths to <function> which don't take the <lock>.\n";
+    print "Generate the call tree file by running smatch with --call-tree.\n";
+    exit(1);
+}
+
+my %f_map;
+
+sub add_to_map($)
+{
+    my $callee = shift;
+
+    if (!defined($f_map{$callee})) {
+	$f_map{$callee} = {visited => 0, called_by => {}};
+    }
+}
+
+sub add_called_by($$)
+{
+    my $caller = shift;
+    my $callee = shift;
+    my $tmp;
+
+    %{$f_map{$callee}->{called_by}}->{$caller} = 1;
+}
+
+sub load_all($$)
+{
+    my $file = shift;
+    my $lock = shift;
+
+    open(FILE, "<$file");
+    while (<FILE>) {
+	if (/.*?:\d+ (.*?)\(\) info: func_call \((.*)\) (.*)/) {
+	    my $caller = quotemeta $1;
+	    my $locks = quotemeta $2;
+	    my $callee = quotemeta $3;
+
+	    add_to_map($callee);
+	    if (!($locks =~ /$lock/)) {
+		add_called_by($caller, $callee);
+	    }
+	}
+    }
+}
+
+my @fstack;
+sub print_fstack()
+{
+    foreach my $f (reverse @fstack) {
+	printf "$f ";
+    }
+    printf "\n";
+}
+
+sub print_unlocked_paths($)
+{
+    my $function = shift;
+
+    if (! defined %{$f_map{$function}}->{called_by}) {
+	push @fstack, $function;
+	print_fstack();
+	pop @fstack;
+	return;
+    }
+
+    push @fstack, $function;
+
+    if (!%{$f_map{$function}}->{visited}) {
+	%{$f_map{$function}}->{visited} = 1;
+	foreach my $caller (keys %{%{$f_map{$function}}->{called_by}}){
+	    print_unlocked_paths($caller);
+	}
+	%{$f_map{$function}}->{visited} = 0;
+
+    }
+
+    pop @fstack;
+}
+
+my $file = shift;
+my $lock = shift;
+my $target = shift;
+
+if (!$file || !$lock || !$target) {
+    usage();
+}
+if (! -e $file) {
+    printf("Error:  $file does not exist.\n");
+    exit(1);
+}
+
+load_all($file, $lock);
+print_unlocked_paths($target);
diff --git a/usr/src/tools/smatch/src/smatch_scripts/whitespace_only.sh b/usr/src/tools/smatch/src/smatch_scripts/whitespace_only.sh
new file mode 100755
index 0000000000..975e6571e1
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/whitespace_only.sh
@@ -0,0 +1,91 @@
+#!/bin/bash -e
+
+usage()
+{
+    echo "usage:  $0 <patch file>"
+    exit 1
+}
+
+if [ "$1" = "" ] ; then
+    usage
+fi
+
+if [ "$1" = "--compile" ] ; then
+    compile=true
+    shift
+fi
+
+SCRIPT_DIR=$(dirname $0)
+if [ -e $SCRIPT_DIR/kchecker ] ; then
+    KCHECKER=$SCRIPT_DIR/kchecker
+    STRIP=$SCRIPT_DIR/strip_whitespace.pl
+elif which kchecker | grep kchecker > /dev/null ; then
+    KCHECKER=kchecker
+    STRIP=strip_whitespace.pl
+else
+    echo "$SCRIPT_DIR"
+    echo "kchecker script not found."
+    exit 1
+fi
+
+PATCH=$1
+
+files=$(grep ^+++ $PATCH | cut -f 1 | cut -b 5-)
+if [ "$files" = "" ] ; then
+    usage
+fi
+
+if ! cat $PATCH | patch -p1 --dry-run > /dev/null ; then
+    echo "Couldn't apply patch"
+    exit 1
+fi
+
+before=$(mktemp /tmp/before.XXXXXXXXXX)
+after=$(mktemp /tmp/after.XXXXXXXXXX)
+tmpfile=$(mktemp)
+
+for file in $files ; do
+    file=${file#*/}
+
+    $STRIP $file > $before
+    if [ "$compile" = "true" ] ; then
+	if ! $KCHECKER --test-parsing --outfile=$before $file ; then
+		echo "warning: compile failed."
+	fi
+	mv $before $tmpfile
+	$STRIP $file > $before
+	cat $tmpfile >> $before
+    fi
+    cat $PATCH | patch -p1
+    $STRIP $file > $after
+    if [ "$compile" = "true" ] ; then
+	if ! $KCHECKER --test-parsing --outfile=$after $file ; then
+		echo "warning: compile failed.  *again*"
+	fi
+	mv $after $tmpfile
+	$STRIP $file > $after
+	cat $tmpfile >> $after
+    fi
+    cat $PATCH | patch -p1 -R
+
+    if [ ! -s $before ] ; then
+	echo "Error:  No result"
+	exit 1
+    fi
+
+    if diff $before $after > /dev/null ; then
+	echo
+	echo Only white space changed
+	echo
+    else
+	echo '!!#$%@$%@^@#$^@#%@$%@$%@#%$@#%!!'
+	echo '!!                            !!'
+	echo '!!  This patch changes stuff  !!'
+	echo '!!                            !!'
+	echo '!!#$%@$%@^@#$^@#%@$%@$%@#%$@#%!!'
+
+	diff -u $before $after 
+    fi
+    rm -f $before $after $tmpfile
+done
+
diff --git a/usr/src/tools/smatch/src/smatch_scripts/wine_checker.sh b/usr/src/tools/smatch/src/smatch_scripts/wine_checker.sh
new file mode 100755
index 0000000000..79b4faa51a
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_scripts/wine_checker.sh
@@ -0,0 +1,65 @@
+#!/bin/bash
+
+function usage {
+    echo "Usage:  $0 [--sparse][--valgrind][--debug] path/to/file.c"
+    exit 1
+}
+
+SCRIPT_DIR=$(dirname $0)
+if [ -e $SCRIPT_DIR/../smatch ] ; then
+    CMD=$SCRIPT_DIR/../smatch
+elif which smatch | grep smatch > /dev/null ; then
+    CMD=smatch
+else
+    echo "Smatch binary not found."
+    exit 1
+fi
+    
+POST=""
+WINE_ARGS="-p=wine --full-path -D__i386__"
+
+while true ; do
+    if [[ "$1" == "--sparse" ]] ; then
+	CMD="sparse"
+	shift
+    elif [[ "$1" == "--valgrind" ]] ; then
+	PRE="valgrind"
+	shift
+    elif [[ "$1" == "" ]] ; then
+	break
+    else
+	if [[ "$1" == "--help" ]] ; then
+		$CMD --help
+		exit 1
+	fi
+	if echo $1 | grep -q ^- ; then
+		POST="$POST $1"
+	else
+		break
+	fi
+	shift
+    fi
+done
+
+cname=$1
+cname=$(echo ${cname/.o/.c})
+if [[ "$cname" == "" ]] ; then
+    usege
+fi
+if ! test -e $cname ; then
+    usege
+fi
+
+oname=$(echo ${cname/.c/.o})
+if ! echo $oname | grep .o$ > /dev/null ; then
+    usege
+fi
+rm -f $oname
+
+cur=$(pwd)
+file_dir=$(dirname $oname)
+o_short_name=$(basename $oname)
+cd $file_dir
+make CC="$PRE $CMD $POST $WINE_ARGS" $o_short_name
+make $o_short_name
+cd $cur
diff --git a/usr/src/tools/smatch/src/smatch_slist.c b/usr/src/tools/smatch/src/smatch_slist.c
new file mode 100644
index 0000000000..ab0ca19d64
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_slist.c
@@ -0,0 +1,994 @@
+/*
+ * Copyright (C) 2008,2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+
+#undef CHECKORDER
+
+ALLOCATOR(smatch_state, "smatch state");
+ALLOCATOR(sm_state, "sm state");
+ALLOCATOR(named_stree, "named slist");
+__DO_ALLOCATOR(char, 1, 4, "state names", sname);
+
+int sm_state_counter;
+
+static struct stree_stack *all_pools;
+
+const char *show_sm(struct sm_state *sm)
+{
+	static char buf[256];
+	struct sm_state *tmp;
+	int pos;
+	int i;
+
+	if (!sm)
+		return "<none>";
+
+	pos = snprintf(buf, sizeof(buf), "[%s] '%s' = '%s'",
+		       check_name(sm->owner), sm->name, show_state(sm->state));
+	if (pos > sizeof(buf))
+		goto truncate;
+
+	if (ptr_list_size((struct ptr_list *)sm->possible) == 1)
+		return buf;
+
+	pos += snprintf(buf + pos, sizeof(buf) - pos, " (");
+	if (pos > sizeof(buf))
+		goto truncate;
+	i = 0;
+	FOR_EACH_PTR(sm->possible, tmp) {
+		if (i++)
+			pos += snprintf(buf + pos, sizeof(buf) - pos, ", ");
+		if (pos > sizeof(buf))
+			goto truncate;
+		pos += snprintf(buf + pos, sizeof(buf) - pos, "%s",
+			       show_state(tmp->state));
+		if (pos > sizeof(buf))
+			goto truncate;
+	} END_FOR_EACH_PTR(tmp);
+	snprintf(buf + pos, sizeof(buf) - pos, ")");
+
+	return buf;
+
+truncate:
+	for (i = 0; i < 3; i++)
+		buf[sizeof(buf) - 2 - i] = '.';
+	return buf;
+}
+
+void __print_stree(struct stree *stree)
+{
+	struct sm_state *sm;
+
+	printf("dumping stree at %d [%ld states]\n", get_lineno(), stree_count(stree));
+	FOR_EACH_SM(stree, sm) {
+		printf("%s\n", show_sm(sm));
+	} END_FOR_EACH_SM(sm);
+	printf("---\n");
+}
+
+/* NULL states go at the end to simplify merge_slist */
+int cmp_tracker(const struct sm_state *a, const struct sm_state *b)
+{
+	int ret;
+
+	if (a == b)
+		return 0;
+	if (!b)
+		return -1;
+	if (!a)
+		return 1;
+
+	if (a->owner > b->owner)
+		return -1;
+	if (a->owner < b->owner)
+		return 1;
+
+	ret = strcmp(a->name, b->name);
+	if (ret < 0)
+		return -1;
+	if (ret > 0)
+		return 1;
+
+	if (!b->sym && a->sym)
+		return -1;
+	if (!a->sym && b->sym)
+		return 1;
+	if (a->sym < b->sym)
+		return -1;
+	if (a->sym > b->sym)
+		return 1;
+
+	return 0;
+}
+
+static int cmp_sm_states(const struct sm_state *a, const struct sm_state *b, int preserve)
+{
+	int ret;
+
+	ret = cmp_tracker(a, b);
+	if (ret)
+		return ret;
+
+	/* todo:  add hook for smatch_extra.c */
+	if (a->state > b->state)
+		return -1;
+	if (a->state < b->state)
+		return 1;
+	/* This is obviously a massive disgusting hack but we need to preserve
+	 * the unmerged states for smatch extra because we use them in
+	 * smatch_db.c.  Meanwhile if we preserve all the other unmerged states
+	 * then it uses a lot of memory and we don't use it.  Hence this hack.
+	 *
+	 * Also sometimes even just preserving every possible SMATCH_EXTRA state
+	 * takes too much resources so we have to cap that.  Capping is probably
+	 * not often a problem in real life.
+	 */
+	if (a->owner == SMATCH_EXTRA && preserve) {
+		if (a == b)
+			return 0;
+		if (a->merged == 1 && b->merged == 0)
+			return -1;
+		if (a->merged == 0)
+			return 1;
+	}
+
+	return 0;
+}
+
+struct sm_state *alloc_sm_state(int owner, const char *name,
+				struct symbol *sym, struct smatch_state *state)
+{
+	struct sm_state *sm_state = __alloc_sm_state(0);
+
+	sm_state_counter++;
+
+	sm_state->name = alloc_sname(name);
+	sm_state->owner = owner;
+	sm_state->sym = sym;
+	sm_state->state = state;
+	sm_state->line = get_lineno();
+	sm_state->merged = 0;
+	sm_state->pool = NULL;
+	sm_state->left = NULL;
+	sm_state->right = NULL;
+	sm_state->nr_children = 1;
+	sm_state->possible = NULL;
+	add_ptr_list(&sm_state->possible, sm_state);
+	return sm_state;
+}
+
+static struct sm_state *alloc_state_no_name(int owner, const char *name,
+				     struct symbol *sym,
+				     struct smatch_state *state)
+{
+	struct sm_state *tmp;
+
+	tmp = alloc_sm_state(owner, NULL, sym, state);
+	tmp->name = name;
+	return tmp;
+}
+
+int too_many_possible(struct sm_state *sm)
+{
+	if (ptr_list_size((struct ptr_list *)sm->possible) >= 100)
+		return 1;
+	return 0;
+}
+
+void add_possible_sm(struct sm_state *to, struct sm_state *new)
+{
+	struct sm_state *tmp;
+	int preserve = 1;
+
+	if (too_many_possible(to))
+		preserve = 0;
+
+	FOR_EACH_PTR(to->possible, tmp) {
+		if (cmp_sm_states(tmp, new, preserve) < 0)
+			continue;
+		else if (cmp_sm_states(tmp, new, preserve) == 0) {
+			return;
+		} else {
+			INSERT_CURRENT(new, tmp);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+	add_ptr_list(&to->possible, new);
+}
+
+static void copy_possibles(struct sm_state *to, struct sm_state *from)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(from->possible, tmp) {
+		add_possible_sm(to, tmp);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+char *alloc_sname(const char *str)
+{
+	char *tmp;
+
+	if (!str)
+		return NULL;
+	tmp = __alloc_sname(strlen(str) + 1);
+	strcpy(tmp, str);
+	return tmp;
+}
+
+int out_of_memory(void)
+{
+	/*
+	 * I decided to use 50M here based on trial and error.
+	 * It works out OK for the kernel and so it should work
+	 * for most other projects as well.
+	 */
+	if (sm_state_counter * sizeof(struct sm_state) >= 100000000)
+		return 1;
+	return 0;
+}
+
+int low_on_memory(void)
+{
+	if (sm_state_counter * sizeof(struct sm_state) >= 25000000)
+		return 1;
+	return 0;
+}
+
+static void free_sm_state(struct sm_state *sm)
+{
+	free_slist(&sm->possible);
+	/*
+	 * fixme.  Free the actual state.
+	 * Right now we leave it until the end of the function
+	 * because we don't want to double free it.
+	 * Use the freelist to not double free things
+	 */
+}
+
+static void free_all_sm_states(struct allocation_blob *blob)
+{
+	unsigned int size = sizeof(struct sm_state);
+	unsigned int offset = 0;
+
+	while (offset < blob->offset) {
+		free_sm_state((struct sm_state *)(blob->data + offset));
+		offset += size;
+	}
+}
+
+/* At the end of every function we free all the sm_states */
+void free_every_single_sm_state(void)
+{
+	struct allocator_struct *desc = &sm_state_allocator;
+	struct allocation_blob *blob = desc->blobs;
+
+	desc->blobs = NULL;
+	desc->allocations = 0;
+	desc->total_bytes = 0;
+	desc->useful_bytes = 0;
+	desc->freelist = NULL;
+	while (blob) {
+		struct allocation_blob *next = blob->next;
+		free_all_sm_states(blob);
+		blob_free(blob, desc->chunking);
+		blob = next;
+	}
+	clear_sname_alloc();
+	clear_smatch_state_alloc();
+
+	free_stack_and_strees(&all_pools);
+	sm_state_counter = 0;
+}
+
+unsigned long get_pool_count(void)
+{
+	return ptr_list_size((struct ptr_list *)all_pools);
+}
+
+struct sm_state *clone_sm(struct sm_state *s)
+{
+	struct sm_state *ret;
+
+	ret = alloc_state_no_name(s->owner, s->name, s->sym, s->state);
+	ret->merged = s->merged;
+	ret->line = s->line;
+	/* clone_sm() doesn't copy the pools.  Each state needs to have
+	   only one pool. */
+	ret->possible = clone_slist(s->possible);
+	ret->left = s->left;
+	ret->right = s->right;
+	ret->nr_children = s->nr_children;
+	return ret;
+}
+
+int is_merged(struct sm_state *sm)
+{
+	return sm->merged;
+}
+
+int is_leaf(struct sm_state *sm)
+{
+	return !sm->merged;
+}
+
+int slist_has_state(struct state_list *slist, struct smatch_state *state)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_PTR(slist, tmp) {
+		if (tmp->state == state)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+struct state_list *clone_slist(struct state_list *from_slist)
+{
+	struct sm_state *sm;
+	struct state_list *to_slist = NULL;
+
+	FOR_EACH_PTR(from_slist, sm) {
+		add_ptr_list(&to_slist, sm);
+	} END_FOR_EACH_PTR(sm);
+	return to_slist;
+}
+
+static struct smatch_state *merge_states(int owner, const char *name,
+					 struct symbol *sym,
+					 struct smatch_state *state1,
+					 struct smatch_state *state2)
+{
+	struct smatch_state *ret;
+
+	if (state1 == state2)
+		ret = state1;
+	else if (__has_merge_function(owner))
+		ret = __client_merge_function(owner, state1, state2);
+	else if (state1 == &ghost)
+		ret = state2;
+	else if (state2 == &ghost)
+		ret = state1;
+	else if (!state1 || !state2)
+		ret = &undefined;
+	else
+		ret = &merged;
+	return ret;
+}
+
+struct sm_state *merge_sm_states(struct sm_state *one, struct sm_state *two)
+{
+	struct smatch_state *s;
+	struct sm_state *result;
+	static int warned;
+
+	if (one == two)
+		return one;
+	if (out_of_memory()) {
+		if (!warned)
+			sm_warning("Function too hairy.  No more merges.");
+		warned = 1;
+		return one;
+	}
+	warned = 0;
+	s = merge_states(one->owner, one->name, one->sym, one->state, two->state);
+	result = alloc_state_no_name(one->owner, one->name, one->sym, s);
+	result->merged = 1;
+	result->left = one;
+	result->right = two;
+	result->nr_children = one->nr_children + two->nr_children;
+	copy_possibles(result, one);
+	copy_possibles(result, two);
+
+	/*
+	 * The ->line information is used by deref_check where we complain about
+	 * checking pointers that have already been dereferenced.  Let's say we
+	 * dereference a pointer on both the true and false paths and then merge
+	 * the states here.  The result state is &derefed, but the ->line number
+	 * is on the line where the pointer is merged not where it was
+	 * dereferenced..
+	 *
+	 * So in that case, let's just pick one dereference and set the ->line
+	 * to point at it.
+	 *
+	 */
+
+	if (result->state == one->state)
+		result->line = one->line;
+	if (result->state == two->state)
+		result->line = two->line;
+
+	if (option_debug ||
+	    strcmp(check_name(one->owner), option_debug_check) == 0) {
+		struct sm_state *tmp;
+		int i = 0;
+
+		printf("%s:%d %s() merge [%s] '%s' %s(L %d) + %s(L %d) => %s (",
+			get_filename(), get_lineno(), get_function(),
+			check_name(one->owner), one->name,
+			show_state(one->state), one->line,
+			show_state(two->state), two->line,
+			show_state(s));
+
+		FOR_EACH_PTR(result->possible, tmp) {
+			if (i++)
+				printf(", ");
+			printf("%s", show_state(tmp->state));
+		} END_FOR_EACH_PTR(tmp);
+		printf(")\n");
+	}
+
+	return result;
+}
+
+struct sm_state *get_sm_state_stree(struct stree *stree, int owner, const char *name,
+				struct symbol *sym)
+{
+	struct tracker tracker = {
+		.owner = owner,
+		.name = (char *)name,
+		.sym = sym,
+	};
+
+	if (!name)
+		return NULL;
+
+
+	return avl_lookup(stree, (struct sm_state *)&tracker);
+}
+
+struct smatch_state *get_state_stree(struct stree *stree,
+				int owner, const char *name,
+				struct symbol *sym)
+{
+	struct sm_state *sm;
+
+	sm = get_sm_state_stree(stree, owner, name, sym);
+	if (sm)
+		return sm->state;
+	return NULL;
+}
+
+/* FIXME: this is almost exactly the same as set_sm_state_slist() */
+void overwrite_sm_state_stree(struct stree **stree, struct sm_state *new)
+{
+	avl_insert(stree, new);
+}
+
+void overwrite_sm_state_stree_stack(struct stree_stack **stack,
+			struct sm_state *sm)
+{
+	struct stree *stree;
+
+	stree = pop_stree(stack);
+	overwrite_sm_state_stree(&stree, sm);
+	push_stree(stack, stree);
+}
+
+struct sm_state *set_state_stree(struct stree **stree, int owner, const char *name,
+		     struct symbol *sym, struct smatch_state *state)
+{
+	struct sm_state *new = alloc_sm_state(owner, name, sym, state);
+
+	avl_insert(stree, new);
+	return new;
+}
+
+void set_state_stree_perm(struct stree **stree, int owner, const char *name,
+		     struct symbol *sym, struct smatch_state *state)
+{
+	struct sm_state *sm;
+
+	sm = malloc(sizeof(*sm) + strlen(name) + 1);
+	memset(sm, 0, sizeof(*sm));
+	sm->owner = owner;
+	sm->name = (char *)(sm + 1);
+	strcpy((char *)sm->name, name);
+	sm->sym = sym;
+	sm->state = state;
+
+	overwrite_sm_state_stree(stree, sm);
+}
+
+void delete_state_stree(struct stree **stree, int owner, const char *name,
+			struct symbol *sym)
+{
+	struct tracker tracker = {
+		.owner = owner,
+		.name = (char *)name,
+		.sym = sym,
+	};
+
+	avl_remove(stree, (struct sm_state *)&tracker);
+}
+
+void delete_state_stree_stack(struct stree_stack **stack, int owner, const char *name,
+			struct symbol *sym)
+{
+	struct stree *stree;
+
+	stree = pop_stree(stack);
+	delete_state_stree(&stree, owner, name, sym);
+	push_stree(stack, stree);
+}
+
+void push_stree(struct stree_stack **stack, struct stree *stree)
+{
+	add_ptr_list(stack, stree);
+}
+
+struct stree *pop_stree(struct stree_stack **stack)
+{
+	struct stree *stree;
+
+	stree = last_ptr_list((struct ptr_list *)*stack);
+	delete_ptr_list_last((struct ptr_list **)stack);
+	return stree;
+}
+
+struct stree *top_stree(struct stree_stack *stack)
+{
+	return last_ptr_list((struct ptr_list *)stack);
+}
+
+void free_slist(struct state_list **slist)
+{
+	__free_ptr_list((struct ptr_list **)slist);
+}
+
+void free_stree_stack(struct stree_stack **stack)
+{
+	__free_ptr_list((struct ptr_list **)stack);
+}
+
+void free_stack_and_strees(struct stree_stack **stree_stack)
+{
+	struct stree *stree;
+
+	FOR_EACH_PTR(*stree_stack, stree) {
+		free_stree(&stree);
+	} END_FOR_EACH_PTR(stree);
+	free_stree_stack(stree_stack);
+}
+
+struct sm_state *set_state_stree_stack(struct stree_stack **stack, int owner, const char *name,
+				struct symbol *sym, struct smatch_state *state)
+{
+	struct stree *stree;
+	struct sm_state *sm;
+
+	stree = pop_stree(stack);
+	sm = set_state_stree(&stree, owner, name, sym, state);
+	push_stree(stack, stree);
+
+	return sm;
+}
+
+/*
+ * get_sm_state_stack() gets the state for the top slist on the stack.
+ */
+struct sm_state *get_sm_state_stree_stack(struct stree_stack *stack,
+				int owner, const char *name,
+				struct symbol *sym)
+{
+	struct stree *stree;
+	struct sm_state *ret;
+
+	stree = pop_stree(&stack);
+	ret = get_sm_state_stree(stree, owner, name, sym);
+	push_stree(&stack, stree);
+	return ret;
+}
+
+struct smatch_state *get_state_stree_stack(struct stree_stack *stack,
+				int owner, const char *name,
+				struct symbol *sym)
+{
+	struct sm_state *sm;
+
+	sm = get_sm_state_stree_stack(stack, owner, name, sym);
+	if (sm)
+		return sm->state;
+	return NULL;
+}
+
+static void match_states_stree(struct stree **one, struct stree **two)
+{
+	struct smatch_state *tmp_state;
+	struct sm_state *sm;
+	struct state_list *add_to_one = NULL;
+	struct state_list *add_to_two = NULL;
+	AvlIter one_iter;
+	AvlIter two_iter;
+
+	avl_iter_begin(&one_iter, *one, FORWARD);
+	avl_iter_begin(&two_iter, *two, FORWARD);
+
+	for (;;) {
+		if (!one_iter.sm && !two_iter.sm)
+			break;
+		if (cmp_tracker(one_iter.sm, two_iter.sm) < 0) {
+			__set_fake_cur_stree_fast(*two);
+			tmp_state = __client_unmatched_state_function(one_iter.sm);
+			__pop_fake_cur_stree_fast();
+			sm = alloc_state_no_name(one_iter.sm->owner, one_iter.sm->name,
+						  one_iter.sm->sym, tmp_state);
+			add_ptr_list(&add_to_two, sm);
+			avl_iter_next(&one_iter);
+		} else if (cmp_tracker(one_iter.sm, two_iter.sm) == 0) {
+			avl_iter_next(&one_iter);
+			avl_iter_next(&two_iter);
+		} else {
+			__set_fake_cur_stree_fast(*one);
+			tmp_state = __client_unmatched_state_function(two_iter.sm);
+			__pop_fake_cur_stree_fast();
+			sm = alloc_state_no_name(two_iter.sm->owner, two_iter.sm->name,
+						  two_iter.sm->sym, tmp_state);
+			add_ptr_list(&add_to_one, sm);
+			avl_iter_next(&two_iter);
+		}
+	}
+
+	FOR_EACH_PTR(add_to_one, sm) {
+		avl_insert(one, sm);
+	} END_FOR_EACH_PTR(sm);
+
+	FOR_EACH_PTR(add_to_two, sm) {
+		avl_insert(two, sm);
+	} END_FOR_EACH_PTR(sm);
+
+	free_slist(&add_to_one);
+	free_slist(&add_to_two);
+}
+
+static void call_pre_merge_hooks(struct stree **one, struct stree **two)
+{
+	struct sm_state *sm, *other;
+
+	save_all_states();
+
+	__swap_cur_stree(*one);
+	FOR_EACH_SM(*two, sm) {
+		other = get_sm_state(sm->owner, sm->name, sm->sym);
+		if (other == sm)
+			continue;
+		call_pre_merge_hook(sm);
+	} END_FOR_EACH_SM(sm);
+	*one = clone_stree(__get_cur_stree());
+
+	__swap_cur_stree(*two);
+	FOR_EACH_SM(*one, sm) {
+		other = get_sm_state(sm->owner, sm->name, sm->sym);
+		if (other == sm)
+			continue;
+		call_pre_merge_hook(sm);
+	} END_FOR_EACH_SM(sm);
+	*two = clone_stree(__get_cur_stree());
+
+	restore_all_states();
+}
+
+static void clone_pool_havers_stree(struct stree **stree)
+{
+	struct sm_state *sm, *tmp;
+	struct state_list *slist = NULL;
+
+	FOR_EACH_SM(*stree, sm) {
+		if (sm->pool) {
+			tmp = clone_sm(sm);
+			add_ptr_list(&slist, tmp);
+		}
+	} END_FOR_EACH_SM(sm);
+
+	FOR_EACH_PTR(slist, sm) {
+		avl_insert(stree, sm);
+	} END_FOR_EACH_PTR(sm);
+
+	free_slist(&slist);
+}
+
+int __stree_id;
+
+/*
+ * merge_slist() is called whenever paths merge, such as after
+ * an if statement.  It takes the two slists and creates one.
+ */
+static void __merge_stree(struct stree **to, struct stree *stree, int add_pool)
+{
+	struct stree *results = NULL;
+	struct stree *implied_one = NULL;
+	struct stree *implied_two = NULL;
+	AvlIter one_iter;
+	AvlIter two_iter;
+	struct sm_state *tmp_sm;
+
+	if (out_of_memory())
+		return;
+
+	/* merging a null and nonnull path gives you only the nonnull path */
+	if (!stree)
+		return;
+	if (*to == stree)
+		return;
+
+	if (!*to) {
+		*to = clone_stree(stree);
+		return;
+	}
+
+	implied_one = clone_stree(*to);
+	implied_two = clone_stree(stree);
+
+	match_states_stree(&implied_one, &implied_two);
+	call_pre_merge_hooks(&implied_one, &implied_two);
+
+	if (add_pool) {
+		clone_pool_havers_stree(&implied_one);
+		clone_pool_havers_stree(&implied_two);
+
+		set_stree_id(&implied_one, ++__stree_id);
+		set_stree_id(&implied_two, ++__stree_id);
+		if (implied_one->base_stree)
+			set_stree_id(&implied_one->base_stree, ++__stree_id);
+		if (implied_two->base_stree)
+			set_stree_id(&implied_two->base_stree, ++__stree_id);
+	}
+
+	push_stree(&all_pools, implied_one);
+	push_stree(&all_pools, implied_two);
+
+	avl_iter_begin(&one_iter, implied_one, FORWARD);
+	avl_iter_begin(&two_iter, implied_two, FORWARD);
+
+	for (;;) {
+		if (!one_iter.sm || !two_iter.sm)
+			break;
+		if (cmp_tracker(one_iter.sm, two_iter.sm) < 0) {
+			sm_perror(" in %s", __func__);
+			avl_iter_next(&one_iter);
+		} else if (cmp_tracker(one_iter.sm, two_iter.sm) == 0) {
+			if (add_pool && one_iter.sm != two_iter.sm) {
+				one_iter.sm->pool = implied_one;
+				if (implied_one->base_stree)
+					one_iter.sm->pool = implied_one->base_stree;
+				two_iter.sm->pool = implied_two;
+				if (implied_two->base_stree)
+					two_iter.sm->pool = implied_two->base_stree;
+			}
+			tmp_sm = merge_sm_states(one_iter.sm, two_iter.sm);
+			add_possible_sm(tmp_sm, one_iter.sm);
+			add_possible_sm(tmp_sm, two_iter.sm);
+			avl_insert(&results, tmp_sm);
+			avl_iter_next(&one_iter);
+			avl_iter_next(&two_iter);
+		} else {
+			sm_perror(" in %s", __func__);
+			avl_iter_next(&two_iter);
+		}
+	}
+
+	free_stree(to);
+	*to = results;
+}
+
+void merge_stree(struct stree **to, struct stree *stree)
+{
+	__merge_stree(to, stree, 1);
+}
+
+void merge_stree_no_pools(struct stree **to, struct stree *stree)
+{
+	__merge_stree(to, stree, 0);
+}
+
+/*
+ * This is unfortunately a bit subtle...  The problem is that if a
+ * state is set on one fake stree but not the other then we should
+ * look up the the original state and use that as the unset state.
+ * Fortunately, after you pop your fake stree then the cur_slist should
+ * reflect the original state.
+ */
+void merge_fake_stree(struct stree **to, struct stree *stree)
+{
+	struct stree *one = *to;
+	struct stree *two = stree;
+	struct sm_state *sm;
+	struct state_list *add_to_one = NULL;
+	struct state_list *add_to_two = NULL;
+	AvlIter one_iter;
+	AvlIter two_iter;
+
+	if (!stree)
+		return;
+	if (*to == stree)
+		return;
+	if (!*to) {
+		*to = clone_stree(stree);
+		return;
+	}
+
+	avl_iter_begin(&one_iter, one, FORWARD);
+	avl_iter_begin(&two_iter, two, FORWARD);
+
+	for (;;) {
+		if (!one_iter.sm && !two_iter.sm)
+			break;
+		if (cmp_tracker(one_iter.sm, two_iter.sm) < 0) {
+			sm = get_sm_state(one_iter.sm->owner, one_iter.sm->name,
+					  one_iter.sm->sym);
+			if (sm)
+				add_ptr_list(&add_to_two, sm);
+			avl_iter_next(&one_iter);
+		} else if (cmp_tracker(one_iter.sm, two_iter.sm) == 0) {
+			avl_iter_next(&one_iter);
+			avl_iter_next(&two_iter);
+		} else {
+			sm = get_sm_state(two_iter.sm->owner, two_iter.sm->name,
+					  two_iter.sm->sym);
+			if (sm)
+				add_ptr_list(&add_to_one, sm);
+			avl_iter_next(&two_iter);
+		}
+	}
+
+	FOR_EACH_PTR(add_to_one, sm) {
+		avl_insert(&one, sm);
+	} END_FOR_EACH_PTR(sm);
+
+	FOR_EACH_PTR(add_to_two, sm) {
+		avl_insert(&two, sm);
+	} END_FOR_EACH_PTR(sm);
+
+	one->base_stree = clone_stree(__get_cur_stree());
+	FOR_EACH_SM(one, sm) {
+		avl_insert(&one->base_stree, sm);
+	} END_FOR_EACH_SM(sm);
+
+	two->base_stree = clone_stree(__get_cur_stree());
+	FOR_EACH_SM(two, sm) {
+		avl_insert(&two->base_stree, sm);
+	} END_FOR_EACH_SM(sm);
+
+	free_slist(&add_to_one);
+	free_slist(&add_to_two);
+
+	__merge_stree(&one, two, 1);
+
+	*to = one;
+}
+
+/*
+ * filter_slist() removes any sm states "slist" holds in common with "filter"
+ */
+void filter_stree(struct stree **stree, struct stree *filter)
+{
+	struct stree *results = NULL;
+	AvlIter one_iter;
+	AvlIter two_iter;
+
+	avl_iter_begin(&one_iter, *stree, FORWARD);
+	avl_iter_begin(&two_iter, filter, FORWARD);
+
+	/* FIXME: This should probably be re-written with trees in mind */
+
+	for (;;) {
+		if (!one_iter.sm && !two_iter.sm)
+			break;
+		if (cmp_tracker(one_iter.sm, two_iter.sm) < 0) {
+			avl_insert(&results, one_iter.sm);
+			avl_iter_next(&one_iter);
+		} else if (cmp_tracker(one_iter.sm, two_iter.sm) == 0) {
+			if (one_iter.sm != two_iter.sm)
+				avl_insert(&results, one_iter.sm);
+			avl_iter_next(&one_iter);
+			avl_iter_next(&two_iter);
+		} else {
+			avl_iter_next(&two_iter);
+		}
+	}
+
+	free_stree(stree);
+	*stree = results;
+}
+
+
+/*
+ * and_slist_stack() pops the top two slists, overwriting the one with
+ * the other and pushing it back on the stack.
+ */
+void and_stree_stack(struct stree_stack **stack)
+{
+	struct sm_state *tmp;
+	struct stree *right_stree = pop_stree(stack);
+
+	FOR_EACH_SM(right_stree, tmp) {
+		overwrite_sm_state_stree_stack(stack, tmp);
+	} END_FOR_EACH_SM(tmp);
+	free_stree(&right_stree);
+}
+
+/*
+ * or_slist_stack() is for if we have:  if (foo || bar) { foo->baz;
+ * It pops the two slists from the top of the stack and merges them
+ * together in a way that preserves the things they have in common
+ * but creates a merged state for most of the rest.
+ * You could have code that had:  if (foo || foo) { foo->baz;
+ * It's this function which ensures smatch does the right thing.
+ */
+void or_stree_stack(struct stree_stack **pre_conds,
+		    struct stree *cur_stree,
+		    struct stree_stack **stack)
+{
+	struct stree *new;
+	struct stree *old;
+	struct stree *pre_stree;
+	struct stree *res;
+	struct stree *tmp_stree;
+
+	new = pop_stree(stack);
+	old = pop_stree(stack);
+
+	pre_stree = pop_stree(pre_conds);
+	push_stree(pre_conds, clone_stree(pre_stree));
+
+	res = clone_stree(pre_stree);
+	overwrite_stree(old, &res);
+
+	tmp_stree = clone_stree(cur_stree);
+	overwrite_stree(new, &tmp_stree);
+
+	merge_stree(&res, tmp_stree);
+	filter_stree(&res, pre_stree);
+
+	push_stree(stack, res);
+	free_stree(&tmp_stree);
+	free_stree(&pre_stree);
+	free_stree(&new);
+	free_stree(&old);
+}
+
+/*
+ * get_named_stree() is only used for gotos.
+ */
+struct stree **get_named_stree(struct named_stree_stack *stack,
+			       const char *name,
+			       struct symbol *sym)
+{
+	struct named_stree *tmp;
+
+	FOR_EACH_PTR(stack, tmp) {
+		if (tmp->sym == sym &&
+		    strcmp(tmp->name, name) == 0)
+			return &tmp->stree;
+	} END_FOR_EACH_PTR(tmp);
+	return NULL;
+}
+
+/* FIXME:  These parameters are in a different order from expected */
+void overwrite_stree(struct stree *from, struct stree **to)
+{
+	struct sm_state *tmp;
+
+	FOR_EACH_SM(from, tmp) {
+		overwrite_sm_state_stree(to, tmp);
+	} END_FOR_EACH_SM(tmp);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_slist.h b/usr/src/tools/smatch/src/smatch_slist.h
new file mode 100644
index 0000000000..358756b25d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_slist.h
@@ -0,0 +1,98 @@
+struct stree;
+
+extern int unfree_stree;
+
+DECLARE_PTR_LIST(state_list, struct sm_state);
+DECLARE_PTR_LIST(state_list_stack, struct state_list);
+
+struct named_stree {
+	char *name;
+	struct symbol *sym;
+	struct stree *stree;
+};
+DECLARE_ALLOCATOR(named_stree);
+DECLARE_PTR_LIST(named_stree_stack, struct named_stree);
+
+
+extern struct state_list_stack *implied_pools;
+extern int __stree_id;
+extern int sm_state_counter;
+
+const char *show_sm(struct sm_state *sm);
+void __print_stree(struct stree *stree);
+void add_history(struct sm_state *sm);
+int cmp_tracker(const struct sm_state *a, const struct sm_state *b);
+char *alloc_sname(const char *str);
+struct sm_state *alloc_sm_state(int owner, const char *name,
+				struct symbol *sym, struct smatch_state *state);
+
+void free_every_single_sm_state(void);
+struct sm_state *clone_sm(struct sm_state *s);
+int is_merged(struct sm_state *sm);
+int is_leaf(struct sm_state *sm);
+struct state_list *clone_slist(struct state_list *from_slist);
+
+int slist_has_state(struct state_list *slist, struct smatch_state *state);
+
+int too_many_possible(struct sm_state *sm);
+void add_possible_sm(struct sm_state *to, struct sm_state *new);
+struct sm_state *merge_sm_states(struct sm_state *one, struct sm_state *two);
+struct smatch_state *get_state_stree(struct stree *stree, int owner, const char *name,
+		    struct symbol *sym);
+
+struct sm_state *get_sm_state_stree(struct stree *stree, int owner, const char *name,
+		    struct symbol *sym);
+
+void overwrite_sm_state_stree(struct stree **stree, struct sm_state *sm);
+void overwrite_sm_state_stree_stack(struct stree_stack **stack, struct sm_state *sm);
+struct sm_state *set_state_stree(struct stree **stree, int owner, const char *name,
+		     struct symbol *sym, struct smatch_state *state);
+void set_state_stree_perm(struct stree **stree, int owner, const char *name,
+		     struct symbol *sym, struct smatch_state *state);
+void delete_state_stree(struct stree **stree, int owner, const char *name,
+			struct symbol *sym);
+
+void delete_state_stree_stack(struct stree_stack **stack, int owner, const char *name,
+			struct symbol *sym);
+
+void push_stree(struct stree_stack **list_stack, struct stree *stree);
+struct stree *pop_stree(struct stree_stack **list_stack);
+struct stree *top_stree(struct stree_stack *stack);
+
+void free_slist(struct state_list **slist);
+void free_stree_stack(struct stree_stack **stack);
+void free_stack_and_strees(struct stree_stack **stree_stack);
+unsigned long get_pool_count(void);
+
+struct sm_state *set_state_stree_stack(struct stree_stack **stack, int owner, const char *name,
+				struct symbol *sym, struct smatch_state *state);
+
+struct sm_state *get_sm_state_stree_stack(struct stree_stack *stack,
+				int owner, const char *name,
+				struct symbol *sym);
+struct smatch_state *get_state_stree_stack(struct stree_stack *stack, int owner,
+				const char *name, struct symbol *sym);
+
+int out_of_memory(void);
+int low_on_memory(void);
+void merge_stree(struct stree **to, struct stree *stree);
+void merge_stree_no_pools(struct stree **to, struct stree *stree);
+void merge_stree(struct stree **to, struct stree *right);
+void merge_fake_stree(struct stree **to, struct stree *stree);
+void filter_stree(struct stree **stree, struct stree *filter);
+void and_stree_stack(struct stree_stack **stree_stack);
+
+void or_stree_stack(struct stree_stack **pre_conds,
+		    struct stree *cur_stree,
+		    struct stree_stack **stack);
+
+struct stree **get_named_stree(struct named_stree_stack *stack,
+			       const char *name,
+			       struct symbol *sym);
+
+void overwrite_stree(struct stree *from, struct stree **to);
+
+/* add stuff smatch_returns.c here */
+
+void all_return_states_hook(void (*callback)(void));
+
diff --git a/usr/src/tools/smatch/src/smatch_start_states.c b/usr/src/tools/smatch/src/smatch_start_states.c
new file mode 100644
index 0000000000..1c3d4b3809
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_start_states.c
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Store the states at the start of the function because this is something that
+ * is used in a couple places.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+
+static struct stree *start_states;
+static struct stree_stack *saved_stack;
+static void save_start_states(struct statement *stmt)
+{
+	start_states = clone_stree(__get_cur_stree());
+}
+
+static void match_save_states(struct expression *expr)
+{
+	push_stree(&saved_stack, start_states);
+	start_states = NULL;
+}
+
+static void match_restore_states(struct expression *expr)
+{
+	free_stree(&start_states);
+	start_states = pop_stree(&saved_stack);
+}
+
+static void match_end_func(void)
+{
+	free_stree(&start_states);
+}
+
+struct stree *get_start_states(void)
+{
+	return start_states;
+}
+
+void register_start_states(int id)
+{
+	my_id = id;
+
+	add_hook(&save_start_states, AFTER_DEF_HOOK);
+	add_hook(&match_save_states, INLINE_FN_START);
+	add_hook(&match_restore_states, INLINE_FN_END);
+	add_hook(&match_end_func, AFTER_FUNC_HOOK);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_statement_count.c b/usr/src/tools/smatch/src/smatch_statement_count.c
new file mode 100644
index 0000000000..1bc6383479
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_statement_count.c
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2018 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdlib.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static struct smatch_state *merge_states(struct smatch_state *s1, struct smatch_state *s2)
+{
+	int left, right, min;
+
+	left = PTR_INT(s1->data);
+	right = PTR_INT(s2->data);
+
+	min = left;
+	if (right < min)
+		min = right;
+	return alloc_state_num(min);
+}
+
+long get_stmt_cnt(void)
+{
+	struct smatch_state *state;
+
+	state = get_state(my_id, "stmts", NULL);
+	if (!state)
+		return 0;
+	return (long)state->data;
+}
+
+static void match_statement(struct statement *stmt)
+{
+	int cnt;
+
+	cnt = get_stmt_cnt();
+	cnt++;
+	set_state(my_id, "stmts", NULL, alloc_state_num(cnt));
+}
+
+static void insert_return_info(int return_id, char *return_ranges, struct expression *expr)
+{
+	char buf[32];
+	int cnt;
+
+	cnt = get_stmt_cnt();
+	snprintf(buf, sizeof(buf), "%d", cnt);
+	sql_insert_return_states(return_id, return_ranges, STMT_CNT, -1, "", buf);
+}
+
+static void select_return_info(struct expression *expr, int param, char *key, char *value)
+{
+	int cnt, add;
+
+	cnt = get_stmt_cnt();
+	add = atoi(value);
+
+	set_state(my_id, "stmts", NULL, alloc_state_num(cnt + add));
+}
+
+void register_statement_count(int id)
+{
+	my_id = id;
+
+	add_hook(match_statement, STMT_HOOK);
+	add_merge_hook(my_id, &merge_states);
+
+	add_split_return_callback(&insert_return_info);
+	select_return_states_hook(STMT_CNT, &select_return_info);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_states.c b/usr/src/tools/smatch/src/smatch_states.c
new file mode 100644
index 0000000000..c7a9c85d2b
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_states.c
@@ -0,0 +1,1144 @@
+/*
+ * Copyright (C) 2006 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * You have a lists of states.  kernel = locked, foo = NULL, ...
+ * When you hit an if {} else {} statement then you swap the list
+ * of states for a different list of states.  The lists are stored
+ * on stacks.
+ *
+ * At the beginning of this file there are list of the stacks that
+ * we use.  Each function in this file does something to one of
+ * of the stacks.
+ *
+ * So the smatch_flow.c understands code but it doesn't understand states.
+ * smatch_flow calls functions in this file.  This file calls functions
+ * in smatch_slist.c which just has boring generic plumbing for handling
+ * state lists.  But really it's this file where all the magic happens.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+struct smatch_state undefined = { .name = "undefined" };
+struct smatch_state ghost = { .name = "ghost" };
+struct smatch_state merged = { .name = "merged" };
+struct smatch_state true_state = { .name = "true" };
+struct smatch_state false_state = { .name = "false" };
+
+static struct stree *cur_stree; /* current states */
+
+static struct stree_stack *true_stack; /* states after a t/f branch */
+static struct stree_stack *false_stack;
+static struct stree_stack *pre_cond_stack; /* states before a t/f branch */
+
+static struct stree_stack *cond_true_stack; /* states affected by a branch */
+static struct stree_stack *cond_false_stack;
+
+static struct stree_stack *fake_cur_stree_stack;
+static int read_only;
+
+static struct stree_stack *break_stack;
+static struct stree_stack *fake_break_stack;
+static struct stree_stack *switch_stack;
+static struct range_list_stack *remaining_cases;
+static struct stree_stack *default_stack;
+static struct stree_stack *continue_stack;
+
+static struct named_stree_stack *goto_stack;
+
+static struct ptr_list *backup;
+
+int option_debug;
+
+void __print_cur_stree(void)
+{
+	__print_stree(cur_stree);
+}
+
+int unreachable(void)
+{
+	if (!cur_stree)
+		return 1;
+	return 0;
+}
+
+struct sm_state *set_state(int owner, const char *name, struct symbol *sym, struct smatch_state *state)
+{
+	struct sm_state *ret;
+
+	if (!name)
+		return NULL;
+
+	if (read_only)
+		sm_perror("cur_stree is read only.");
+
+	if (option_debug || strcmp(check_name(owner), option_debug_check) == 0) {
+		struct smatch_state *s;
+
+		s = get_state(owner, name, sym);
+		if (!s)
+			sm_msg("%s new [%s] '%s' %s", __func__,
+			       check_name(owner), name, show_state(state));
+		else
+			sm_msg("%s change [%s] '%s' %s => %s",
+				__func__, check_name(owner), name, show_state(s),
+				show_state(state));
+	}
+
+	if (owner != -1 && unreachable())
+		return NULL;
+
+	if (fake_cur_stree_stack)
+		set_state_stree_stack(&fake_cur_stree_stack, owner, name, sym, state);
+
+	ret = set_state_stree(&cur_stree, owner, name, sym, state);
+
+	return ret;
+}
+
+struct sm_state *set_state_expr(int owner, struct expression *expr, struct smatch_state *state)
+{
+	char *name;
+	struct symbol *sym;
+	struct sm_state *ret = NULL;
+
+	expr = strip_expr(expr);
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	ret = set_state(owner, name, sym, state);
+free:
+	free_string(name);
+	return ret;
+}
+
+void __swap_cur_stree(struct stree *stree)
+{
+	free_stree(&cur_stree);
+	cur_stree = stree;
+}
+
+void __push_fake_cur_stree(void)
+{
+	push_stree(&fake_cur_stree_stack, NULL);
+	__save_pre_cond_states();
+}
+
+struct stree *__pop_fake_cur_stree(void)
+{
+	if (!fake_cur_stree_stack)
+		sm_perror("popping too many fake cur strees.");
+	__use_pre_cond_states();
+	return pop_stree(&fake_cur_stree_stack);
+}
+
+void __free_fake_cur_stree(void)
+{
+	struct stree *stree;
+
+	stree = __pop_fake_cur_stree();
+	free_stree(&stree);
+}
+
+void __set_fake_cur_stree_fast(struct stree *stree)
+{
+	push_stree(&pre_cond_stack, cur_stree);
+	cur_stree = stree;
+	read_only = 1;
+}
+
+void __pop_fake_cur_stree_fast(void)
+{
+	cur_stree = pop_stree(&pre_cond_stack);
+	read_only = 0;
+}
+
+void __merge_stree_into_cur(struct stree *stree)
+{
+	struct sm_state *sm;
+	struct sm_state *orig;
+	struct sm_state *merged;
+
+	FOR_EACH_SM(stree, sm) {
+		orig = get_sm_state(sm->owner, sm->name, sm->sym);
+		if (orig)
+			merged = merge_sm_states(orig, sm);
+		else
+			merged = sm;
+		__set_sm(merged);
+	} END_FOR_EACH_SM(sm);
+}
+
+void __set_sm(struct sm_state *sm)
+{
+	if (read_only)
+		sm_perror("cur_stree is read only.");
+
+	if (option_debug ||
+	    strcmp(check_name(sm->owner), option_debug_check) == 0) {
+		struct smatch_state *s;
+
+		s = get_state(sm->owner, sm->name, sm->sym);
+		if (!s)
+			sm_msg("%s new %s", __func__, show_sm(sm));
+		else
+			sm_msg("%s change %s (was %s)",	__func__, show_sm(sm),
+			       show_state(s));
+	}
+
+	if (unreachable())
+		return;
+
+	if (fake_cur_stree_stack)
+		overwrite_sm_state_stree_stack(&fake_cur_stree_stack, sm);
+
+	overwrite_sm_state_stree(&cur_stree, sm);
+}
+
+void __set_sm_cur_stree(struct sm_state *sm)
+{
+	if (read_only)
+		sm_perror("cur_stree is read only.");
+
+	if (option_debug ||
+	    strcmp(check_name(sm->owner), option_debug_check) == 0) {
+		struct smatch_state *s;
+
+		s = get_state(sm->owner, sm->name, sm->sym);
+		if (!s)
+			sm_msg("%s new %s", __func__, show_sm(sm));
+		else
+			sm_msg("%s change %s (was %s)",
+				__func__, show_sm(sm), show_state(s));
+	}
+
+	if (unreachable())
+		return;
+
+	overwrite_sm_state_stree(&cur_stree, sm);
+}
+
+void __set_sm_fake_stree(struct sm_state *sm)
+{
+	if (read_only)
+		sm_perror("cur_stree is read only.");
+
+	if (option_debug ||
+	    strcmp(check_name(sm->owner), option_debug_check) == 0) {
+		struct smatch_state *s;
+
+		s = get_state(sm->owner, sm->name, sm->sym);
+		if (!s)
+			sm_msg("%s new %s", __func__, show_sm(sm));
+		else
+			sm_msg("%s change %s (was %s)",
+				__func__, show_sm(sm), show_state(s));
+	}
+
+	if (unreachable())
+		return;
+
+	overwrite_sm_state_stree_stack(&fake_cur_stree_stack, sm);
+}
+
+
+typedef void (get_state_hook)(int owner, const char *name, struct symbol *sym);
+DECLARE_PTR_LIST(fn_list, get_state_hook *);
+static struct fn_list *get_state_hooks;
+
+void add_get_state_hook(get_state_hook *fn)
+{
+	get_state_hook **p = malloc(sizeof(get_state_hook *));
+	*p = fn;
+	add_ptr_list(&get_state_hooks, p);
+}
+
+static void call_get_state_hooks(int owner, const char *name, struct symbol *sym)
+{
+	static int recursion;
+	get_state_hook **fn;
+
+	if (recursion)
+		return;
+	recursion = 1;
+
+	FOR_EACH_PTR(get_state_hooks, fn) {
+		(*fn)(owner, name, sym);
+	} END_FOR_EACH_PTR(fn);
+
+	recursion = 0;
+}
+
+struct smatch_state *__get_state(int owner, const char *name, struct symbol *sym)
+{
+	return get_state_stree(cur_stree, owner, name, sym);
+}
+
+struct smatch_state *get_state(int owner, const char *name, struct symbol *sym)
+{
+	call_get_state_hooks(owner, name, sym);
+
+	return __get_state(owner, name, sym);
+}
+
+struct smatch_state *get_state_expr(int owner, struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	struct smatch_state *ret = NULL;
+
+	expr = strip_expr(expr);
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	ret = get_state(owner, name, sym);
+free:
+	free_string(name);
+	return ret;
+}
+
+struct state_list *get_possible_states(int owner, const char *name, struct symbol *sym)
+{
+	struct sm_state *sms;
+
+	sms = get_sm_state_stree(cur_stree, owner, name, sym);
+	if (sms)
+		return sms->possible;
+	return NULL;
+}
+
+struct state_list *get_possible_states_expr(int owner, struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	struct state_list *ret = NULL;
+
+	expr = strip_expr(expr);
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	ret = get_possible_states(owner, name, sym);
+free:
+	free_string(name);
+	return ret;
+}
+
+struct sm_state *get_sm_state(int owner, const char *name, struct symbol *sym)
+{
+	return get_sm_state_stree(cur_stree, owner, name, sym);
+}
+
+struct sm_state *get_sm_state_expr(int owner, struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	struct sm_state *ret = NULL;
+
+	expr = strip_expr(expr);
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	ret = get_sm_state(owner, name, sym);
+free:
+	free_string(name);
+	return ret;
+}
+
+void delete_state(int owner, const char *name, struct symbol *sym)
+{
+	delete_state_stree(&cur_stree, owner, name, sym);
+	if (cond_true_stack) {
+		delete_state_stree_stack(&pre_cond_stack, owner, name, sym);
+		delete_state_stree_stack(&cond_true_stack, owner, name, sym);
+		delete_state_stree_stack(&cond_false_stack, owner, name, sym);
+	}
+}
+
+void delete_state_expr(int owner, struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+
+	expr = strip_expr(expr);
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	delete_state(owner, name, sym);
+free:
+	free_string(name);
+}
+
+static void delete_all_states_stree_sym(struct stree **stree, struct symbol *sym)
+{
+	struct state_list *slist = NULL;
+	struct sm_state *sm;
+
+	FOR_EACH_SM(*stree, sm) {
+		if (sm->sym == sym)
+			add_ptr_list(&slist, sm);
+	} END_FOR_EACH_SM(sm);
+
+	FOR_EACH_PTR(slist, sm) {
+		delete_state_stree(stree, sm->owner, sm->name, sm->sym);
+	} END_FOR_EACH_PTR(sm);
+
+	free_slist(&slist);
+}
+
+static void delete_all_states_stree_stack_sym(struct stree_stack **stack, struct symbol *sym)
+{
+	struct stree *stree;
+
+	if (!*stack)
+		return;
+
+	stree = pop_stree(stack);
+	delete_all_states_stree_sym(&stree, sym);
+	push_stree(stack, stree);
+}
+
+void __delete_all_states_sym(struct symbol *sym)
+{
+	delete_all_states_stree_sym(&cur_stree, sym);
+
+	delete_all_states_stree_stack_sym(&true_stack, sym);
+	delete_all_states_stree_stack_sym(&true_stack, sym);
+	delete_all_states_stree_stack_sym(&false_stack, sym);
+	delete_all_states_stree_stack_sym(&pre_cond_stack, sym);
+	delete_all_states_stree_stack_sym(&cond_true_stack, sym);
+	delete_all_states_stree_stack_sym(&cond_false_stack, sym);
+	delete_all_states_stree_stack_sym(&fake_cur_stree_stack, sym);
+	delete_all_states_stree_stack_sym(&break_stack, sym);
+	delete_all_states_stree_stack_sym(&fake_break_stack, sym);
+	delete_all_states_stree_stack_sym(&switch_stack, sym);
+	delete_all_states_stree_stack_sym(&continue_stack, sym);
+
+	/*
+	 * deleting from the goto stack is problematic because we don't know
+	 * if the label is in scope and also we need the value for --two-passes.
+	 */
+}
+
+struct stree *get_all_states_from_stree(int owner, struct stree *source)
+{
+	struct stree *ret = NULL;
+	struct sm_state *tmp;
+
+	FOR_EACH_SM(source, tmp) {
+		if (tmp->owner == owner)
+			avl_insert(&ret, tmp);
+	} END_FOR_EACH_SM(tmp);
+
+	return ret;
+}
+
+struct stree *get_all_states_stree(int owner)
+{
+	return get_all_states_from_stree(owner, cur_stree);
+}
+
+struct stree *__get_cur_stree(void)
+{
+	return cur_stree;
+}
+
+int is_reachable(void)
+{
+	if (cur_stree)
+		return 1;
+	return 0;
+}
+
+void set_true_false_states(int owner, const char *name, struct symbol *sym,
+			   struct smatch_state *true_state,
+			   struct smatch_state *false_state)
+{
+	if (read_only)
+		sm_perror("cur_stree is read only.");
+
+	if (option_debug || strcmp(check_name(owner), option_debug_check) == 0) {
+		struct smatch_state *tmp;
+
+		tmp = get_state(owner, name, sym);
+		sm_msg("%s [%s] '%s'.  Was %s.  Now T:%s F:%s", __func__,
+		       check_name(owner),  name, show_state(tmp),
+		       show_state(true_state), show_state(false_state));
+	}
+
+	if (unreachable())
+		return;
+
+	if (!cond_false_stack || !cond_true_stack) {
+		sm_perror("missing true/false stacks");
+		return;
+	}
+
+	if (true_state)
+		set_state_stree_stack(&cond_true_stack, owner, name, sym, true_state);
+	if (false_state)
+		set_state_stree_stack(&cond_false_stack, owner, name, sym, false_state);
+}
+
+void set_true_false_states_expr(int owner, struct expression *expr,
+			   struct smatch_state *true_state,
+			   struct smatch_state *false_state)
+{
+	char *name;
+	struct symbol *sym;
+
+	expr = strip_expr(expr);
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	set_true_false_states(owner, name, sym, true_state, false_state);
+free:
+	free_string(name);
+}
+
+void __set_true_false_sm(struct sm_state *true_sm, struct sm_state *false_sm)
+{
+	int owner;
+	const char *name;
+	struct symbol *sym;
+
+	if (!true_sm && !false_sm)
+		return;
+
+	if (unreachable())
+		return;
+
+	owner = true_sm ? true_sm->owner : false_sm->owner;
+	name = true_sm ? true_sm->name : false_sm->name;
+	sym = true_sm ? true_sm->sym : false_sm->sym;
+	if (option_debug || strcmp(check_name(owner), option_debug_check) == 0) {
+		struct smatch_state *tmp;
+
+		tmp = get_state(owner, name, sym);
+		sm_msg("%s [%s] '%s'.  Was %s.  Now T:%s F:%s", __func__,
+		       check_name(owner),  name, show_state(tmp),
+		       show_state(true_sm ? true_sm->state : NULL),
+		       show_state(false_sm ? false_sm->state : NULL));
+	}
+
+	if (!cond_false_stack || !cond_true_stack) {
+		sm_perror("missing true/false stacks");
+		return;
+	}
+
+	if (true_sm)
+		overwrite_sm_state_stree_stack(&cond_true_stack, true_sm);
+	if (false_sm)
+		overwrite_sm_state_stree_stack(&cond_false_stack, false_sm);
+}
+
+void nullify_path(void)
+{
+	if (fake_cur_stree_stack) {
+		__free_fake_cur_stree();
+		__push_fake_cur_stree();
+	}
+	free_stree(&cur_stree);
+}
+
+void __match_nullify_path_hook(const char *fn, struct expression *expr,
+			       void *unused)
+{
+	nullify_path();
+}
+
+/*
+ * At the start of every function we mark the path
+ * as unnull.  That way there is always at least one state
+ * in the cur_stree until nullify_path is called.  This
+ * is used in merge_slist() for the first null check.
+ */
+void __unnullify_path(void)
+{
+	if (!cur_stree)
+		set_state(-1, "unnull_path", NULL, &true_state);
+}
+
+int __path_is_null(void)
+{
+	if (cur_stree)
+		return 0;
+	return 1;
+}
+
+static void check_stree_stack_free(struct stree_stack **stack)
+{
+	if (*stack) {
+		sm_perror("stack not empty");
+		free_stack_and_strees(stack);
+	}
+}
+
+void save_all_states(void)
+{
+	__add_ptr_list(&backup, cur_stree, 0);
+	cur_stree = NULL;
+
+	__add_ptr_list(&backup, true_stack, 0);
+	true_stack = NULL;
+	__add_ptr_list(&backup, false_stack, 0);
+	false_stack = NULL;
+	__add_ptr_list(&backup, pre_cond_stack, 0);
+	pre_cond_stack = NULL;
+
+	__add_ptr_list(&backup, cond_true_stack, 0);
+	cond_true_stack = NULL;
+	__add_ptr_list(&backup, cond_false_stack, 0);
+	cond_false_stack = NULL;
+
+	__add_ptr_list(&backup, fake_cur_stree_stack, 0);
+	fake_cur_stree_stack = NULL;
+
+	__add_ptr_list(&backup, break_stack, 0);
+	break_stack = NULL;
+	__add_ptr_list(&backup, fake_break_stack, 0);
+	fake_break_stack = NULL;
+
+	__add_ptr_list(&backup, switch_stack, 0);
+	switch_stack = NULL;
+	__add_ptr_list(&backup, remaining_cases, 0);
+	remaining_cases = NULL;
+	__add_ptr_list(&backup, default_stack, 0);
+	default_stack = NULL;
+	__add_ptr_list(&backup, continue_stack, 0);
+	continue_stack = NULL;
+
+	__add_ptr_list(&backup, goto_stack, 0);
+	goto_stack = NULL;
+}
+
+static void *pop_backup(void)
+{
+	void *ret;
+
+	ret = last_ptr_list(backup);
+	delete_ptr_list_last(&backup);
+	return ret;
+}
+
+void restore_all_states(void)
+{
+	goto_stack = pop_backup();
+
+	continue_stack = pop_backup();
+	default_stack = pop_backup();
+	remaining_cases = pop_backup();
+	switch_stack = pop_backup();
+	fake_break_stack = pop_backup();
+	break_stack = pop_backup();
+
+	fake_cur_stree_stack = pop_backup();
+
+	cond_false_stack = pop_backup();
+	cond_true_stack = pop_backup();
+
+	pre_cond_stack = pop_backup();
+	false_stack = pop_backup();
+	true_stack = pop_backup();
+
+	cur_stree = pop_backup();
+}
+
+void free_goto_stack(void)
+{
+	struct named_stree *named_stree;
+
+	FOR_EACH_PTR(goto_stack, named_stree) {
+		free_stree(&named_stree->stree);
+	} END_FOR_EACH_PTR(named_stree);
+	__free_ptr_list((struct ptr_list **)&goto_stack);
+}
+
+void clear_all_states(void)
+{
+	nullify_path();
+	check_stree_stack_free(&true_stack);
+	check_stree_stack_free(&false_stack);
+	check_stree_stack_free(&pre_cond_stack);
+	check_stree_stack_free(&cond_true_stack);
+	check_stree_stack_free(&cond_false_stack);
+	check_stree_stack_free(&break_stack);
+	check_stree_stack_free(&fake_break_stack);
+	check_stree_stack_free(&switch_stack);
+	check_stree_stack_free(&continue_stack);
+	check_stree_stack_free(&fake_cur_stree_stack);
+
+	free_goto_stack();
+
+	free_every_single_sm_state();
+	free_tmp_expressions();
+}
+
+void __push_cond_stacks(void)
+{
+	push_stree(&cond_true_stack, NULL);
+	push_stree(&cond_false_stack, NULL);
+	__push_fake_cur_stree();
+}
+
+void __fold_in_set_states(void)
+{
+	struct stree *new_states;
+	struct sm_state *sm;
+
+	new_states = __pop_fake_cur_stree();
+	FOR_EACH_SM(new_states, sm) {
+		__set_sm(sm);
+		__set_true_false_sm(sm, sm);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&new_states);
+}
+
+void __free_set_states(void)
+{
+	struct stree *new_states;
+
+	new_states = __pop_fake_cur_stree();
+	free_stree(&new_states);
+}
+
+struct stree *__copy_cond_true_states(void)
+{
+	struct stree *ret;
+
+	ret = pop_stree(&cond_true_stack);
+	push_stree(&cond_true_stack, clone_stree(ret));
+	return ret;
+}
+
+struct stree *__copy_cond_false_states(void)
+{
+	struct stree *ret;
+
+	ret = pop_stree(&cond_false_stack);
+	push_stree(&cond_false_stack, clone_stree(ret));
+	return ret;
+}
+
+struct stree *__pop_cond_true_stack(void)
+{
+	return pop_stree(&cond_true_stack);
+}
+
+struct stree *__pop_cond_false_stack(void)
+{
+	return pop_stree(&cond_false_stack);
+}
+
+/*
+ * This combines the pre cond states with either the true or false states.
+ * For example:
+ * a = kmalloc() ; if (a !! foo(a)
+ * In the pre state a is possibly null.  In the true state it is non null.
+ * In the false state it is null.  Combine the pre and the false to get
+ * that when we call 'foo', 'a' is null.
+ */
+static void __use_cond_stack(struct stree_stack **stack)
+{
+	struct stree *stree;
+
+	free_stree(&cur_stree);
+
+	cur_stree = pop_stree(&pre_cond_stack);
+	push_stree(&pre_cond_stack, clone_stree(cur_stree));
+
+	stree = pop_stree(stack);
+	overwrite_stree(stree, &cur_stree);
+	push_stree(stack, stree);
+}
+
+void __use_pre_cond_states(void)
+{
+	free_stree(&cur_stree);
+	cur_stree = pop_stree(&pre_cond_stack);
+}
+
+void __use_cond_true_states(void)
+{
+	__use_cond_stack(&cond_true_stack);
+}
+
+void __use_cond_false_states(void)
+{
+	__use_cond_stack(&cond_false_stack);
+}
+
+void __negate_cond_stacks(void)
+{
+	struct stree *old_false, *old_true;
+
+	__use_cond_stack(&cond_false_stack);
+	old_false = pop_stree(&cond_false_stack);
+	old_true = pop_stree(&cond_true_stack);
+	push_stree(&cond_false_stack, old_true);
+	push_stree(&cond_true_stack, old_false);
+}
+
+void __and_cond_states(void)
+{
+	and_stree_stack(&cond_true_stack);
+	or_stree_stack(&pre_cond_stack, cur_stree, &cond_false_stack);
+}
+
+void __or_cond_states(void)
+{
+	or_stree_stack(&pre_cond_stack, cur_stree, &cond_true_stack);
+	and_stree_stack(&cond_false_stack);
+}
+
+void __save_pre_cond_states(void)
+{
+	push_stree(&pre_cond_stack, clone_stree(cur_stree));
+}
+
+void __discard_pre_cond_states(void)
+{
+	struct stree *tmp;
+
+	tmp = pop_stree(&pre_cond_stack);
+	free_stree(&tmp);
+}
+
+struct stree *__get_true_states(void)
+{
+	return clone_stree(top_stree(cond_true_stack));
+}
+
+struct stree *__get_false_states(void)
+{
+	return clone_stree(top_stree(cond_false_stack));
+}
+
+void __use_cond_states(void)
+{
+	struct stree *pre, *pre_clone, *true_states, *false_states;
+
+	pre = pop_stree(&pre_cond_stack);
+	pre_clone = clone_stree(pre);
+
+	true_states = pop_stree(&cond_true_stack);
+	overwrite_stree(true_states, &pre);
+	free_stree(&true_states);
+	/* we use the true states right away */
+	free_stree(&cur_stree);
+	cur_stree = pre;
+
+	false_states = pop_stree(&cond_false_stack);
+	overwrite_stree(false_states, &pre_clone);
+	free_stree(&false_states);
+	push_stree(&false_stack, pre_clone);
+}
+
+void __push_true_states(void)
+{
+	push_stree(&true_stack, clone_stree(cur_stree));
+}
+
+void __use_false_states(void)
+{
+	free_stree(&cur_stree);
+	cur_stree = pop_stree(&false_stack);
+}
+
+void __discard_false_states(void)
+{
+	struct stree *stree;
+
+	stree = pop_stree(&false_stack);
+	free_stree(&stree);
+}
+
+void __merge_false_states(void)
+{
+	struct stree *stree;
+
+	stree = pop_stree(&false_stack);
+	merge_stree(&cur_stree, stree);
+	free_stree(&stree);
+}
+
+/*
+ * This function probably seemed common sensical when I wrote it but, oh wow,
+ * does it look subtle in retrospect.  Say we set a state on one side of the if
+ * else path but not on the other, then what we should record in the fake stree
+ * is the merged state.
+ *
+ * This function relies on the fact that the we always set the cur_stree as well
+ * and we already have the infrastructure to merge things correctly into the
+ * cur_stree.
+ *
+ * So instead of merging fake strees together which is probably a lot of work,
+ * we just use it as a list of set states and look up the actual current values
+ * in the cur_stree.
+ *
+ */
+static void update_stree_with_merged(struct stree **stree)
+{
+	struct state_list *slist = NULL;
+	struct sm_state *sm, *new;
+
+	FOR_EACH_SM(*stree, sm) {
+		new = get_sm_state(sm->owner, sm->name, sm->sym);
+		if (!new)  /* This can happen if we go out of scope */
+			continue;
+		add_ptr_list(&slist, new);
+	} END_FOR_EACH_SM(sm);
+
+	FOR_EACH_PTR(slist, sm) {
+		overwrite_sm_state_stree(stree, sm);
+	} END_FOR_EACH_PTR(sm);
+
+	free_slist(&slist);
+}
+
+static void update_fake_stree_with_merged(void)
+{
+	struct stree *stree;
+
+	if (!fake_cur_stree_stack)
+		return;
+	stree = pop_stree(&fake_cur_stree_stack);
+	update_stree_with_merged(&stree);
+	push_stree(&fake_cur_stree_stack, stree);
+}
+
+void __merge_true_states(void)
+{
+	struct stree *stree;
+
+	stree = pop_stree(&true_stack);
+	merge_stree(&cur_stree, stree);
+	update_fake_stree_with_merged();
+	free_stree(&stree);
+}
+
+void __push_continues(void)
+{
+	push_stree(&continue_stack, NULL);
+}
+
+void __discard_continues(void)
+{
+	struct stree *stree;
+
+	stree = pop_stree(&continue_stack);
+	free_stree(&stree);
+}
+
+void __process_continues(void)
+{
+	struct stree *stree;
+
+	stree = pop_stree(&continue_stack);
+	if (!stree)
+		stree = clone_stree(cur_stree);
+	else
+		merge_stree(&stree, cur_stree);
+
+	push_stree(&continue_stack, stree);
+}
+
+void __merge_continues(void)
+{
+	struct stree *stree;
+
+	stree = pop_stree(&continue_stack);
+	merge_stree(&cur_stree, stree);
+	free_stree(&stree);
+}
+
+void __push_breaks(void)
+{
+	push_stree(&break_stack, NULL);
+	if (fake_cur_stree_stack)
+		push_stree(&fake_break_stack, NULL);
+}
+
+void __process_breaks(void)
+{
+	struct stree *stree;
+
+	stree = pop_stree(&break_stack);
+	if (!stree)
+		stree = clone_stree(cur_stree);
+	else
+		merge_stree(&stree, cur_stree);
+	push_stree(&break_stack, stree);
+
+	if (!fake_cur_stree_stack)
+		return;
+
+	stree = pop_stree(&fake_break_stack);
+	if (!stree)
+		stree = clone_stree(top_stree(fake_cur_stree_stack));
+	else
+		merge_stree(&stree, top_stree(fake_cur_stree_stack));
+	push_stree(&fake_break_stack, stree);
+}
+
+int __has_breaks(void)
+{
+	struct stree *stree;
+	int ret;
+
+	stree = pop_stree(&break_stack);
+	ret = !!stree;
+	push_stree(&break_stack, stree);
+	return ret;
+}
+
+void __merge_breaks(void)
+{
+	struct stree *stree;
+	struct sm_state *sm;
+
+	stree = pop_stree(&break_stack);
+	merge_stree(&cur_stree, stree);
+	free_stree(&stree);
+
+	if (!fake_cur_stree_stack)
+		return;
+
+	stree = pop_stree(&fake_break_stack);
+	update_stree_with_merged(&stree);
+	FOR_EACH_SM(stree, sm) {
+		overwrite_sm_state_stree_stack(&fake_cur_stree_stack, sm);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&stree);
+}
+
+void __use_breaks(void)
+{
+	struct stree *stree;
+	struct sm_state *sm;
+
+	free_stree(&cur_stree);
+	cur_stree = pop_stree(&break_stack);
+
+	if (!fake_cur_stree_stack)
+		return;
+	stree = pop_stree(&fake_break_stack);
+	FOR_EACH_SM(stree, sm) {
+		overwrite_sm_state_stree_stack(&fake_cur_stree_stack, sm);
+	} END_FOR_EACH_SM(sm);
+	free_stree(&stree);
+
+
+}
+
+void __save_switch_states(struct expression *switch_expr)
+{
+	struct range_list *rl;
+
+	get_absolute_rl(switch_expr, &rl);
+
+	push_rl(&remaining_cases, rl);
+	push_stree(&switch_stack, clone_stree(cur_stree));
+}
+
+int have_remaining_cases(void)
+{
+	return !!top_rl(remaining_cases);
+}
+
+void __merge_switches(struct expression *switch_expr, struct range_list *case_rl)
+{
+	struct stree *stree;
+	struct stree *implied_stree;
+
+	stree = pop_stree(&switch_stack);
+	implied_stree = __implied_case_stree(switch_expr, case_rl, &remaining_cases, &stree);
+	merge_stree(&cur_stree, implied_stree);
+	free_stree(&implied_stree);
+	push_stree(&switch_stack, stree);
+}
+
+void __discard_switches(void)
+{
+	struct stree *stree;
+
+	pop_rl(&remaining_cases);
+	stree = pop_stree(&switch_stack);
+	free_stree(&stree);
+}
+
+void __push_default(void)
+{
+	push_stree(&default_stack, NULL);
+}
+
+void __set_default(void)
+{
+	set_state_stree_stack(&default_stack, 0, "has_default", NULL, &true_state);
+}
+
+int __pop_default(void)
+{
+	struct stree *stree;
+
+	stree = pop_stree(&default_stack);
+	if (stree) {
+		free_stree(&stree);
+		return 1;
+	}
+	return 0;
+}
+
+static struct named_stree *alloc_named_stree(const char *name, struct symbol *sym, struct stree *stree)
+{
+	struct named_stree *named_stree = __alloc_named_stree(0);
+
+	named_stree->name = (char *)name;
+	named_stree->stree = stree;
+	named_stree->sym = sym;
+	return named_stree;
+}
+
+void __save_gotos(const char *name, struct symbol *sym)
+{
+	struct stree **stree;
+	struct stree *clone;
+
+	stree = get_named_stree(goto_stack, name, sym);
+	if (stree) {
+		merge_stree(stree, cur_stree);
+		return;
+	} else {
+		struct named_stree *named_stree;
+
+		clone = clone_stree(cur_stree);
+		named_stree = alloc_named_stree(name, sym, clone);
+		add_ptr_list(&goto_stack, named_stree);
+	}
+}
+
+void __merge_gotos(const char *name, struct symbol *sym)
+{
+	struct stree **stree;
+
+	stree = get_named_stree(goto_stack, name, sym);
+	if (stree)
+		merge_stree(&cur_stree, *stree);
+}
diff --git a/usr/src/tools/smatch/src/smatch_stored_conditions.c b/usr/src/tools/smatch/src/smatch_stored_conditions.c
new file mode 100644
index 0000000000..07f436d416
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_stored_conditions.c
@@ -0,0 +1,320 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Keep a record of all the things we have tested for so that we know when we
+ * test for it again.  For example, if we have code like this:
+ *
+ * 	if (foo & FLAG)
+ *		lock();
+ *
+ *	...
+ *
+ *	if (foo & FLAG)
+ *		unlock();
+ *
+ * That's the end goal at least.  But actually implementing the flow of that
+ * requires quite a bit of work because if "foo" changes the condition needs to
+ * be retested and smatch_implications.c needs to be updated.
+ *
+ * For now, I just record the conditions and use it to see if we test for NULL
+ * twice.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+static int my_id;
+static int link_id;
+
+static struct smatch_state *alloc_link_state(struct expression_list *expr_list)
+{
+	struct expression *tmp;
+	struct smatch_state *state;
+	static char buf[256];
+	char *name;
+	int i;
+
+	state = __alloc_smatch_state(0);
+
+	i = 0;
+	FOR_EACH_PTR(expr_list, tmp) {
+		name = expr_to_str(tmp);
+		if (!i++) {
+			snprintf(buf, sizeof(buf), "%s", name);
+		} else {
+			append(buf, ", ", sizeof(buf));
+			append(buf, name, sizeof(buf));
+		}
+		free_string(name);
+	} END_FOR_EACH_PTR(tmp);
+
+	state->name = alloc_sname(buf);
+	state->data = expr_list;
+	return state;
+}
+
+static struct expression_list *clone_expression_list(struct expression_list *list)
+{
+	struct expression_list *ret = NULL;
+	struct expression *expr;
+
+	FOR_EACH_PTR(list, expr) {
+		add_ptr_list(&ret, expr);
+	} END_FOR_EACH_PTR(expr);
+
+	return ret;
+}
+
+static void insert_expression(struct expression_list **list, struct expression *expr)
+{
+	struct expression *tmp;
+
+	FOR_EACH_PTR(*list, tmp) {
+		if (tmp == expr)
+			return;
+	} END_FOR_EACH_PTR(tmp);
+
+	add_ptr_list(list, expr);
+}
+
+static struct smatch_state *merge_links(struct smatch_state *s1, struct smatch_state *s2)
+{
+	struct expression_list *list, *expr_list;
+	struct expression *expr;
+
+	expr_list = clone_expression_list(s1->data);
+
+	list = s2->data;
+	FOR_EACH_PTR(list, expr) {
+		insert_expression(&expr_list, expr);
+	} END_FOR_EACH_PTR(expr);
+
+	return alloc_link_state(expr_list);
+}
+
+static void save_link_var_sym(const char *var, struct symbol *sym, struct expression *condition)
+{
+	struct smatch_state *old_state, *new_state;
+	struct expression_list *expr_list;
+
+	old_state = get_state(link_id, var, sym);
+	expr_list = clone_expression_list(old_state ? old_state->data : NULL);
+
+	insert_expression(&expr_list, condition);
+
+	new_state = alloc_link_state(expr_list);
+	set_state(link_id, var, sym, new_state);
+}
+
+static void match_link_modify(struct sm_state *sm, struct expression *mod_expr)
+{
+	struct expression_list *expr_list;
+	struct expression *tmp;
+	char *name;
+
+	expr_list = sm->state->data;
+
+	FOR_EACH_PTR(expr_list, tmp) {
+		name = expr_to_str(tmp);
+		set_state(my_id, name, NULL, &undefined);
+		free_string(name);
+	} END_FOR_EACH_PTR(tmp);
+	set_state(link_id, sm->name, sm->sym, &undefined);
+}
+
+static struct smatch_state *alloc_state(struct expression *expr, int is_true)
+{
+	struct smatch_state *state;
+
+	state = __alloc_smatch_state(0);
+	if (is_true)
+		state->name = alloc_sname("true");
+	else
+		state->name = alloc_sname("false");
+	state->data = expr;
+	return state;
+}
+
+static void store_all_links(struct expression *expr, struct expression *condition)
+{
+	char *var;
+	struct symbol *sym;
+
+	expr = strip_expr(expr);
+
+	if (is_array(expr)) {
+		var = expr_to_known_chunk_sym(expr, &sym);
+		if (var)
+			save_link_var_sym(var, sym, condition);
+	}
+
+	switch (expr->type) {
+	case EXPR_COMPARE:
+	case EXPR_BINOP:
+		store_all_links(expr->left, condition);
+		store_all_links(expr->right, condition);
+		return;
+	case EXPR_VALUE:
+		return;
+	}
+
+	var = expr_to_var_sym(expr, &sym);
+	if (!var || !sym)
+		goto free;
+	save_link_var_sym(var, sym, condition);
+free:
+	free_string(var);
+}
+
+static int condition_too_complicated(struct expression *expr)
+{
+	if (get_complication_score(expr) > 2)
+		return 1;
+	return 0;
+}
+
+void __stored_condition(struct expression *expr)
+{
+	struct smatch_state *true_state, *false_state;
+	char *name;
+	sval_t val;
+
+	if (get_value(expr, &val))
+		return;
+
+	if (condition_too_complicated(expr))
+		return;
+
+	name = expr_to_str(expr);
+	if (!name)
+		return;
+	true_state = alloc_state(expr, TRUE);
+	false_state = alloc_state(expr, FALSE);
+	set_true_false_states(my_id, name, NULL, true_state, false_state);
+	store_all_links(expr, expr);
+	free_string(name);
+}
+
+struct smatch_state *get_stored_condition(struct expression *expr)
+{
+	struct smatch_state *state;
+	char *name;
+
+	name = expr_to_str(expr);
+	if (!name)
+		return NULL;
+
+	state = get_state(my_id, name, NULL);
+	free_string(name);
+	return state;
+}
+
+struct expression_list *get_conditions(struct expression *expr)
+{
+	struct smatch_state *state;
+
+	state = get_state_expr(link_id, expr);
+	if (!state)
+		return NULL;
+	return state->data;
+}
+
+void register_stored_conditions(int id)
+{
+	my_id = id;
+}
+
+void register_stored_conditions_links(int id)
+{
+	link_id = id;
+	add_merge_hook(link_id, &merge_links);
+	add_modification_hook(link_id, &match_link_modify);
+}
+
+#define RECURSE_LIMIT 50
+
+static void filter_by_sm(struct sm_state *sm,
+		       struct state_list **true_stack,
+		       struct state_list **false_stack,
+		       int *recurse_cnt)
+{
+	if (!sm)
+		return;
+
+	if ((*recurse_cnt)++ > RECURSE_LIMIT)
+		return;
+
+	if (strcmp(sm->state->name, "true") == 0) {
+		add_ptr_list(true_stack, sm);
+	} else if (strcmp(sm->state->name, "false") == 0) {
+		add_ptr_list(false_stack, sm);
+	}
+
+	if (sm->merged) {
+		filter_by_sm(sm->left, true_stack, false_stack, recurse_cnt);
+		filter_by_sm(sm->right, true_stack, false_stack, recurse_cnt);
+	}
+}
+
+struct sm_state *stored_condition_implication_hook(struct expression *expr,
+				struct state_list **true_stack,
+				struct state_list **false_stack)
+{
+	struct sm_state *sm;
+	char *name;
+	int recurse_cnt = 0;
+	struct state_list *tmp_true = NULL;
+	struct state_list *tmp_false = NULL;
+	struct sm_state *tmp;
+
+	expr = strip_expr(expr);
+
+	name = expr_to_str(expr);
+	if (!name)
+		return NULL;
+
+	sm = get_sm_state(my_id, name, NULL);
+	free_string(name);
+	if (!sm)
+		return NULL;
+	if (!sm->merged)
+		return NULL;
+
+	filter_by_sm(sm, &tmp_true, &tmp_false, &recurse_cnt);
+	if (!tmp_true && !tmp_false)
+		return NULL;
+	if (recurse_cnt > RECURSE_LIMIT) {
+		sm = NULL;
+		goto free;
+	}
+
+	FOR_EACH_PTR(tmp_true, tmp) {
+		add_ptr_list(true_stack, tmp);
+	} END_FOR_EACH_PTR(tmp);
+
+	FOR_EACH_PTR(tmp_false, tmp) {
+		add_ptr_list(false_stack, tmp);
+	} END_FOR_EACH_PTR(tmp);
+
+free:
+	free_slist(&tmp_true);
+	free_slist(&tmp_false);
+	return sm;
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_string_list.c b/usr/src/tools/smatch/src/smatch_string_list.c
new file mode 100644
index 0000000000..832ef7b938
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_string_list.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+int list_has_string(struct string_list *str_list, const char *str)
+{
+	char *tmp;
+
+	if (!str)
+		return 0;
+
+	FOR_EACH_PTR(str_list, tmp) {
+		if (strcmp(tmp, str) < 0)
+			continue;
+		if (strcmp(tmp, str) == 0)
+			return 1;
+		return 0;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+void insert_string(struct string_list **str_list, const char *_new)
+{
+	char *new = (char *)_new;
+	char *tmp;
+
+	FOR_EACH_PTR(*str_list, tmp) {
+		if (strcmp(tmp, new) < 0)
+			continue;
+		else if (strcmp(tmp, new) == 0) {
+			return;
+		} else {
+			INSERT_CURRENT(alloc_string(new), tmp);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+	new = alloc_string(new);
+	add_ptr_list(str_list, new);
+}
+
+struct string_list *clone_str_list(struct string_list *orig)
+{
+	char *tmp;
+	struct string_list *ret = NULL;
+
+	FOR_EACH_PTR(orig, tmp) {
+		add_ptr_list(&ret, tmp);
+	} END_FOR_EACH_PTR(tmp);
+	return ret;
+}
+
+struct string_list *combine_string_lists(struct string_list *one, struct string_list *two)
+{
+	struct string_list *ret;
+	char *tmp;
+
+	ret = clone_str_list(one);
+	FOR_EACH_PTR(two, tmp) {
+		insert_string(&ret, tmp);
+	} END_FOR_EACH_PTR(tmp);
+	return ret;
+}
+
+
diff --git a/usr/src/tools/smatch/src/smatch_strings.c b/usr/src/tools/smatch/src/smatch_strings.c
new file mode 100644
index 0000000000..2f6db0184f
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_strings.c
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2015 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static int get_str(void *_ret, int argc, char **argv, char **azColName)
+{
+	char **ret = _ret;
+
+	if (*ret)
+		*ret = (void *)-1UL;
+	else
+		*ret = alloc_sname(argv[0]);
+
+	return 0;
+}
+
+static char *get_string_from_mtag(mtag_t tag)
+{
+	char *str = NULL;
+
+	run_sql(get_str, &str,
+		"select value from mtag_data where tag = %lld and offset = 0 and type = %d;",
+		tag, STRING_VALUE);
+
+	if ((unsigned long)str == -1UL)
+		return NULL;
+	return str;
+}
+
+struct expression *fake_string_from_mtag(mtag_t tag)
+{
+	char *str;
+
+	if (!tag)
+		return NULL;
+	str = get_string_from_mtag(tag);
+	if (!str)
+		return NULL;
+	return string_expression(str);
+}
+
+static void match_strcpy(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *dest, *src;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	src = get_argument_from_call_expr(expr->args, 1);
+	src = strip_expr(src);
+	if (src->type == EXPR_STRING)
+		set_state_expr(my_id, dest, alloc_state_str(src->string->data));
+}
+
+struct state_list *get_strings(struct expression *expr)
+{
+	struct state_list *ret = NULL;
+	struct smatch_state *state;
+	struct sm_state *sm;
+
+	expr = strip_expr(expr);
+	if (expr->type == EXPR_STRING) {
+		state = alloc_state_str(expr->string->data);
+		sm = alloc_sm_state(my_id, expr->string->data, NULL, state);
+		add_ptr_list(&ret, sm);
+		return ret;
+	}
+
+	if (expr->type == EXPR_CONDITIONAL ||
+	    expr->type == EXPR_SELECT) {
+		struct state_list *true_strings = NULL;
+		struct state_list *false_strings = NULL;
+
+		if (known_condition_true(expr->conditional))
+			return get_strings(expr->cond_true);
+		if (known_condition_false(expr->conditional))
+			return get_strings(expr->cond_false);
+
+		true_strings = get_strings(expr->cond_true);
+		false_strings = get_strings(expr->cond_false);
+		concat_ptr_list((struct ptr_list *)true_strings, (struct ptr_list **)&false_strings);
+		free_slist(&true_strings);
+		return false_strings;
+	}
+
+	sm = get_sm_state_expr(my_id, expr);
+	if (!sm)
+		return NULL;
+
+	return clone_slist(sm->possible);
+}
+
+static void match_assignment(struct expression *expr)
+{
+	struct state_list *slist;
+	struct sm_state *sm;
+
+	if (expr->op != '=')
+		return;
+
+	slist = get_strings(strip_expr(expr->right));
+	if (!slist)
+		return;
+
+	if (ptr_list_size((struct ptr_list *)slist) == 1) {
+		sm = first_ptr_list((struct ptr_list *)slist);
+		set_state_expr(my_id, expr->left, sm->state);
+		return;
+	}
+}
+
+static void match_string(struct expression *expr)
+{
+	mtag_t tag;
+
+	if (expr->type != EXPR_STRING || !expr->string->data)
+		return;
+	if (expr->string->length > 255)
+		return;
+
+	if (!get_string_mtag(expr, &tag))
+		return;
+
+	cache_sql(NULL, NULL, "insert into mtag_data values (%lld, %d, %d, '%q');",
+		  tag, 0, STRING_VALUE, escape_newlines(expr->string->data));
+}
+
+void register_strings(int id)
+{
+	my_id = id;
+
+	add_function_hook("strcpy", &match_strcpy, NULL);
+	add_function_hook("strlcpy", &match_strcpy, NULL);
+	add_function_hook("strncpy", &match_strcpy, NULL);
+
+	add_hook(&match_assignment, ASSIGNMENT_HOOK);
+	add_hook(&match_string, STRING_HOOK);
+
+}
diff --git a/usr/src/tools/smatch/src/smatch_strlen.c b/usr/src/tools/smatch/src/smatch_strlen.c
new file mode 100644
index 0000000000..145d32ad39
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_strlen.c
@@ -0,0 +1,360 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include "parse.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+#define UNKNOWN_SIZE (-1)
+
+static int my_strlen_id;
+/*
+ * The trick with the my_equiv_id is that if we have:
+ * foo = strlen(bar);
+ * We don't know at that point what the strlen() is but we know it's equivalent
+ * to "foo" so maybe we can find the value of "foo" later.
+ */
+static int my_equiv_id;
+
+static struct smatch_state *size_to_estate(int size)
+{
+	sval_t sval;
+
+	sval.type = &int_ctype;
+	sval.value = size;
+
+	return alloc_estate_sval(sval);
+}
+
+static struct smatch_state *unmatched_strlen_state(struct sm_state *sm)
+{
+	return size_to_estate(UNKNOWN_SIZE);
+}
+
+static void set_strlen_undefined(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(sm->owner, sm->name, sm->sym, size_to_estate(UNKNOWN_SIZE));
+}
+
+static void set_strlen_equiv_undefined(struct sm_state *sm, struct expression *mod_expr)
+{
+	set_state(sm->owner, sm->name, sm->sym, &undefined);
+}
+
+static void match_string_assignment(struct expression *expr)
+{
+	struct range_list *rl;
+
+	if (expr->op != '=')
+		return;
+	if (!get_implied_strlen(expr->right, &rl))
+		return;
+	set_state_expr(my_strlen_id, expr->left, alloc_estate_rl(clone_rl(rl)));
+}
+
+static void match_strlen(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *right;
+	struct expression *str;
+	struct expression *len_expr;
+	char *len_name;
+	struct smatch_state *state;
+
+	right = strip_expr(expr->right);
+	str = get_argument_from_call_expr(right->args, 0);
+	len_expr = strip_expr(expr->left);
+
+	len_name = expr_to_var(len_expr);
+	if (!len_name)
+		return;
+
+	state = __alloc_smatch_state(0);
+        state->name = len_name;
+	state->data = len_expr;
+
+	set_state_expr(my_equiv_id, str, state);
+}
+
+static void match_strlen_condition(struct expression *expr)
+{
+	struct expression *left;
+	struct expression *right;
+	struct expression *str = NULL;
+	int strlen_left = 0;
+	int strlen_right = 0;
+	sval_t sval;
+	struct smatch_state *true_state = NULL;
+	struct smatch_state *false_state = NULL;
+	int op;
+
+	if (expr->type != EXPR_COMPARE)
+		return;
+
+	left = strip_expr(expr->left);
+	right = strip_expr(expr->right);
+
+	if (left->type == EXPR_CALL && sym_name_is("strlen", left->fn)) {
+		str = get_argument_from_call_expr(left->args, 0);
+		strlen_left = 1;
+	}
+	if (right->type == EXPR_CALL && sym_name_is("strlen", right->fn)) {
+		str = get_argument_from_call_expr(right->args, 0);
+		strlen_right = 1;
+	}
+
+	if (!strlen_left && !strlen_right)
+		return;
+	if (strlen_left && strlen_right)
+		return;
+
+	op = expr->op;
+	if (strlen_left) {
+		if (!get_value(right, &sval))
+			return;
+	} else {
+		op = flip_comparison(op);
+		if (!get_value(left, &sval))
+			return;
+	}
+
+	switch (op) {
+	case '<':
+	case SPECIAL_UNSIGNED_LT:
+		true_state = size_to_estate(sval.value - 1);
+		break;
+	case SPECIAL_LTE:
+	case SPECIAL_UNSIGNED_LTE:
+		true_state = size_to_estate(sval.value);
+		break;
+	case SPECIAL_EQUAL:
+		true_state = size_to_estate(sval.value);
+		break;
+	case SPECIAL_NOTEQUAL:
+		false_state = size_to_estate(sval.value);
+		break;
+	case SPECIAL_GTE:
+	case SPECIAL_UNSIGNED_GTE:
+		false_state = size_to_estate(sval.value - 1);
+		break;
+	case '>':
+	case SPECIAL_UNSIGNED_GT:
+		false_state = size_to_estate(sval.value);
+		break;
+	}
+
+	set_true_false_states_expr(my_strlen_id, str, true_state, false_state);
+}
+
+static void match_snprintf(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *dest;
+	struct expression *dest_size_expr;
+	sval_t limit_size;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	dest_size_expr = get_argument_from_call_expr(expr->args, 1);
+
+	if (!get_implied_value(dest_size_expr, &limit_size))
+		return;
+
+	if (limit_size.value <= 0)
+		return;
+
+	set_state_expr(my_strlen_id, dest, size_to_estate(limit_size.value - 1));
+}
+
+static void match_strlcpycat(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *dest;
+	struct expression *src;
+	struct expression *limit_expr;
+	int src_len;
+	sval_t limit;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	src = get_argument_from_call_expr(expr->args, 1);
+	limit_expr = get_argument_from_call_expr(expr->args, 2);
+
+	src_len = get_size_from_strlen(src);
+
+	if (!get_implied_max(limit_expr, &limit))
+		return;
+	if (limit.value < 0 || limit.value > INT_MAX)
+		return;
+	if (src_len != 0 && strcmp(fn, "strcpy") == 0 && src_len < limit.value)
+		limit.value = src_len;
+
+	set_state_expr(my_strlen_id, dest, size_to_estate(limit.value - 1));
+}
+
+static void match_strcpy(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *dest;
+	struct expression *src;
+	int src_len;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	src = get_argument_from_call_expr(expr->args, 1);
+
+	src_len = get_size_from_strlen(src);
+	if (src_len == 0)
+		return;
+
+	set_state_expr(my_strlen_id, dest, size_to_estate(src_len - 1));
+}
+
+static int get_strlen_from_string(struct expression *expr, struct range_list **rl)
+{
+	sval_t sval;
+	int len;
+
+	len = expr->string->length;
+	sval = sval_type_val(&int_ctype, len - 1);
+	*rl = alloc_rl(sval, sval);
+	return 1;
+}
+
+
+static int get_strlen_from_state(struct expression *expr, struct range_list **rl)
+{
+	struct smatch_state *state;
+
+	state = get_state_expr(my_strlen_id, expr);
+	if (!state)
+		return 0;
+	*rl = estate_rl(state);
+	return 1;
+}
+
+static int get_strlen_from_equiv(struct expression *expr, struct range_list **rl)
+{
+	struct smatch_state *state;
+
+	state = get_state_expr(my_equiv_id, expr);
+	if (!state || !state->data)
+		return 0;
+	if (!get_implied_rl((struct expression *)state->data, rl))
+		return 0;
+	return 1;
+}
+
+/*
+ * This returns the strlen() without the NUL char.
+ */
+int get_implied_strlen(struct expression *expr, struct range_list **rl)
+{
+
+	*rl = NULL;
+
+	expr = strip_expr(expr);
+	if (expr->type == EXPR_STRING)
+		return get_strlen_from_string(expr, rl);
+
+	if (get_strlen_from_state(expr, rl))
+		return 1;
+	if (get_strlen_from_equiv(expr, rl))
+		return 1;
+	return 0;
+}
+
+int get_size_from_strlen(struct expression *expr)
+{
+	struct range_list *rl;
+	sval_t max;
+
+	if (!get_implied_strlen(expr, &rl))
+		return 0;
+	max = rl_max(rl);
+	if (sval_is_negative(max) || sval_is_max(max))
+		return 0;
+
+	return max.value + 1; /* add one because strlen doesn't include the NULL */
+}
+
+void set_param_strlen(const char *name, struct symbol *sym, char *key, char *value)
+{
+	struct range_list *rl = NULL;
+	struct smatch_state *state;
+	char fullname[256];
+
+	if (strncmp(key, "$", 1) != 0)
+		return;
+
+	snprintf(fullname, 256, "%s%s", name, key + 1);
+
+	str_to_rl(&int_ctype, value, &rl);
+	if (!rl || is_whole_rl(rl))
+		return;
+	state = alloc_estate_rl(rl);
+	set_state(my_strlen_id, fullname, sym, state);
+}
+
+static void match_call(struct expression *expr)
+{
+	struct expression *arg;
+	struct range_list *rl;
+	int i;
+
+	i = 0;
+	FOR_EACH_PTR(expr->args, arg) {
+		if (!get_implied_strlen(arg, &rl))
+			continue;
+		if (!is_whole_rl(rl))
+			sql_insert_caller_info(expr, STR_LEN, i, "$", show_rl(rl));
+		i++;
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
+{
+	if (sm->state == &merged)
+		return;
+	sql_insert_caller_info(call, STR_LEN, param, printed_name, sm->state->name);
+}
+
+void register_strlen(int id)
+{
+	my_strlen_id = id;
+
+	add_unmatched_state_hook(my_strlen_id, &unmatched_strlen_state);
+
+	select_caller_info_hook(set_param_strlen, STR_LEN);
+	add_hook(&match_string_assignment, ASSIGNMENT_HOOK);
+
+	add_modification_hook(my_strlen_id, &set_strlen_undefined);
+	add_merge_hook(my_strlen_id, &merge_estates);
+	add_hook(&match_call, FUNCTION_CALL_HOOK);
+	add_member_info_callback(my_strlen_id, struct_member_callback);
+	add_hook(&match_strlen_condition, CONDITION_HOOK);
+
+	add_function_hook("snprintf", &match_snprintf, NULL);
+
+	add_function_hook("strlcpy", &match_strlcpycat, NULL);
+	add_function_hook("strlcat", &match_strlcpycat, NULL);
+	add_function_hook("strcpy", &match_strcpy, NULL);
+}
+
+void register_strlen_equiv(int id)
+{
+	my_equiv_id = id;
+	add_function_assign_hook("strlen", &match_strlen, NULL);
+	add_modification_hook(my_equiv_id, &set_strlen_equiv_undefined);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_struct_assignment.c b/usr/src/tools/smatch/src/smatch_struct_assignment.c
new file mode 100644
index 0000000000..414f5af770
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_struct_assignment.c
@@ -0,0 +1,558 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * This file started out by saying that if you have:
+ *
+ * 	struct foo one, two;
+ * 	...
+ * 	one = two;
+ *
+ * That's equivalent to saying:
+ *
+ * 	one.x = two.x;
+ * 	one.y = two.y;
+ *
+ * Turning an assignment like that into a bunch of small fake assignments is
+ * really useful.
+ *
+ * The call to memcpy(&one, &two, sizeof(foo)); is the same as "one = two;" so
+ * we can re-use the code.  And we may as well use it for memset() too.
+ * Assigning pointers is almost the same:
+ *
+ * 	p1 = p2;
+ *
+ * Is the same as:
+ *
+ * 	p1->x = p2->x;
+ * 	p1->y = p2->y;
+ *
+ * The problem is that you can go a bit crazy with pointers to pointers.
+ *
+ * 	p1->x->y->z->one->two->three = p2->x->y->z->one->two->three;
+ *
+ * I don't have a proper solution for this problem right now.  I just copy one
+ * level and don't nest.  It should handle limitted nesting but intelligently.
+ *
+ * The other thing is that you end up with a lot of garbage assignments where
+ * we record "x could be anything. x->y could be anything. x->y->z->a->b->c
+ * could *also* be anything!".  There should be a better way to filter this
+ * useless information.
+ *
+ */
+
+#include "scope.h"
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+enum {
+	COPY_NORMAL,
+	COPY_MEMCPY,
+	COPY_MEMSET,
+};
+
+static struct symbol *get_struct_type(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (!type)
+		return NULL;
+	if (type->type == SYM_PTR) {
+		type = get_real_base_type(type);
+		if (!type)
+			return NULL;
+	}
+	if (type->type == SYM_STRUCT)
+		return type;
+	if (type->type == SYM_UNION)
+		return type;
+	return NULL;
+}
+
+static struct expression *get_right_base_expr(struct symbol *left_type, struct expression *right)
+{
+	struct symbol *struct_type;
+
+	if (!right)
+		return NULL;
+
+	struct_type = get_struct_type(right);
+	if (!struct_type)
+		return NULL;
+	if (struct_type != left_type)
+		return NULL;
+
+	if (right->type == EXPR_PREOP && right->op == '&')
+		right = strip_expr(right->unop);
+
+	if (right->type == EXPR_CALL)
+		return NULL;
+
+	if (is_pointer(right))
+		right = deref_expression(right);
+
+	return right;
+}
+
+static struct expression *remove_addr(struct expression *expr)
+{
+	struct symbol *type;
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return NULL;
+
+	if (expr->type == EXPR_PREOP && expr->op == '&')
+		return strip_expr(expr->unop);
+	type = get_type(expr);
+	if (!type)
+		return expr;
+	if (type->type != SYM_PTR && type->type != SYM_ARRAY)
+		return expr;
+
+	return deref_expression(expr);
+}
+
+static struct expression *faked_expression;
+struct expression *get_faked_expression(void)
+{
+	if (!__in_fake_assign)
+		return NULL;
+	return faked_expression;
+}
+
+static void split_fake_expr(struct expression *expr)
+{
+	__in_fake_assign++;
+	__in_fake_struct_assign++;
+	__split_expr(expr);
+	__in_fake_struct_assign--;
+	__in_fake_assign--;
+}
+
+static void handle_non_struct_assignments(struct expression *left, struct expression *right)
+{
+	struct symbol *type;
+	struct expression *assign;
+
+	type = get_type(left);
+	if (!type)
+		return;
+	if (type->type == SYM_PTR) {
+		left = deref_expression(left);
+		if (right)
+			right = deref_expression(right);
+		else
+			right = unknown_value_expression(left);
+		assign = assign_expression(left, '=', right);
+		split_fake_expr(assign);
+		return;
+	}
+	if (type->type != SYM_BASETYPE)
+		return;
+	right = strip_expr(right);
+	if (!right)
+		right = unknown_value_expression(left);
+	assign = assign_expression(left, '=', right);
+	split_fake_expr(assign);
+}
+
+static void set_inner_struct_members(int mode, struct expression *faked, struct expression *left, struct expression *right, struct symbol *member)
+{
+	struct expression *left_member;
+	struct expression *right_member = NULL;  /* silence GCC */
+	struct expression *assign;
+	struct symbol *base = get_real_base_type(member);
+	struct symbol *tmp;
+
+	if (member->ident) {
+		left = member_expression(left, '.', member->ident);
+		if (mode != COPY_MEMSET && right)
+			right = member_expression(right, '.', member->ident);
+	}
+
+	FOR_EACH_PTR(base->symbol_list, tmp) {
+		struct symbol *type;
+
+		type = get_real_base_type(tmp);
+		if (!type)
+			continue;
+
+		if (type->type == SYM_ARRAY)
+			continue;
+		if (type->type == SYM_UNION || type->type == SYM_STRUCT) {
+			set_inner_struct_members(mode, faked, left, right, tmp);
+			continue;
+		}
+		if (!tmp->ident)
+			continue;
+
+		left_member = member_expression(left, '.', tmp->ident);
+
+		switch (mode) {
+		case COPY_NORMAL:
+		case COPY_MEMCPY:
+			if (right)
+				right_member = member_expression(right, '.', tmp->ident);
+			else
+				right_member = unknown_value_expression(left_member);
+			break;
+		case COPY_MEMSET:
+			right_member = right;
+			break;
+		}
+
+		assign = assign_expression(left_member, '=', right_member);
+		split_fake_expr(assign);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+static void __struct_members_copy(int mode, struct expression *faked,
+				  struct expression *left,
+				  struct expression *right)
+{
+	struct symbol *struct_type, *tmp, *type;
+	struct expression *left_member;
+	struct expression *right_member;
+	struct expression *assign;
+	int op = '.';
+
+
+	if (__in_fake_assign)
+		return;
+	faked_expression = faked;
+
+	left = strip_expr(left);
+	right = strip_expr(right);
+
+	struct_type = get_struct_type(left);
+	if (!struct_type) {
+		/*
+		 * This is not a struct assignment obviously.  But this is where
+		 * memcpy() is handled so it feels like a good place to add this
+		 * code.
+		 */
+		handle_non_struct_assignments(left, right);
+		goto done;
+	}
+
+	if (is_pointer(left)) {
+		left = deref_expression(left);
+		op = '*';
+	}
+	if (mode != COPY_MEMSET)
+		right = get_right_base_expr(struct_type, right);
+
+	FOR_EACH_PTR(struct_type->symbol_list, tmp) {
+		type = get_real_base_type(tmp);
+		if (!type)
+			continue;
+		if (type->type == SYM_ARRAY)
+			continue;
+
+		if (type->type == SYM_UNION || type->type == SYM_STRUCT) {
+			set_inner_struct_members(mode, faked, left, right, tmp);
+			continue;
+		}
+
+		if (!tmp->ident)
+			continue;
+
+		left_member = member_expression(left, op, tmp->ident);
+		right_member = NULL;
+
+		switch (mode) {
+		case COPY_NORMAL:
+		case COPY_MEMCPY:
+			if (right)
+				right_member = member_expression(right, op, tmp->ident);
+			else
+				right_member = unknown_value_expression(left_member);
+			break;
+		case COPY_MEMSET:
+			right_member = right;
+			break;
+		}
+		if (!right_member) {
+			sm_perror("No right member");
+			continue;
+		}
+		assign = assign_expression(left_member, '=', right_member);
+		split_fake_expr(assign);
+	} END_FOR_EACH_PTR(tmp);
+
+done:
+	faked_expression = NULL;
+}
+
+static int returns_zeroed_mem(struct expression *expr)
+{
+	char *fn;
+
+	if (expr->type != EXPR_CALL || expr->fn->type != EXPR_SYMBOL)
+		return 0;
+	fn = expr_to_var(expr->fn);
+	if (!fn)
+		return 0;
+	if (strcmp(fn, "kcalloc") == 0)
+		return 1;
+	if (option_project == PROJ_KERNEL && strstr(fn, "zalloc"))
+		return 1;
+	return 0;
+}
+
+static int copy_containter_states(struct expression *left, struct expression *right, int offset)
+{
+	char *left_name = NULL, *right_name = NULL;
+	struct symbol *left_sym, *right_sym;
+	struct sm_state *sm, *new_sm;
+	int ret = 0;
+	int len;
+	char buf[64];
+	char new_name[128];
+
+	right_name = expr_to_var_sym(right, &right_sym);
+	if (!right_name || !right_sym)
+		goto free;
+	left_name = expr_to_var_sym(left, &left_sym);
+	if (!left_name || !left_sym)
+		goto free;
+
+	len = snprintf(buf, sizeof(buf), "%s(-%d)", right_name, offset);
+	if (len >= sizeof(buf))
+		goto free;
+
+	FOR_EACH_SM(__get_cur_stree(), sm) {
+		if (sm->sym != right_sym)
+			continue;
+		if (strncmp(sm->name, buf, len) != 0)
+			continue;
+		snprintf(new_name, sizeof(new_name), "%s%s", left_name, sm->name + len);
+		new_sm = clone_sm(sm);
+		new_sm->name = alloc_sname(new_name);
+		new_sm->sym = left_sym;
+		__set_sm(new_sm);
+		ret = 1;
+	} END_FOR_EACH_SM(sm);
+free:
+	free_string(left_name);
+	free_string(right_name);
+	return ret;
+}
+
+static int handle_param_offsets(struct expression *expr)
+{
+	struct expression *right;
+	sval_t sval;
+
+	right = strip_expr(expr->right);
+
+	if (right->type != EXPR_BINOP || right->op != '-')
+		return 0;
+
+	if (!get_value(right->right, &sval))
+		return 0;
+
+	right = get_assigned_expr(right->left);
+	if (!right)
+		return 0;
+	return copy_containter_states(expr->left, right, sval.value);
+}
+
+static void returns_container_of(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *call, *arg;
+	int offset;
+
+	if (expr->type != EXPR_ASSIGNMENT || expr->op != '=')
+		return;
+	call = strip_expr(expr->right);
+	if (call->type != EXPR_CALL)
+		return;
+	if (param != -1)
+		return;
+	param = atoi(key);
+	offset = atoi(value);
+
+	arg = get_argument_from_call_expr(call->args, param);
+	if (!arg)
+		return;
+
+	copy_containter_states(expr->left, arg, -offset);
+}
+
+void __fake_struct_member_assignments(struct expression *expr)
+{
+	struct symbol *left_type;
+
+	if (expr->op != '=')
+		return;
+
+	if (is_zero(expr->right))
+		return;
+
+	left_type = get_type(expr->left);
+	if (!left_type ||
+	    (left_type->type != SYM_PTR &&
+	     left_type->type != SYM_STRUCT))
+		return;
+
+	if (handle_param_offsets(expr))
+		return;
+
+	if (returns_zeroed_mem(expr->right))
+		__struct_members_copy(COPY_MEMSET, expr, expr->left, zero_expr());
+	else
+		__struct_members_copy(COPY_NORMAL, expr, expr->left, expr->right);
+}
+
+static void match_memset(const char *fn, struct expression *expr, void *_size_arg)
+{
+	struct expression *buf;
+	struct expression *val;
+
+	buf = get_argument_from_call_expr(expr->args, 0);
+	val = get_argument_from_call_expr(expr->args, 1);
+
+	buf = strip_expr(buf);
+	__struct_members_copy(COPY_MEMSET, expr, remove_addr(buf), val);
+}
+
+static void match_memcpy(const char *fn, struct expression *expr, void *_arg)
+{
+	struct expression *dest;
+	struct expression *src;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	src = get_argument_from_call_expr(expr->args, 1);
+
+	__struct_members_copy(COPY_MEMCPY, expr, remove_addr(dest), remove_addr(src));
+}
+
+static void match_memcpy_unknown(const char *fn, struct expression *expr, void *_arg)
+{
+	struct expression *dest;
+
+	dest = get_argument_from_call_expr(expr->args, 0);
+	__struct_members_copy(COPY_MEMCPY, expr, remove_addr(dest), NULL);
+}
+
+static void match_sscanf(const char *fn, struct expression *expr, void *unused)
+{
+	struct expression *arg;
+	int i;
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		if (++i < 2)
+			continue;
+		__struct_members_copy(COPY_MEMCPY, expr, remove_addr(arg), NULL);
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void unop_expr(struct expression *expr)
+{
+	if (expr->op != SPECIAL_INCREMENT &&
+	    expr->op != SPECIAL_DECREMENT)
+		return;
+
+	if (!is_pointer(expr))
+		return;
+	faked_expression = expr;
+	__struct_members_copy(COPY_MEMCPY, expr, expr->unop, NULL);
+	faked_expression = NULL;
+}
+
+static void register_clears_param(void)
+{
+	struct token *token;
+	char name[256];
+	const char *function;
+	int param;
+
+	if (option_project == PROJ_NONE)
+		return;
+
+	snprintf(name, 256, "%s.clears_argument", option_project_str);
+
+	token = get_tokens_file(name);
+	if (!token)
+		return;
+	if (token_type(token) != TOKEN_STREAMBEGIN)
+		return;
+	token = token->next;
+	while (token_type(token) != TOKEN_STREAMEND) {
+		if (token_type(token) != TOKEN_IDENT)
+			return;
+		function = show_ident(token->ident);
+		token = token->next;
+		if (token_type(token) != TOKEN_NUMBER)
+			return;
+		param = atoi(token->number);
+		add_function_hook(function, &match_memcpy_unknown, INT_PTR(param));
+		token = token->next;
+	}
+	clear_token_alloc();
+}
+
+static void db_param_cleared(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	/*
+	 * FIXME:  __struct_members_copy() requires an expression but
+	 * get_variable_from_key() returns a name/sym pair so that doesn't
+	 * work here.
+	 */
+	if (strcmp(key, "$") != 0)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	if (!arg)
+		return;
+
+	if (strcmp(value, "0") == 0)
+		__struct_members_copy(COPY_MEMSET, expr, remove_addr(arg), zero_expr());
+	else
+		__struct_members_copy(COPY_MEMCPY, expr, remove_addr(arg), NULL);
+}
+
+void register_struct_assignment(int id)
+{
+	add_function_hook("memset", &match_memset, NULL);
+	add_function_hook("__memset", &match_memset, NULL);
+
+	add_function_hook("memcpy", &match_memcpy, INT_PTR(0));
+	add_function_hook("memmove", &match_memcpy, INT_PTR(0));
+	add_function_hook("__memcpy", &match_memcpy, INT_PTR(0));
+	add_function_hook("__memmove", &match_memcpy, INT_PTR(0));
+
+	add_function_hook("sscanf", &match_sscanf, NULL);
+
+	add_hook(&unop_expr, OP_HOOK);
+	register_clears_param();
+	select_return_states_hook(PARAM_CLEARED, &db_param_cleared);
+
+	select_return_states_hook(CONTAINER, &returns_container_of);
+}
diff --git a/usr/src/tools/smatch/src/smatch_sval.c b/usr/src/tools/smatch/src/smatch_sval.c
new file mode 100644
index 0000000000..a3a5cc7a02
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_sval.c
@@ -0,0 +1,674 @@
+/*
+ * Copyright (C) 2012 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Basically the point of sval is that it can hold both ULLONG_MAX and
+ * LLONG_MIN.  If it is an unsigned type then we use sval.uvalue or if it is
+ * signed we use sval.value.
+ *
+ * I considered just using one bit to store whether the value was signed vs
+ * unsigned but I think it might help to have the type information so we know
+ * how to do type promotion.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+__ALLOCATOR(sval_t, "svals", sval);
+
+sval_t *sval_alloc(sval_t sval)
+{
+	sval_t *ret;
+
+	ret = __alloc_sval(0);
+	*ret = sval;
+	return ret;
+}
+
+sval_t *sval_alloc_permanent(sval_t sval)
+{
+	sval_t *ret;
+
+	ret = malloc(sizeof(*ret));
+	*ret = sval;
+	return ret;
+}
+
+sval_t sval_blank(struct expression *expr)
+{
+	sval_t ret;
+
+	ret.type = get_type(expr);
+	if (!ret.type)
+		ret.type = &int_ctype;
+	ret.value = 123456789;
+
+	return ret;
+}
+
+sval_t sval_type_val(struct symbol *type, long long val)
+{
+	sval_t ret;
+
+	if (!type)
+		type = &int_ctype;
+
+	ret.type = type;
+	ret.value = val;
+	return ret;
+}
+
+sval_t sval_from_val(struct expression *expr, long long val)
+{
+	sval_t ret;
+
+	ret = sval_blank(expr);
+	ret.value = val;
+	ret = sval_cast(get_type(expr), ret);
+
+	return ret;
+}
+
+int sval_is_ptr(sval_t sval)
+{
+	if (!sval.type)
+		return 0;
+	return (sval.type->type == SYM_PTR || sval.type->type == SYM_ARRAY);
+}
+
+int sval_unsigned(sval_t sval)
+{
+	return type_unsigned(sval.type);
+}
+
+int sval_signed(sval_t sval)
+{
+	return !type_unsigned(sval.type);
+}
+
+int sval_bits(sval_t sval)
+{
+	return type_bits(sval.type);
+}
+
+int sval_bits_used(sval_t sval)
+{
+	int i;
+
+	for (i = 64; i >= 1; i--) {
+		if (sval.uvalue & (1ULL << (i - 1)))
+			return i;
+	}
+	return 0;
+}
+
+int sval_is_negative(sval_t sval)
+{
+	if (type_unsigned(sval.type))
+		return 0;
+	if (sval.value < 0)
+		return 1;
+	return 0;
+}
+
+int sval_is_positive(sval_t sval)
+{
+	return !sval_is_negative(sval);
+}
+
+int sval_is_min(sval_t sval)
+{
+	sval_t min = sval_type_min(sval.type);
+
+	if (sval_unsigned(sval)) {
+		if (sval.uvalue == 0)
+			return 1;
+		return 0;
+	}
+	/* return true for less than min as well */
+	return (sval.value <= min.value);
+}
+
+int sval_is_max(sval_t sval)
+{
+	sval_t max = sval_type_max(sval.type);
+
+	if (sval_unsigned(sval))
+		return (sval.uvalue >= max.value);
+	return (sval.value >= max.value);
+}
+
+int sval_is_a_min(sval_t sval)
+{
+	if (sval_is_min(sval))
+		return 1;
+	if (sval_signed(sval) && sval.value == SHRT_MIN)
+		return 1;
+	if (sval_signed(sval) && sval.value == INT_MIN)
+		return 1;
+	if (sval_signed(sval) && sval.value == LLONG_MIN)
+		return 1;
+	return 0;
+}
+
+int sval_is_a_max(sval_t sval)
+{
+	if (sval_is_max(sval))
+		return 1;
+	if (sval.uvalue == SHRT_MAX)
+		return 1;
+	if (sval.uvalue == INT_MAX)
+		return 1;
+	if (sval.uvalue == LLONG_MAX)
+		return 1;
+	if (sval.uvalue == USHRT_MAX)
+		return 1;
+	if (sval.uvalue == UINT_MAX)
+		return 1;
+	if (sval_unsigned(sval) && sval.uvalue == ULLONG_MAX)
+		return 1;
+	if (sval.value > valid_ptr_max - 1000 &&
+	    sval.value < valid_ptr_max + 1000)
+		return 1;
+	return 0;
+}
+
+int sval_is_negative_min(sval_t sval)
+{
+	if (!sval_is_negative(sval))
+		return 0;
+	return sval_is_min(sval);
+}
+
+int sval_cmp_t(struct symbol *type, sval_t one, sval_t two)
+{
+	sval_t one_cast, two_cast;
+
+	one_cast = sval_cast(type, one);
+	two_cast = sval_cast(type, two);
+	return sval_cmp(one_cast, two_cast);
+}
+
+int sval_cmp_val(sval_t one, long long val)
+{
+	sval_t sval;
+
+	sval = sval_type_val(&llong_ctype, val);
+	return sval_cmp(one, sval);
+}
+
+sval_t sval_min(sval_t one, sval_t two)
+{
+	if (sval_cmp(one, two) > 0)
+		return two;
+	return one;
+}
+
+sval_t sval_max(sval_t one, sval_t two)
+{
+	if (sval_cmp(one, two) < 0)
+		return two;
+	return one;
+}
+
+int sval_too_low(struct symbol *type, sval_t sval)
+{
+	if (sval_is_negative(sval) && type_unsigned(type))
+		return 1;
+	if (type_signed(type) &&  sval_unsigned(sval))
+		return 0;
+	if (type_signed(sval.type) &&
+	    sval.value < sval_type_min(type).value)
+		return 1;
+	if (sval_cmp(sval, sval_type_min(type)) < 0)
+		return 1;
+	return 0;
+}
+
+int sval_too_high(struct symbol *type, sval_t sval)
+{
+	if (sval_is_negative(sval))
+		return 0;
+	if (sval.uvalue > sval_type_max(type).uvalue)
+		return 1;
+	return 0;
+}
+
+int sval_fits(struct symbol *type, sval_t sval)
+{
+	if (sval_too_low(type, sval))
+		return 0;
+	if (sval_too_high(type, sval))
+		return 0;
+	return 1;
+}
+
+sval_t sval_cast(struct symbol *type, sval_t sval)
+{
+	sval_t ret;
+
+	if (!type)
+		type = &int_ctype;
+
+	ret.type = type;
+	switch (sval_bits(ret)) {
+	case 1:
+		ret.value = !!sval.value;
+		break;
+	case 8:
+		if (sval_unsigned(ret))
+			ret.value = (long long)(unsigned char)sval.value;
+		else
+			ret.value = (long long)(char)sval.value;
+		break;
+	case 16:
+		if (sval_unsigned(ret))
+			ret.value = (long long)(unsigned short)sval.value;
+		else
+			ret.value = (long long)(short)sval.value;
+		break;
+	case 32:
+		if (sval_unsigned(ret))
+			ret.value = (long long)(unsigned int)sval.value;
+		else
+			ret.value = (long long)(int)sval.value;
+		break;
+	default:
+		ret.value = sval.value;
+	}
+	return ret;
+
+}
+
+sval_t sval_preop(sval_t sval, int op)
+{
+	switch (op) {
+	case '!':
+		sval.value = !sval.value;
+		break;
+	case '~':
+		sval.value = ~sval.value;
+		sval = sval_cast(sval.type, sval);
+		break;
+	case '-':
+		sval.value = -sval.value;
+		sval = sval_cast(sval.type, sval);
+		break;
+	}
+	return sval;
+}
+
+static sval_t sval_binop_unsigned(struct symbol *type, sval_t left, int op, sval_t right)
+{
+	sval_t ret;
+
+	ret.type = type;
+	switch (op) {
+	case '*':
+		ret.uvalue =  left.uvalue * right.uvalue;
+		break;
+	case '/':
+		if (right.uvalue == 0) {
+			sm_debug("%s: divide by zero", __func__);
+			ret.uvalue = 123456789;
+		} else {
+			ret.uvalue = left.uvalue / right.uvalue;
+		}
+		break;
+	case '+':
+		ret.uvalue = left.uvalue + right.uvalue;
+		break;
+	case '-':
+		ret.uvalue = left.uvalue - right.uvalue;
+		break;
+	case '%':
+		if (right.uvalue == 0) {
+			sm_perror(" %s: MOD by zero", __func__);
+			ret.uvalue = 123456789;
+		} else {
+			ret.uvalue = left.uvalue % right.uvalue;
+		}
+		break;
+	case '|':
+		ret.uvalue = left.uvalue | right.uvalue;
+		break;
+	case '&':
+		ret.uvalue = left.uvalue & right.uvalue;
+		break;
+	case SPECIAL_RIGHTSHIFT:
+		ret.uvalue = left.uvalue >> right.uvalue;
+		break;
+	case SPECIAL_LEFTSHIFT:
+		ret.uvalue = left.uvalue << right.uvalue;
+		break;
+	case '^':
+		ret.uvalue = left.uvalue ^ right.uvalue;
+		break;
+	default:
+		sm_perror(" %s: unhandled binop %s", __func__,
+		       show_special(op));
+		ret.uvalue = 1234567;
+	}
+	return ret;
+}
+
+
+static sval_t sval_binop_signed(struct symbol *type, sval_t left, int op, sval_t right)
+{
+	sval_t ret;
+
+	ret.type = type;
+	switch (op) {
+	case '*':
+		ret.value =  left.value * right.value;
+		break;
+	case '/':
+		if (right.value == 0) {
+			sm_debug("%s: divide by zero", __func__);
+			ret.value = 123456789;
+		} else if (left.value == LLONG_MIN && right.value == -1) {
+			sm_debug("%s: invalid divide LLONG_MIN/-1", __func__);
+			ret.value = 12345678;
+		} else {
+			ret.value = left.value / right.value;
+		}
+		break;
+	case '+':
+		ret.value = left.value + right.value;
+		break;
+	case '-':
+		ret.value = left.value - right.value;
+		break;
+	case '%':
+		if (right.value == 0) {
+			sm_perror(" %s: MOD by zero", __func__);
+			ret.value = 123456789;
+		} else {
+			ret.value = left.value % right.value;
+		}
+		break;
+	case '|':
+		ret.value = left.value | right.value;
+		break;
+	case '&':
+		ret.value = left.value & right.value;
+		break;
+	case SPECIAL_RIGHTSHIFT:
+		ret.value = left.value >> right.value;
+		break;
+	case SPECIAL_LEFTSHIFT:
+		ret.value = left.value << right.value;
+		break;
+	case '^':
+		ret.value = left.value ^ right.value;
+		break;
+	default:
+		sm_perror(" %s: unhandled binop %s", __func__,
+		       show_special(op));
+		ret.value = 1234567;
+	}
+	return ret;
+}
+
+static sval_t ptr_binop(struct symbol *type, sval_t left, int op, sval_t right)
+{
+	sval_t ret;
+	int align;
+
+	if (op != '+' && op != '-')
+		return sval_binop_unsigned(type, left, op, right);
+
+	ret.type = type;
+	if (type->type == SYM_PTR)
+		type = get_real_base_type(type);
+	align = type->ctype.alignment;
+	if (align <= 0)
+		align = 1;
+
+	if (op == '+') {
+		if (type_is_ptr(left.type))
+			ret.value = left.value + right.value * align;
+		else
+			ret.value = left.value * align + right.value;
+	} else {
+		if (!type_is_ptr(left.type)) {
+			left.value = -left.value;
+			ret = ptr_binop(type, left, '+', right);
+		} else if (!type_is_ptr(right.type)) {
+			right.value = -right.value;
+			ret = ptr_binop(type, left, '+', right);
+		} else {
+			ret.value = (left.value - right.value) / align;
+		}
+	}
+
+	return ret;
+}
+
+sval_t sval_binop(sval_t left, int op, sval_t right)
+{
+	struct symbol *type;
+	sval_t ret;
+
+	type = get_promoted_type(left.type, right.type);
+
+	if (type_is_ptr(type))
+		ret = ptr_binop(type, left, op, right);
+	else if (type_unsigned(type))
+		ret = sval_binop_unsigned(type, left, op, right);
+	else
+		ret = sval_binop_signed(type, left, op, right);
+	return sval_cast(type, ret);
+}
+
+int sval_unop_overflows(sval_t sval, int op)
+{
+	if (op != '-')
+		return 0;
+	if (sval_positive_bits(sval) == 32 && sval.value == INT_MIN)
+		return 1;
+	if (sval_positive_bits(sval) == 64 && sval.value == LLONG_MIN)
+		return 1;
+	if (sval_is_negative(sval))
+		return 0;
+	if (sval_signed(sval))
+		return 0;
+	if (sval_bits(sval) == 32 && sval.uvalue > INT_MAX)
+		return 1;
+	if (sval_bits(sval) == 64 && sval.uvalue > LLONG_MAX)
+		return 1;
+	return 0;
+}
+
+int sval_binop_overflows(sval_t left, int op, sval_t right)
+{
+	struct symbol *type;
+	sval_t max, min;
+
+	type = left.type;
+	if (type_positive_bits(right.type) > type_positive_bits(left.type))
+		type = right.type;
+	if (type_positive_bits(type) < 31)
+		type = &int_ctype;
+
+	max = sval_type_max(type);
+	min = sval_type_min(type);
+
+	switch (op) {
+	case '+':
+		if (sval_is_negative(left) && sval_is_negative(right)) {
+			if (left.value < min.value + right.value)
+				return 1;
+			return 0;
+		}
+		if (sval_is_negative(left) || sval_is_negative(right))
+			return 0;
+		if (left.uvalue > max.uvalue - right.uvalue)
+				return 1;
+		return 0;
+	case '*':
+		if (type_signed(type)) {
+			if (left.value == 0 || right.value == 0)
+				return 0;
+			if (left.value > max.value / right.value)
+				return 1;
+			if (left.value == -1 || right.value == -1)
+				return 0;
+			return left.value != left.value * right.value / right.value;
+
+		}
+		return right.uvalue != 0 && left.uvalue > max.uvalue / right.uvalue;
+	case '-':
+		if (type_unsigned(type)) {
+			if (sval_cmp(left, right) < 0)
+				return 1;
+			return 0;
+		}
+		if (sval_is_negative(left) && sval_is_negative(right))
+			return 0;
+
+		if (sval_is_negative(left)) {
+			if (left.value < min.value + right.value)
+				return 1;
+			return 0;
+		}
+		if (sval_is_negative(right)) {
+			if (right.value == min.value)
+				return 1;
+			right = sval_preop(right, '-');
+			if (sval_binop_overflows(left, '+', right))
+				return 1;
+			return 0;
+		}
+		return 0;
+	case SPECIAL_LEFTSHIFT:
+		if (sval_cmp(left, sval_binop(max, invert_op(op), right)) > 0)
+			return 1;
+		return 0;
+	}
+	return 0;
+}
+
+int sval_binop_overflows_no_sign(sval_t left, int op, sval_t right)
+{
+
+	struct symbol *type;
+
+	type = left.type;
+	if (type_positive_bits(right.type) > type_positive_bits(left.type))
+		type = right.type;
+	if (type_positive_bits(type) <= 31)
+		type = &uint_ctype;
+	else
+		type = &ullong_ctype;
+
+	left = sval_cast(type, left);
+	right = sval_cast(type, right);
+	return sval_binop_overflows(left, op, right);
+}
+
+unsigned long long fls_mask(unsigned long long uvalue)
+{
+	unsigned long long high_bit = 0;
+
+	while (uvalue) {
+		uvalue >>= 1;
+		high_bit++;
+	}
+
+	if (high_bit == 0)
+		return 0;
+
+	return ((unsigned long long)-1) >> (64 - high_bit);
+}
+
+unsigned long long sval_fls_mask(sval_t sval)
+{
+	return fls_mask(sval.uvalue);
+}
+
+const char *sval_to_str(sval_t sval)
+{
+	char buf[30];
+
+	if (sval_unsigned(sval) && sval.value == ULLONG_MAX)
+		return "u64max";
+	if (sval_unsigned(sval) && sval.value == UINT_MAX)
+		return "u32max";
+	if (sval.value == USHRT_MAX)
+		return "u16max";
+
+	if (sval_signed(sval) && sval.value == LLONG_MAX)
+		return "s64max";
+	if (sval.value == INT_MAX)
+		return "s32max";
+	if (sval.value == SHRT_MAX)
+		return "s16max";
+
+	if (sval_signed(sval) && sval.value == SHRT_MIN)
+		return "s16min";
+	if (sval_signed(sval) && sval.value == INT_MIN)
+		return "s32min";
+	if (sval_signed(sval) && sval.value == LLONG_MIN)
+		return "s64min";
+
+	if (sval_unsigned(sval))
+		snprintf(buf, sizeof(buf), "%llu", sval.value);
+	else if (sval.value < 0)
+		snprintf(buf, sizeof(buf), "(%lld)", sval.value);
+	else
+		snprintf(buf, sizeof(buf), "%lld", sval.value);
+
+	return alloc_sname(buf);
+}
+
+const char *sval_to_numstr(sval_t sval)
+{
+	char buf[30];
+
+	if (sval_unsigned(sval))
+		snprintf(buf, sizeof(buf), "%llu", sval.value);
+	else if (sval.value < 0)
+		snprintf(buf, sizeof(buf), "(%lld)", sval.value);
+	else
+		snprintf(buf, sizeof(buf), "%lld", sval.value);
+
+	return alloc_sname(buf);
+}
+
+sval_t ll_to_sval(long long val)
+{
+	sval_t ret;
+
+	ret.type = &llong_ctype;
+	ret.value = val;
+	return ret;
+}
+
+static void free_svals(struct symbol *sym)
+{
+	if (__inline_fn)
+		return;
+	clear_sval_alloc();
+}
+
+void register_sval(int my_id)
+{
+	add_hook(&free_svals, AFTER_FUNC_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_tracker.c b/usr/src/tools/smatch/src/smatch_tracker.c
new file mode 100644
index 0000000000..9f3fef2ddf
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_tracker.c
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+ALLOCATOR(tracker, "trackers");
+
+struct tracker *alloc_tracker(int owner, const char *name, struct symbol *sym)
+{
+	struct tracker *tmp;
+
+	tmp = __alloc_tracker(0);
+	tmp->name = alloc_string(name);
+	tmp->owner = owner;
+	tmp->sym = sym;
+	return tmp;
+}
+
+void add_tracker(struct tracker_list **list, int owner, const char *name,
+		struct symbol *sym)
+{
+	struct tracker *tmp;
+
+	if (in_tracker_list(*list, owner, name, sym))
+		return;
+	tmp = alloc_tracker(owner, name, sym);
+	add_ptr_list(list, tmp);
+}
+
+void add_tracker_expr(struct tracker_list **list, int owner, struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+
+	name = expr_to_var_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+	add_tracker(list, owner, name, sym);
+free:
+	free_string(name);
+}
+
+static void free_tracker(struct tracker *t)
+{
+	free_string(t->name);
+	__free_tracker(t);
+}
+
+void del_tracker(struct tracker_list **list, int owner, const char *name,
+		struct symbol *sym)
+{
+	struct tracker *tmp;
+
+	FOR_EACH_PTR(*list, tmp) {
+		if (tmp->owner == owner && tmp->sym == sym
+		    && !strcmp(tmp->name, name)) {
+			DELETE_CURRENT_PTR(tmp);
+			free_tracker(tmp);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+int in_tracker_list(struct tracker_list *list, int owner, const char *name,
+		struct symbol *sym)
+{
+	struct tracker *tmp;
+
+	FOR_EACH_PTR(list, tmp) {
+		if (tmp->owner == owner && tmp->sym == sym
+		    && !strcmp(tmp->name, name))
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+void free_tracker_list(struct tracker_list **list)
+{
+	__free_ptr_list((struct ptr_list **)list);
+}
+
+void free_trackers_and_list(struct tracker_list **list)
+{
+	struct tracker *tmp;
+
+	FOR_EACH_PTR(*list, tmp) {
+		free_tracker(tmp);
+	} END_FOR_EACH_PTR(tmp);
+	free_tracker_list(list);
+}
+
diff --git a/usr/src/tools/smatch/src/smatch_type.c b/usr/src/tools/smatch/src/smatch_type.c
new file mode 100644
index 0000000000..23763b9f13
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_type.c
@@ -0,0 +1,810 @@
+/*
+ * Copyright (C) 2009 Dan Carpenter.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The idea here is that you have an expression and you
+ * want to know what the type is for that.
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+
+struct symbol *get_real_base_type(struct symbol *sym)
+{
+	struct symbol *ret;
+
+	if (!sym)
+		return NULL;
+	ret = get_base_type(sym);
+	if (!ret)
+		return NULL;
+	if (ret->type == SYM_RESTRICT || ret->type == SYM_NODE)
+		return get_real_base_type(ret);
+	return ret;
+}
+
+int type_bytes(struct symbol *type)
+{
+	int bits;
+
+	if (type && type->type == SYM_ARRAY)
+		return array_bytes(type);
+
+	bits = type_bits(type);
+	if (bits < 0)
+		return 0;
+	return bits_to_bytes(bits);
+}
+
+int array_bytes(struct symbol *type)
+{
+	if (!type || type->type != SYM_ARRAY)
+		return 0;
+	return bits_to_bytes(type->bit_size);
+}
+
+static struct symbol *get_binop_type(struct expression *expr)
+{
+	struct symbol *left, *right;
+
+	left = get_type(expr->left);
+	if (!left)
+		return NULL;
+
+	if (expr->op == SPECIAL_LEFTSHIFT ||
+	    expr->op == SPECIAL_RIGHTSHIFT) {
+		if (type_positive_bits(left) < 31)
+			return &int_ctype;
+		return left;
+	}
+	right = get_type(expr->right);
+	if (!right)
+		return NULL;
+
+	if (left->type == SYM_PTR || left->type == SYM_ARRAY)
+		return left;
+	if (right->type == SYM_PTR || right->type == SYM_ARRAY)
+		return right;
+
+	if (type_positive_bits(left) < 31 && type_positive_bits(right) < 31)
+		return &int_ctype;
+
+	if (type_positive_bits(left) > type_positive_bits(right))
+		return left;
+	return right;
+}
+
+static struct symbol *get_type_symbol(struct expression *expr)
+{
+	if (!expr || expr->type != EXPR_SYMBOL || !expr->symbol)
+		return NULL;
+
+	return get_real_base_type(expr->symbol);
+}
+
+static struct symbol *get_member_symbol(struct symbol_list *symbol_list, struct ident *member)
+{
+	struct symbol *tmp, *sub;
+
+	FOR_EACH_PTR(symbol_list, tmp) {
+		if (!tmp->ident) {
+			sub = get_real_base_type(tmp);
+			sub = get_member_symbol(sub->symbol_list, member);
+			if (sub)
+				return sub;
+			continue;
+		}
+		if (tmp->ident == member)
+			return tmp;
+	} END_FOR_EACH_PTR(tmp);
+
+	return NULL;
+}
+
+static struct symbol *get_symbol_from_deref(struct expression *expr)
+{
+	struct ident *member;
+	struct symbol *sym;
+
+	if (!expr || expr->type != EXPR_DEREF)
+		return NULL;
+
+	member = expr->member;
+	sym = get_type(expr->deref);
+	if (!sym) {
+		// sm_msg("could not find struct type");
+		return NULL;
+	}
+	if (sym->type == SYM_PTR)
+		sym = get_real_base_type(sym);
+	sym = get_member_symbol(sym->symbol_list, member);
+	if (!sym)
+		return NULL;
+	return get_real_base_type(sym);
+}
+
+static struct symbol *get_return_type(struct expression *expr)
+{
+	struct symbol *tmp;
+
+	tmp = get_type(expr->fn);
+	if (!tmp)
+		return NULL;
+	/* this is to handle __builtin_constant_p() */
+	if (tmp->type != SYM_FN)
+		tmp = get_base_type(tmp);
+	return get_real_base_type(tmp);
+}
+
+static struct symbol *get_expr_stmt_type(struct statement *stmt)
+{
+	if (stmt->type != STMT_COMPOUND)
+		return NULL;
+	stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
+	if (stmt->type == STMT_LABEL)
+		stmt = stmt->label_statement;
+	if (stmt->type != STMT_EXPRESSION)
+		return NULL;
+	return get_type(stmt->expression);
+}
+
+static struct symbol *get_select_type(struct expression *expr)
+{
+	struct symbol *one, *two;
+
+	one = get_type(expr->cond_true);
+	two = get_type(expr->cond_false);
+	if (!one || !two)
+		return NULL;
+	/*
+	 * This is a hack.  If the types are not equiv then we
+	 * really don't know the type.  But I think guessing is
+	 *  probably Ok here.
+	 */
+	if (type_positive_bits(one) > type_positive_bits(two))
+		return one;
+	return two;
+}
+
+struct symbol *get_pointer_type(struct expression *expr)
+{
+	struct symbol *sym;
+
+	sym = get_type(expr);
+	if (!sym)
+		return NULL;
+	if (sym->type == SYM_NODE) {
+		sym = get_real_base_type(sym);
+		if (!sym)
+			return NULL;
+	}
+	if (sym->type != SYM_PTR && sym->type != SYM_ARRAY)
+		return NULL;
+	return get_real_base_type(sym);
+}
+
+static struct symbol *fake_pointer_sym(struct expression *expr)
+{
+	struct symbol *sym;
+	struct symbol *base;
+
+	sym = alloc_symbol(expr->pos, SYM_PTR);
+	expr = expr->unop;
+	base = get_type(expr);
+	if (!base)
+		return NULL;
+	sym->ctype.base_type = base;
+	return sym;
+}
+
+static struct symbol *get_type_helper(struct expression *expr)
+{
+	struct symbol *ret;
+
+	expr = strip_parens(expr);
+	if (!expr)
+		return NULL;
+
+	if (expr->ctype)
+		return expr->ctype;
+
+	switch (expr->type) {
+	case EXPR_STRING:
+		ret = &string_ctype;
+		break;
+	case EXPR_SYMBOL:
+		ret = get_type_symbol(expr);
+		break;
+	case EXPR_DEREF:
+		ret = get_symbol_from_deref(expr);
+		break;
+	case EXPR_PREOP:
+	case EXPR_POSTOP:
+		if (expr->op == '&')
+			ret = fake_pointer_sym(expr);
+		else if (expr->op == '*')
+			ret = get_pointer_type(expr->unop);
+		else
+			ret = get_type(expr->unop);
+		break;
+	case EXPR_ASSIGNMENT:
+		ret = get_type(expr->left);
+		break;
+	case EXPR_CAST:
+	case EXPR_FORCE_CAST:
+	case EXPR_IMPLIED_CAST:
+		ret = get_real_base_type(expr->cast_type);
+		break;
+	case EXPR_COMPARE:
+	case EXPR_BINOP:
+		ret = get_binop_type(expr);
+		break;
+	case EXPR_CALL:
+		ret = get_return_type(expr);
+		break;
+	case EXPR_STATEMENT:
+		ret = get_expr_stmt_type(expr->statement);
+		break;
+	case EXPR_CONDITIONAL:
+	case EXPR_SELECT:
+		ret = get_select_type(expr);
+		break;
+	case EXPR_SIZEOF:
+		ret = &ulong_ctype;
+		break;
+	case EXPR_LOGICAL:
+		ret = &int_ctype;
+		break;
+	default:
+		return NULL;
+	}
+
+	if (ret && ret->type == SYM_TYPEOF)
+		ret = get_type(ret->initializer);
+
+	expr->ctype = ret;
+	return ret;
+}
+
+static struct symbol *get_final_type_helper(struct expression *expr)
+{
+	/*
+	 * I'm not totally positive I understand types...
+	 *
+	 * So, when you're doing pointer math, and you do a subtraction, then
+	 * the sval_binop() and whatever need to know the type of the pointer
+	 * so they can figure out the alignment.  But the result is going to be
+	 * and ssize_t.  So get_operation_type() gives you the pointer type
+	 * and get_type() gives you ssize_t.
+	 *
+	 * Most of the time the operation type and the final type are the same
+	 * but this just handles the few places where they are different.
+	 *
+	 */
+
+	expr = strip_parens(expr);
+	if (!expr)
+		return NULL;
+
+	switch (expr->type) {
+	case EXPR_COMPARE:
+		return &int_ctype;
+	case EXPR_BINOP: {
+		struct symbol *left, *right;
+
+		if (expr->op != '-')
+			return NULL;
+
+		left = get_type(expr->left);
+		right = get_type(expr->right);
+		if (type_is_ptr(left) || type_is_ptr(right))
+			return ssize_t_ctype;
+		}
+	}
+
+	return NULL;
+}
+
+struct symbol *get_type(struct expression *expr)
+{
+	return get_type_helper(expr);
+}
+
+struct symbol *get_final_type(struct expression *expr)
+{
+	struct symbol *ret;
+
+	ret = get_final_type_helper(expr);
+	if (ret)
+		return ret;
+	return get_type_helper(expr);
+}
+
+struct symbol *get_promoted_type(struct symbol *left, struct symbol *right)
+{
+	struct symbol *ret = &int_ctype;
+
+	if (type_positive_bits(left) > type_positive_bits(ret))
+		ret = left;
+	if (type_positive_bits(right) > type_positive_bits(ret))
+		ret = right;
+
+	if (type_is_ptr(left))
+		ret = left;
+	if (type_is_ptr(right))
+		ret = right;
+
+	return ret;
+}
+
+int type_signed(struct symbol *base_type)
+{
+	if (!base_type)
+		return 0;
+	if (base_type->ctype.modifiers & MOD_SIGNED)
+		return 1;
+	return 0;
+}
+
+int expr_unsigned(struct expression *expr)
+{
+	struct symbol *sym;
+
+	sym = get_type(expr);
+	if (!sym)
+		return 0;
+	if (type_unsigned(sym))
+		return 1;
+	return 0;
+}
+
+int expr_signed(struct expression *expr)
+{
+	struct symbol *sym;
+
+	sym = get_type(expr);
+	if (!sym)
+		return 0;
+	if (type_signed(sym))
+		return 1;
+	return 0;
+}
+
+int returns_unsigned(struct symbol *sym)
+{
+	if (!sym)
+		return 0;
+	sym = get_base_type(sym);
+	if (!sym || sym->type != SYM_FN)
+		return 0;
+	sym = get_base_type(sym);
+	return type_unsigned(sym);
+}
+
+int is_pointer(struct expression *expr)
+{
+	struct symbol *sym;
+
+	sym = get_type(expr);
+	if (!sym)
+		return 0;
+	if (sym == &string_ctype)
+		return 0;
+	if (sym->type == SYM_PTR)
+		return 1;
+	return 0;
+}
+
+int returns_pointer(struct symbol *sym)
+{
+	if (!sym)
+		return 0;
+	sym = get_base_type(sym);
+	if (!sym || sym->type != SYM_FN)
+		return 0;
+	sym = get_base_type(sym);
+	if (sym->type == SYM_PTR)
+		return 1;
+	return 0;
+}
+
+sval_t sval_type_max(struct symbol *base_type)
+{
+	sval_t ret;
+
+	if (!base_type || !type_bits(base_type))
+		base_type = &llong_ctype;
+	ret.type = base_type;
+
+	ret.value = (~0ULL) >> (64 - type_positive_bits(base_type));
+	return ret;
+}
+
+sval_t sval_type_min(struct symbol *base_type)
+{
+	sval_t ret;
+
+	if (!base_type || !type_bits(base_type))
+		base_type = &llong_ctype;
+	ret.type = base_type;
+
+	if (type_unsigned(base_type)) {
+		ret.value = 0;
+		return ret;
+	}
+
+	ret.value = (~0ULL) << type_positive_bits(base_type);
+
+	return ret;
+}
+
+int nr_bits(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (!type)
+		return 0;
+	return type_bits(type);
+}
+
+int is_void_pointer(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_PTR)
+		return 0;
+	type = get_real_base_type(type);
+	if (type == &void_ctype)
+		return 1;
+	return 0;
+}
+
+int is_char_pointer(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (!type || type->type != SYM_PTR)
+		return 0;
+	type = get_real_base_type(type);
+	if (type == &char_ctype)
+		return 1;
+	return 0;
+}
+
+int is_string(struct expression *expr)
+{
+	expr = strip_expr(expr);
+	if (!expr || expr->type != EXPR_STRING)
+		return 0;
+	if (expr->string)
+		return 1;
+	return 0;
+}
+
+int is_static(struct expression *expr)
+{
+	char *name;
+	struct symbol *sym;
+	int ret = 0;
+
+	name = expr_to_str_sym(expr, &sym);
+	if (!name || !sym)
+		goto free;
+
+	if (sym->ctype.modifiers & MOD_STATIC)
+		ret = 1;
+free:
+	free_string(name);
+	return ret;
+}
+
+int is_local_variable(struct expression *expr)
+{
+	struct symbol *sym;
+	char *name;
+
+	name = expr_to_var_sym(expr, &sym);
+	free_string(name);
+	if (!sym || !sym->scope || !sym->scope->token || !cur_func_sym)
+		return 0;
+	if (cmp_pos(sym->scope->token->pos, cur_func_sym->pos) < 0)
+		return 0;
+	if (is_static(expr))
+		return 0;
+	return 1;
+}
+
+int types_equiv(struct symbol *one, struct symbol *two)
+{
+	if (!one && !two)
+		return 1;
+	if (!one || !two)
+		return 0;
+	if (one->type != two->type)
+		return 0;
+	if (one->type == SYM_PTR)
+		return types_equiv(get_real_base_type(one), get_real_base_type(two));
+	if (type_positive_bits(one) != type_positive_bits(two))
+		return 0;
+	return 1;
+}
+
+int fn_static(void)
+{
+	return !!(cur_func_sym->ctype.modifiers & MOD_STATIC);
+}
+
+const char *global_static(void)
+{
+	if (cur_func_sym->ctype.modifiers & MOD_STATIC)
+		return "static";
+	else
+		return "global";
+}
+
+struct symbol *cur_func_return_type(void)
+{
+	struct symbol *sym;
+
+	sym = get_real_base_type(cur_func_sym);
+	if (!sym || sym->type != SYM_FN)
+		return NULL;
+	sym = get_real_base_type(sym);
+	return sym;
+}
+
+struct symbol *get_arg_type(struct expression *fn, int arg)
+{
+	struct symbol *fn_type;
+	struct symbol *tmp;
+	struct symbol *arg_type;
+	int i;
+
+	fn_type = get_type(fn);
+	if (!fn_type)
+		return NULL;
+	if (fn_type->type == SYM_PTR)
+		fn_type = get_real_base_type(fn_type);
+	if (fn_type->type != SYM_FN)
+		return NULL;
+
+	i = 0;
+	FOR_EACH_PTR(fn_type->arguments, tmp) {
+		arg_type = get_real_base_type(tmp);
+		if (i == arg) {
+			return arg_type;
+		}
+		i++;
+	} END_FOR_EACH_PTR(tmp);
+
+	return NULL;
+}
+
+static struct symbol *get_member_from_string(struct symbol_list *symbol_list, const char *name)
+{
+	struct symbol *tmp, *sub;
+	int chunk_len;
+
+	if (strncmp(name, ".", 1) == 0)
+		name += 1;
+	if (strncmp(name, "->", 2) == 0)
+		name += 2;
+
+	FOR_EACH_PTR(symbol_list, tmp) {
+		if (!tmp->ident) {
+			sub = get_real_base_type(tmp);
+			sub = get_member_from_string(sub->symbol_list, name);
+			if (sub)
+				return sub;
+			continue;
+		}
+
+		if (strcmp(tmp->ident->name, name) == 0)
+			return tmp;
+
+		chunk_len = strlen(tmp->ident->name);
+		if (strncmp(tmp->ident->name, name, chunk_len) == 0 &&
+		    (name[chunk_len] == '.' || name[chunk_len] == '-')) {
+			sub = get_real_base_type(tmp);
+			return get_member_from_string(sub->symbol_list, name + chunk_len);
+		}
+
+	} END_FOR_EACH_PTR(tmp);
+
+	return NULL;
+}
+
+struct symbol *get_member_type_from_key(struct expression *expr, const char *key)
+{
+	struct symbol *sym;
+
+	if (strcmp(key, "$") == 0)
+		return get_type(expr);
+
+	if (strcmp(key, "*$") == 0) {
+		sym = get_type(expr);
+		if (!sym || sym->type != SYM_PTR)
+			return NULL;
+		return get_real_base_type(sym);
+	}
+
+	sym = get_type(expr);
+	if (!sym)
+		return NULL;
+	if (sym->type == SYM_PTR)
+		sym = get_real_base_type(sym);
+
+	key = key + 1;
+	sym = get_member_from_string(sym->symbol_list, key);
+	if (!sym)
+		return NULL;
+	return get_real_base_type(sym);
+}
+
+struct symbol *get_arg_type_from_key(struct expression *fn, int param, struct expression *arg, const char *key)
+{
+	struct symbol *type;
+
+	if (!key)
+		return NULL;
+	if (strcmp(key, "$") == 0)
+		return get_arg_type(fn, param);
+	if (strcmp(key, "*$") == 0) {
+		type = get_arg_type(fn, param);
+		if (!type || type->type != SYM_PTR)
+			return NULL;
+		return get_real_base_type(type);
+	}
+	return get_member_type_from_key(arg, key);
+}
+
+int is_struct(struct expression *expr)
+{
+	struct symbol *type;
+
+	type = get_type(expr);
+	if (type && type->type == SYM_STRUCT)
+		return 1;
+	return 0;
+}
+
+static struct {
+	struct symbol *sym;
+	const char *name;
+} base_types[] = {
+	{&bool_ctype, "bool"},
+	{&void_ctype, "void"},
+	{&type_ctype, "type"},
+	{&char_ctype, "char"},
+	{&schar_ctype, "schar"},
+	{&uchar_ctype, "uchar"},
+	{&short_ctype, "short"},
+	{&sshort_ctype, "sshort"},
+	{&ushort_ctype, "ushort"},
+	{&int_ctype, "int"},
+	{&sint_ctype, "sint"},
+	{&uint_ctype, "uint"},
+	{&long_ctype, "long"},
+	{&slong_ctype, "slong"},
+	{&ulong_ctype, "ulong"},
+	{&llong_ctype, "llong"},
+	{&sllong_ctype, "sllong"},
+	{&ullong_ctype, "ullong"},
+	{&lllong_ctype, "lllong"},
+	{&slllong_ctype, "slllong"},
+	{&ulllong_ctype, "ulllong"},
+	{&float_ctype, "float"},
+	{&double_ctype, "double"},
+	{&ldouble_ctype, "ldouble"},
+	{&string_ctype, "string"},
+	{&ptr_ctype, "ptr"},
+	{&lazy_ptr_ctype, "lazy_ptr"},
+	{&incomplete_ctype, "incomplete"},
+	{&label_ctype, "label"},
+	{&bad_ctype, "bad"},
+	{&null_ctype, "null"},
+};
+
+static const char *base_type_str(struct symbol *sym)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(base_types); i++) {
+		if (sym == base_types[i].sym)
+			return base_types[i].name;
+	}
+	return "<unknown>";
+}
+
+static int type_str_helper(char *buf, int size, struct symbol *type)
+{
+	int n;
+
+	if (!type)
+		return snprintf(buf, size, "<unknown>");
+
+	if (type->type == SYM_BASETYPE) {
+		return snprintf(buf, size, base_type_str(type));
+	} else if (type->type == SYM_PTR) {
+		type = get_real_base_type(type);
+		n = type_str_helper(buf, size, type);
+		if (n > size)
+			return n;
+		return n + snprintf(buf + n, size - n, "*");
+	} else if (type->type == SYM_ARRAY) {
+		type = get_real_base_type(type);
+		n = type_str_helper(buf, size, type);
+		if (n > size)
+			return n;
+		return n + snprintf(buf + n, size - n, "[]");
+	} else if (type->type == SYM_STRUCT) {
+		return snprintf(buf, size, "struct %s", type->ident ? type->ident->name : "");
+	} else if (type->type == SYM_UNION) {
+		if (type->ident)
+			return snprintf(buf, size, "union %s", type->ident->name);
+		else
+			return snprintf(buf, size, "anonymous union");
+	} else if (type->type == SYM_FN) {
+		struct symbol *arg, *return_type, *arg_type;
+		int i;
+
+		return_type = get_real_base_type(type);
+		n = type_str_helper(buf, size, return_type);
+		if (n > size)
+			return n;
+		n += snprintf(buf + n, size - n, "(*)(");
+		if (n > size)
+			return n;
+
+		i = 0;
+		FOR_EACH_PTR(type->arguments, arg) {
+			if (i++)
+				n += snprintf(buf + n, size - n, ", ");
+			if (n > size)
+				return n;
+			arg_type = get_real_base_type(arg);
+			n += type_str_helper(buf + n, size - n, arg_type);
+			if (n > size)
+				return n;
+		} END_FOR_EACH_PTR(arg);
+
+		return n + snprintf(buf + n, size - n, ")");
+	} else if (type->type == SYM_NODE) {
+		n = snprintf(buf, size, "node {");
+		if (n > size)
+			return n;
+		type = get_real_base_type(type);
+		n += type_str_helper(buf + n, size - n, type);
+		if (n > size)
+			return n;
+		return n + snprintf(buf + n, size - n, "}");
+	} else {
+		return snprintf(buf, size, "<type %d>", type->type);
+	}
+}
+
+char *type_to_str(struct symbol *type)
+{
+	static char buf[256];
+
+	buf[0] = '\0';
+	type_str_helper(buf, sizeof(buf), type);
+	return buf;
+}
diff --git a/usr/src/tools/smatch/src/smatch_type_links.c b/usr/src/tools/smatch/src/smatch_type_links.c
new file mode 100644
index 0000000000..49eb4fb980
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_type_links.c
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The plan here is to save all the possible values store to a given struct
+ * member.
+ *
+ * We will load all the values in to the function_type_val table first then
+ * run a script on that and load all the resulting values into the type_val
+ * table.
+ *
+ * So in this file we want to take the union of everything assigned to the
+ * struct member and insert it into the function_type_val at the end.
+ *
+ * You would think that we could use smatch_modification_hooks.c or
+ * extra_modification_hook() here to get the information here but in the end we
+ * need to code everything again a third time.
+ *
+ */
+
+/*
+ * Remember links like:
+ *
+ * foo->void_ptr = some_struct.
+ *
+ * If we get a some_struct pointer from foo->void_ptr then assume it's the same
+ * stuff.
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+static void match_assign(struct expression *expr)
+{
+	struct symbol *type;
+
+	if (!is_void_pointer(expr->left))
+		return;
+
+	type = get_type(expr->right);
+	if (!type || type->type != SYM_PTR)
+		return;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_STRUCT)
+		return;
+
+	sql_insert_data_info(expr->left, TYPE_LINK, type_to_str(type));
+}
+
+void register_type_links(int id)
+{
+	if (!option_info)
+		return;
+	my_id = id;
+
+	add_hook(&match_assign, ASSIGNMENT_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_type_val.c b/usr/src/tools/smatch/src/smatch_type_val.c
new file mode 100644
index 0000000000..6baa2f50dd
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_type_val.c
@@ -0,0 +1,612 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The plan here is to save all the possible values store to a given struct
+ * member.
+ *
+ * We will load all the values in to the function_type_val table first then
+ * run a script on that and load all the resulting values into the type_val
+ * table.
+ *
+ * So in this file we want to take the union of everything assigned to the
+ * struct member and insert it into the function_type_val at the end.
+ *
+ * You would think that we could use smatch_modification_hooks.c or
+ * extra_modification_hook() here to get the information here but in the end we
+ * need to code everything again a third time.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+
+struct stree_stack *fn_type_val_stack;
+struct stree *fn_type_val;
+struct stree *global_type_val;
+
+static int get_vals(void *_db_vals, int argc, char **argv, char **azColName)
+{
+	char **db_vals = _db_vals;
+
+	*db_vals = alloc_string(argv[0]);
+	return 0;
+}
+
+static void match_inline_start(struct expression *expr)
+{
+	push_stree(&fn_type_val_stack, fn_type_val);
+	fn_type_val = NULL;
+}
+
+static void match_inline_end(struct expression *expr)
+{
+	free_stree(&fn_type_val);
+	fn_type_val = pop_stree(&fn_type_val_stack);
+}
+
+struct expr_rl {
+	struct expression *expr;
+	struct range_list *rl;
+};
+static struct expr_rl cached_results[10];
+static int res_idx;
+
+static int get_cached(struct expression *expr, struct range_list **rl, int *ret)
+{
+	int i;
+
+	*ret = 0;
+
+	for (i = 0; i < ARRAY_SIZE(cached_results); i++) {
+		if (expr == cached_results[i].expr) {
+			if (cached_results[i].rl) {
+				*rl = clone_rl(cached_results[i].rl);
+				*ret = 1;
+			}
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+int get_db_type_rl(struct expression *expr, struct range_list **rl)
+{
+	char *db_vals = NULL;
+	char *member;
+	struct range_list *tmp;
+	struct symbol *type;
+	int ret;
+
+	if (get_cached(expr, rl, &ret))
+		return ret;
+
+	member = get_member_name(expr);
+	if (!member)
+		return 0;
+
+	res_idx = (res_idx + 1) % ARRAY_SIZE(cached_results);
+	cached_results[res_idx].expr = expr;
+	cached_results[res_idx].rl = NULL;
+
+	run_sql(get_vals, &db_vals,
+		"select value from type_value where type = '%s';", member);
+	free_string(member);
+	if (!db_vals)
+		return 0;
+	type = get_type(expr);
+	str_to_rl(type, db_vals, &tmp);
+	free_string(db_vals);
+	if (is_whole_rl(tmp))
+		return 0;
+
+	*rl = tmp;
+	cached_results[res_idx].rl = clone_rl(tmp);
+
+	return 1;
+}
+
+static void add_type_val(char *member, struct range_list *rl)
+{
+	struct smatch_state *old, *add, *new;
+
+	member = alloc_string(member);
+	old = get_state_stree(fn_type_val, my_id, member, NULL);
+	add = alloc_estate_rl(rl);
+	if (old)
+		new = merge_estates(old, add);
+	else
+		new = add;
+	set_state_stree(&fn_type_val, my_id, member, NULL, new);
+}
+
+static void add_fake_type_val(char *member, struct range_list *rl, int ignore)
+{
+	struct smatch_state *old, *add, *new;
+
+	member = alloc_string(member);
+	old = get_state_stree(fn_type_val, my_id, member, NULL);
+	if (old && strcmp(old->name, "min-max") == 0)
+		return;
+	if (ignore && old && strcmp(old->name, "ignore") == 0)
+		return;
+	add = alloc_estate_rl(rl);
+	if (old) {
+		new = merge_estates(old, add);
+	} else {
+		new = add;
+		if (ignore)
+			new->name = alloc_string("ignore");
+		else
+			new->name = alloc_string("min-max");
+	}
+	set_state_stree(&fn_type_val, my_id, member, NULL, new);
+}
+
+static void add_global_type_val(char *member, struct range_list *rl)
+{
+	struct smatch_state *old, *add, *new;
+
+	member = alloc_string(member);
+	old = get_state_stree(global_type_val, my_id, member, NULL);
+	add = alloc_estate_rl(rl);
+	if (old)
+		new = merge_estates(old, add);
+	else
+		new = add;
+	new = clone_estate_perm(new);
+	set_state_stree_perm(&global_type_val, my_id, member, NULL, new);
+}
+
+static int has_link_cb(void *has_link, int argc, char **argv, char **azColName)
+{
+	*(int *)has_link = 1;
+	return 0;
+}
+
+static int is_ignored_fake_assignment(void)
+{
+	struct expression *expr;
+	struct symbol *type;
+	char *member_name;
+	int has_link = 0;
+
+	expr = get_faked_expression();
+	if (!expr || expr->type != EXPR_ASSIGNMENT)
+		return 0;
+	if (!is_void_pointer(expr->right))
+		return 0;
+	member_name = get_member_name(expr->right);
+	if (!member_name)
+		return 0;
+
+	type = get_type(expr->left);
+	if (!type || type->type != SYM_PTR)
+		return 0;
+	type = get_real_base_type(type);
+	if (!type || type->type != SYM_STRUCT)
+		return 0;
+
+	run_sql(has_link_cb, &has_link,
+		"select * from data_info where type = %d and data = '%s' and value = '%s';",
+		TYPE_LINK, member_name, type_to_str(type));
+	return has_link;
+}
+
+static int is_container_of(void)
+{
+	/* We already check the macro name in is_ignored_macro() */
+	struct expression *expr;
+	int offset;
+
+	expr = get_faked_expression();
+	if (!expr || expr->type != EXPR_ASSIGNMENT)
+		return 0;
+
+	offset = get_offset_from_container_of(expr->right);
+	if (offset < 0)
+		return 0;
+	return 1;
+}
+
+static int is_ignored_macro(void)
+{
+	struct expression *expr;
+	char *name;
+
+	expr = get_faked_expression();
+	if (!expr || expr->type != EXPR_ASSIGNMENT)
+		return 0;
+	name = get_macro_name(expr->right->pos);
+	if (!name)
+		return 0;
+	if (strcmp(name, "container_of") == 0)
+		return 1;
+	if (strcmp(name, "rb_entry") == 0)
+		return 1;
+	if (strcmp(name, "list_entry") == 0)
+		return 1;
+	if (strcmp(name, "list_first_entry") == 0)
+		return 1;
+	if (strcmp(name, "hlist_entry") == 0)
+		return 1;
+	if (strstr(name, "for_each"))
+		return 1;
+	return 0;
+}
+
+static int is_ignored_function(void)
+{
+	struct expression *expr;
+
+	expr = get_faked_expression();
+	if (!expr || expr->type != EXPR_ASSIGNMENT)
+		return 0;
+	expr = strip_expr(expr->right);
+	if (!expr || expr->type != EXPR_CALL || expr->fn->type != EXPR_SYMBOL)
+		return 0;
+
+	if (sym_name_is("kmalloc", expr->fn))
+		return 1;
+	if (sym_name_is("netdev_priv", expr->fn))
+		return 1;
+	if (sym_name_is("dev_get_drvdata", expr->fn))
+		return 1;
+
+	return 0;
+}
+
+static int is_uncasted_pointer_assign(void)
+{
+	struct expression *expr;
+	struct symbol *left_type, *right_type;
+
+	expr = get_faked_expression();
+	if (!expr)
+		return 0;
+	if (expr->type == EXPR_PREOP || expr->type == EXPR_POSTOP) {
+		if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
+			return 1;
+	}
+	if (expr->type != EXPR_ASSIGNMENT)
+		return 0;
+	left_type = get_type(expr->left);
+	right_type = get_type(expr->right);
+
+	if (!left_type || !right_type)
+		return 0;
+
+	if (left_type->type != SYM_PTR &&
+	    left_type->type != SYM_ARRAY)
+		return 0;
+	if (right_type->type != SYM_PTR &&
+	    right_type->type != SYM_ARRAY)
+		return 0;
+	left_type = get_real_base_type(left_type);
+	right_type = get_real_base_type(right_type);
+
+	if (left_type == right_type)
+		return 1;
+	return 0;
+}
+
+static int set_param_type(void *_type_str, int argc, char **argv, char **azColName)
+{
+	char **type_str = _type_str;
+	static char type_buf[128];
+
+	if (*type_str) {
+		if (strcmp(*type_str, argv[0]) == 0)
+			return 0;
+		strncpy(type_buf, "unknown", sizeof(type_buf));
+		return 0;
+	}
+	strncpy(type_buf, argv[0], sizeof(type_buf));
+	*type_str = type_buf;
+
+	return 0;
+}
+
+static char *db_get_parameter_type(int param)
+{
+	char *ret = NULL;
+
+	if (!cur_func_sym)
+		return NULL;
+
+	run_sql(set_param_type, &ret,
+		"select value from fn_data_link where "
+		"file = '%s' and function = '%s' and static = %d and type = %d and parameter = %d and key = '$';",
+		(cur_func_sym->ctype.modifiers & MOD_STATIC) ? get_base_file() : "extern",
+		cur_func_sym->ident->name,
+		!!(cur_func_sym->ctype.modifiers & MOD_STATIC),
+		PASSES_TYPE, param);
+
+	return ret;
+}
+
+static int is_uncasted_fn_param_from_db(void)
+{
+	struct expression *expr, *right;
+	struct symbol *left_type;
+	char left_type_name[128];
+	int param;
+	char *right_type_name;
+	static struct expression *prev_expr;
+	static int prev_ans;
+
+	expr = get_faked_expression();
+
+	if (expr == prev_expr)
+		return prev_ans;
+	prev_expr = expr;
+	prev_ans = 0;
+
+	if (!expr || expr->type != EXPR_ASSIGNMENT)
+		return 0;
+	left_type = get_type(expr->left);
+	if (!left_type || left_type->type != SYM_PTR)
+		return 0;
+	left_type = get_real_base_type(left_type);
+	if (!left_type || left_type->type != SYM_STRUCT)
+		return 0;
+	snprintf(left_type_name, sizeof(left_type_name), "%s", type_to_str(left_type));
+
+	right = strip_expr(expr->right);
+	param = get_param_num(right);
+	if (param < 0)
+		return 0;
+	right_type_name = db_get_parameter_type(param);
+	if (!right_type_name)
+		return 0;
+
+	if (strcmp(right_type_name, left_type_name) == 0) {
+		prev_ans = 1;
+		return 1;
+	}
+
+	return 0;
+}
+
+static void match_assign_value(struct expression *expr)
+{
+	char *member, *right_member;
+	struct range_list *rl;
+	struct symbol *type;
+
+	if (!cur_func_sym)
+		return;
+
+	type = get_type(expr->left);
+	if (type && type->type == SYM_STRUCT)
+		return;
+
+	member = get_member_name(expr->left);
+	if (!member)
+		return;
+
+	/* if we're saying foo->mtu = bar->mtu then that doesn't add information */
+	right_member = get_member_name(expr->right);
+	if (right_member && strcmp(right_member, member) == 0)
+		goto free;
+
+	if (is_fake_call(expr->right)) {
+		if (is_ignored_macro())
+			goto free;
+		if (is_ignored_function())
+			goto free;
+		if (is_uncasted_pointer_assign())
+			goto free;
+		if (is_uncasted_fn_param_from_db())
+			goto free;
+		if (is_container_of())
+			goto free;
+		add_fake_type_val(member, alloc_whole_rl(get_type(expr->left)), is_ignored_fake_assignment());
+		goto free;
+	}
+
+	if (expr->op == '=') {
+		get_absolute_rl(expr->right, &rl);
+		rl = cast_rl(type, rl);
+	} else {
+		/*
+		 * This is a bit cheating.  We order it so this will already be set
+		 * by smatch_extra.c and we just look up the value.
+		 */
+		get_absolute_rl(expr->left, &rl);
+	}
+	add_type_val(member, rl);
+free:
+	free_string(right_member);
+	free_string(member);
+}
+
+/*
+ * If we too:  int *p = &my_struct->member then abandon all hope of tracking
+ * my_struct->member.
+ */
+static void match_assign_pointer(struct expression *expr)
+{
+	struct expression *right;
+	char *member;
+	struct range_list *rl;
+	struct symbol *type;
+
+	right = strip_expr(expr->right);
+	if (right->type != EXPR_PREOP || right->op != '&')
+		return;
+	right = strip_expr(right->unop);
+
+	member = get_member_name(right);
+	if (!member)
+		return;
+	type = get_type(right);
+	rl = alloc_whole_rl(type);
+	add_type_val(member, rl);
+	free_string(member);
+}
+
+static void match_global_assign(struct expression *expr)
+{
+	char *member;
+	struct range_list *rl;
+	struct symbol *type;
+
+	type = get_type(expr->left);
+	if (type && (type->type == SYM_ARRAY || type->type == SYM_STRUCT))
+		return;
+	member = get_member_name(expr->left);
+	if (!member)
+		return;
+	get_absolute_rl(expr->right, &rl);
+	rl = cast_rl(type, rl);
+	add_global_type_val(member, rl);
+	free_string(member);
+}
+
+static void unop_expr(struct expression *expr)
+{
+	struct range_list *rl;
+	char *member;
+
+	if (expr->op != SPECIAL_DECREMENT && expr->op != SPECIAL_INCREMENT)
+		return;
+
+	expr = strip_expr(expr->unop);
+	member = get_member_name(expr);
+	if (!member)
+		return;
+	rl = alloc_whole_rl(get_type(expr));
+	add_type_val(member, rl);
+	free_string(member);
+}
+
+static void asm_expr(struct statement *stmt)
+{
+	struct expression *expr;
+	struct range_list *rl;
+	char *member;
+	int state = 0;
+
+	FOR_EACH_PTR(stmt->asm_outputs, expr) {
+		switch (state) {
+		case 0: /* identifier */
+		case 1: /* constraint */
+			state++;
+			continue;
+		case 2: /* expression */
+			state = 0;
+			member = get_member_name(expr);
+			if (!member)
+				continue;
+			rl = alloc_whole_rl(get_type(expr));
+			add_type_val(member, rl);
+			free_string(member);
+			continue;
+		}
+	} END_FOR_EACH_PTR(expr);
+}
+
+static void db_param_add(struct expression *expr, int param, char *key, char *value)
+{
+	struct expression *arg;
+	struct symbol *type;
+	struct range_list *rl;
+	char *member;
+
+	if (strcmp(key, "*$") != 0)
+		return;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	arg = get_argument_from_call_expr(expr->args, param);
+	arg = strip_expr(arg);
+	if (!arg)
+		return;
+	type = get_member_type_from_key(arg, key);
+	if (arg->type != EXPR_PREOP || arg->op != '&')
+		return;
+	arg = strip_expr(arg->unop);
+
+	member = get_member_name(arg);
+	if (!member)
+		return;
+	call_results_to_rl(expr, type, value, &rl);
+	add_type_val(member, rl);
+	free_string(member);
+}
+
+static void match_end_func_info(struct symbol *sym)
+{
+	struct sm_state *sm;
+
+	FOR_EACH_SM(fn_type_val, sm) {
+		sql_insert_function_type_value(sm->name, sm->state->name);
+	} END_FOR_EACH_SM(sm);
+}
+
+static void clear_cache(struct symbol *sym)
+{
+	memset(cached_results, 0, sizeof(cached_results));
+}
+
+static void match_after_func(struct symbol *sym)
+{
+	free_stree(&fn_type_val);
+}
+
+static void match_end_file(struct symbol_list *sym_list)
+{
+	struct sm_state *sm;
+
+	FOR_EACH_SM(global_type_val, sm) {
+		sql_insert_function_type_value(sm->name, sm->state->name);
+	} END_FOR_EACH_SM(sm);
+}
+
+void register_type_val(int id)
+{
+	my_id = id;
+	add_hook(&clear_cache, AFTER_FUNC_HOOK);
+
+	if (!option_info)
+		return;
+
+	add_hook(&match_assign_value, ASSIGNMENT_HOOK_AFTER);
+	add_hook(&match_assign_pointer, ASSIGNMENT_HOOK);
+	add_hook(&unop_expr, OP_HOOK);
+	add_hook(&asm_expr, ASM_HOOK);
+	select_return_states_hook(PARAM_ADD, &db_param_add);
+	select_return_states_hook(PARAM_SET, &db_param_add);
+
+
+	add_hook(&match_inline_start, INLINE_FN_START);
+	add_hook(&match_inline_end, INLINE_FN_END);
+
+	add_hook(&match_end_func_info, END_FUNC_HOOK);
+	add_hook(&match_after_func, AFTER_FUNC_HOOK);
+
+	add_hook(&match_global_assign, GLOBAL_ASSIGNMENT_HOOK);
+	add_hook(&match_end_file, END_FILE_HOOK);
+}
diff --git a/usr/src/tools/smatch/src/smatch_unknown_value.c b/usr/src/tools/smatch/src/smatch_unknown_value.c
new file mode 100644
index 0000000000..47dcc54c57
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_unknown_value.c
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * The situation here is that we often need to fake an assignment but we don't
+ * know anything about the right hand side of the assignment.  We use a fake
+ * function call of &llong_ctype.  The reason for using a function call instead
+ * of a value is so we don't start storing the equivalence.
+ *
+ */
+
+#include "smatch.h"
+
+struct ident fake_assign = {
+	.len = sizeof("fake assign"),
+	.name = "fake assign",
+};
+
+static struct symbol fake_fn_symbol = {
+	.type = SYM_FN,
+	.ident = &fake_assign,
+};
+
+static struct symbol fake_node_symbol = {
+	.type = SYM_NODE,
+	.ident = &fake_assign,
+};
+
+static struct expression fake_fn_expr = {
+	.type = EXPR_SYMBOL,
+	.ctype = &llong_ctype,
+};
+
+static struct expression fake_call = {
+	.type = EXPR_CALL,
+	.ctype = &llong_ctype,
+};
+
+static void __attribute__((constructor)) initialize_local_variables(void)
+{
+	fake_fn_symbol.ctype.base_type = &llong_ctype;
+	fake_node_symbol.ctype.base_type = &fake_fn_symbol;
+	fake_fn_expr.symbol = &fake_node_symbol;
+	fake_fn_expr.symbol_name = &fake_assign;
+	fake_call.fn = &fake_fn_expr;
+}
+
+struct expression *unknown_value_expression(struct expression *expr)
+{
+	fake_fn_expr.parent = 0;
+	fake_call.parent = 0;
+	return &fake_call;
+}
+
+int is_fake_call(struct expression *expr)
+{
+	return expr == &fake_call;
+}
diff --git a/usr/src/tools/smatch/src/smatch_untracked_param.c b/usr/src/tools/smatch/src/smatch_untracked_param.c
new file mode 100644
index 0000000000..7f07d9894d
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_untracked_param.c
@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2014 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+/*
+ * Sometimes we aren't able to track a variable through a function call.  This
+ * usually happens because a function changes too many variables so we give up.
+ * Another reason this happens is because we call a function pointer and there
+ * are too many functions which implement that function pointer so we give up.
+ * Also maybe we don't have the database enabled.
+ *
+ * The goal here is to make a call back so what if we call:
+ *
+ * 	frob(&foo);
+ *
+ * but we're not able to say what happens to "foo", then let's assume that we
+ * don't know anything about "foo" if it's an untracked call.
+ *
+ */
+
+#include "smatch.h"
+#include "smatch_slist.h"
+#include "smatch_extra.h"
+
+static int my_id;
+static int tracked;
+
+STATE(untracked);
+
+typedef void (untracked_hook)(struct expression *call, int param);
+DECLARE_PTR_LIST(untracked_hook_list, untracked_hook *);
+static struct untracked_hook_list *untracked_hooks;
+
+struct int_stack *tracked_stack;
+
+void add_untracked_param_hook(void (func)(struct expression *call, int param))
+{
+	untracked_hook **p = malloc(sizeof(untracked_hook *));
+	*p = func;
+	add_ptr_list(&untracked_hooks, p);
+}
+
+static void call_untracked_callbacks(struct expression *expr, int param)
+{
+	untracked_hook **fn;
+
+	FOR_EACH_PTR(untracked_hooks, fn) {
+		(*fn)(expr, param);
+	} END_FOR_EACH_PTR(fn);
+}
+
+static void assume_tracked(struct expression *call_expr, int param, char *key, char *value)
+{
+	tracked = 1;
+}
+
+void mark_untracked(struct expression *expr, int param, const char *key, const char *value)
+{
+	char *name;
+	struct symbol *sym;
+
+	while (expr->type == EXPR_ASSIGNMENT)
+		expr = strip_expr(expr->right);
+	if (expr->type != EXPR_CALL)
+		return;
+
+	name = return_state_to_var_sym(expr, param, key, &sym);
+	if (!name || !sym)
+		goto free;
+
+	call_untracked_callbacks(expr, param);
+	set_state(my_id, name, sym, &untracked);
+free:
+	free_string(name);
+}
+
+static int lost_in_va_args(struct expression *expr)
+{
+	struct symbol *fn;
+	char *name;
+	int is_lost;
+
+	fn = get_type(expr->fn);
+	if (!fn || !fn->variadic)
+		return 0;
+
+	is_lost = 1;
+	name = expr_to_var(expr->fn);
+	if (name && strstr(name, "print"))
+		is_lost = 0;
+	free_string(name);
+
+	return is_lost;
+}
+
+static void match_after_call(struct expression *expr)
+{
+	struct expression *arg;
+	struct symbol *type;
+	int i;
+
+	if (lost_in_va_args(expr))
+		tracked = 0;
+
+	if (tracked) {
+		tracked = 0;
+		return;
+	}
+
+	i = -1;
+	FOR_EACH_PTR(expr->args, arg) {
+		i++;
+
+		type = get_type(arg);
+		if (!type || type->type != SYM_PTR)
+			continue;
+
+		call_untracked_callbacks(expr, i);
+		set_state_expr(my_id, arg, &untracked);
+	} END_FOR_EACH_PTR(arg);
+}
+
+void mark_all_params_untracked(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct symbol *arg;
+	int param;
+
+	param = -1;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
+		param++;
+
+		if (!arg->ident)
+			continue;
+		sql_insert_return_states(return_id, return_ranges,
+					 UNTRACKED_PARAM, param, "$", "");
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void print_untracked_params(int return_id, char *return_ranges, struct expression *expr)
+{
+	struct symbol *arg;
+	int param;
+
+	param = -1;
+	FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, arg) {
+		param++;
+
+		if (!arg->ident)
+			continue;
+		if (!get_state(my_id, arg->ident->name, arg) &&
+		    !__bail_on_rest_of_function)  /* hairy functions are untrackable */
+			continue;
+
+		sql_insert_return_states(return_id, return_ranges,
+					 UNTRACKED_PARAM, param, "$", "");
+	} END_FOR_EACH_PTR(arg);
+}
+
+static void match_param_assign(struct expression *expr)
+{
+	struct expression *right;
+	struct symbol *type;
+	int param;
+
+	if (__in_fake_assign)
+		return;
+
+	right = strip_expr(expr->right);
+	type = get_type(right);
+	if (!type || type->type != SYM_PTR)
+		return;
+
+	param = get_param_num(right);
+	if (param < 0)
+		return;
+
+	set_state_expr(my_id, right, &untracked);
+}
+
+
+static void match_param_assign_in_asm(struct statement *stmt)
+{
+
+	struct expression *expr;
+	struct symbol *type;
+	int state = 0;
+	int param;
+
+	FOR_EACH_PTR(stmt->asm_inputs, expr) {
+		switch (state) {
+		case 0: /* identifier */
+		case 1: /* constraint */
+			state++;
+			continue;
+		case 2: /* expression */
+			state = 0;
+
+			expr = strip_expr(expr);
+			type = get_type(expr);
+			if (!type || type->type != SYM_PTR)
+				continue;
+			param = get_param_num(expr);
+			if (param < 0)
+				continue;
+			set_state_expr(my_id, expr, &untracked);
+			continue;
+		}
+	} END_FOR_EACH_PTR(expr);
+}
+
+static void match_inline_start(struct expression *expr)
+{
+	push_int(&tracked_stack, tracked);
+}
+
+static void match_inline_end(struct expression *expr)
+{
+	tracked = pop_int(&tracked_stack);
+}
+
+void register_untracked_param(int id)
+{
+	my_id = id;
+
+	select_return_states_hook(INTERNAL, &assume_tracked);
+	select_return_states_hook(UNTRACKED_PARAM, &mark_untracked);
+	add_hook(&match_after_call, FUNCTION_CALL_HOOK_AFTER_DB);
+
+	add_split_return_callback(&print_untracked_params);
+
+	add_hook(&match_param_assign, ASSIGNMENT_HOOK);
+	add_hook(&match_param_assign_in_asm, ASM_HOOK);
+
+	add_hook(&match_inline_start, INLINE_FN_START);
+	add_hook(&match_inline_end, INLINE_FN_END);
+}
diff --git a/usr/src/tools/smatch/src/smatch_var_sym.c b/usr/src/tools/smatch/src/smatch_var_sym.c
new file mode 100644
index 0000000000..7cfa06ac94
--- /dev/null
+++ b/usr/src/tools/smatch/src/smatch_var_sym.c
@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2013 Oracle.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
+ */
+
+#include "smatch.h"
+
+ALLOCATOR(var_sym, "var_sym structs");
+
+struct var_sym *alloc_var_sym(const char *var, struct symbol *sym)
+{
+	struct var_sym *tmp;
+
+	tmp = __alloc_var_sym(0);
+	tmp->var = alloc_string(var);
+	tmp->sym = sym;
+	return tmp;
+}
+
+struct var_sym_list *expr_to_vsl(struct expression *expr)
+{
+	struct expression *unop;
+	struct var_sym_list *ret = NULL;
+	char *var;
+	struct symbol *sym;
+
+	expr = strip_expr(expr);
+	if (!expr)
+		return NULL;
+
+	if ((expr->type == EXPR_PREOP && expr->op == '*')) {
+		unop = strip_expr(expr->unop);
+
+		if (unop->type == EXPR_SYMBOL)
+			goto one_var;
+		return expr_to_vsl(unop);
+	}
+
+	if (expr->type == EXPR_BINOP ||
+	    expr->type == EXPR_LOGICAL ||
+	    expr->type == EXPR_COMPARE) {
+		struct var_sym_list *left, *right;
+
+		left = expr_to_vsl(expr->left);
+		right = expr_to_vsl(expr->right);
+		ret = combine_var_sym_lists(left, right);
+		free_var_syms_and_list(&left);
+		free_var_syms_and_list(&right);
+		return ret;
+	}
+
+	if (expr->type == EXPR_DEREF)
+		return expr_to_vsl(expr->deref);
+
+one_var:
+	var = expr_to_var_sym(expr, &sym);
+	if (!var || !sym) {
+		free_string(var);
+		return NULL;
+	}
+	add_var_sym(&ret, var, sym);
+	return ret;
+}
+
+int cmp_var_sym(const struct var_sym *a, const struct var_sym *b)
+{
+	int ret;
+
+	if (a == b)
+		return 0;
+	if (!b)
+		return -1;
+	if (!a)
+		return 1;
+
+	ret = strcmp(a->var, b->var);
+	if (ret < 0)
+		return -1;
+	if (ret > 0)
+		return 1;
+
+	if (!b->sym && a->sym)
+		return -1;
+	if (!a->sym && b->sym)
+		return 1;
+	if (a->sym < b->sym)
+		return -1;
+	if (a->sym > b->sym)
+		return 1;
+
+	return 0;
+}
+
+void add_var_sym(struct var_sym_list **list, const char *var, struct symbol *sym)
+{
+	struct var_sym *tmp, *new;
+
+	if (in_var_sym_list(*list, var, sym))
+		return;
+	new = alloc_var_sym(var, sym);
+
+	FOR_EACH_PTR(*list, tmp) {
+		if (cmp_var_sym(tmp, new) < 0)
+			continue;
+		else if (cmp_var_sym(tmp, new) == 0) {
+			return;
+		} else {
+			INSERT_CURRENT(new, tmp);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+	add_ptr_list(list, new);
+}
+
+void add_var_sym_expr(struct var_sym_list **list, struct expression *expr)
+{
+	char *var;
+	struct symbol *sym;
+
+	var = expr_to_var_sym(expr, &sym);
+	if (!var || !sym)
+		goto free;
+	add_var_sym(list, var, sym);
+free:
+	free_string(var);
+}
+
+static void free_var_sym(struct var_sym *vs)
+{
+	free_string(vs->var);
+	__free_var_sym(vs);
+}
+
+void del_var_sym(struct var_sym_list **list, const char *var, struct symbol *sym)
+{
+	struct var_sym *tmp;
+
+	FOR_EACH_PTR(*list, tmp) {
+		if (tmp->sym == sym && strcmp(tmp->var, var) == 0) {
+			DELETE_CURRENT_PTR(tmp);
+			free_var_sym(tmp);
+			return;
+		}
+	} END_FOR_EACH_PTR(tmp);
+}
+
+int in_var_sym_list(struct var_sym_list *list, const char *var, struct symbol *sym)
+{
+	struct var_sym *tmp;
+
+	FOR_EACH_PTR(list, tmp) {
+		if (tmp->sym == sym && strcmp(tmp->var, var) == 0)
+			return 1;
+	} END_FOR_EACH_PTR(tmp);
+	return 0;
+}
+
+struct var_sym_list *clone_var_sym_list(struct var_sym_list *from_vsl)
+{
+	struct var_sym *tmp, *clone_vs;
+	struct var_sym_list *to_vsl = NULL;
+
+	FOR_EACH_PTR(from_vsl, tmp) {
+		clone_vs = alloc_var_sym(tmp->var, tmp->sym);
+		add_ptr_list(&to_vsl, clone_vs);
+	} END_FOR_EACH_PTR(tmp);
+	return to_vsl;
+}
+
+void merge_var_sym_list(struct var_sym_list **dest, struct var_sym_list *src)
+{
+	struct var_sym *tmp;
+
+	FOR_EACH_PTR(src, tmp) {
+		add_var_sym(dest, tmp->var, tmp->sym);
+	} END_FOR_EACH_PTR(tmp);
+}
+
+struct var_sym_list *combine_var_sym_lists(struct var_sym_list *one, struct var_sym_list *two)
+{
+	struct var_sym_list *to_vsl;
+
+	to_vsl = clone_var_sym_list(one);
+	merge_var_sym_list(&to_vsl, two);
+	return to_vsl;
+}
+
+int var_sym_lists_equiv(struct var_sym_list *one, struct var_sym_list *two)
+{
+	struct var_sym *one_tmp, *two_tmp;
+
+	if (one == two)
+		return 1;
+
+	if (ptr_list_size((struct ptr_list *)one) != ptr_list_size((struct ptr_list *)two))
+		return 0;
+
+	PREPARE_PTR_LIST(one, one_tmp);
+	PREPARE_PTR_LIST(two, two_tmp);
+	for (;;) {
+		if (!one_tmp && !two_tmp)
+			return 1;
+		if (one_tmp->sym != two_tmp->sym)
+			return 0;
+		if (strcmp(one_tmp->var, two_tmp->var) != 0)
+			return 0;
+		NEXT_PTR_LIST(one_tmp);
+		NEXT_PTR_LIST(two_tmp);
+	}
+	FINISH_PTR_LIST(two_tmp);
+	FINISH_PTR_LIST(one_tmp);
+
+	return 1;
+}
+
+void free_var_sym_list(struct var_sym_list **list)
+{
+	__free_ptr_list((struct ptr_list **)list);
+}
+
+void free_var_syms_and_list(struct var_sym_list **list)
+{
+	struct var_sym *tmp;
+
+	FOR_EACH_PTR(*list, tmp) {
+		free_var_sym(tmp);
+	} END_FOR_EACH_PTR(tmp);
+	free_var_sym_list(list);
+}
+
diff --git a/usr/src/tools/smatch/src/sort.c b/usr/src/tools/smatch/src/sort.c
new file mode 100644
index 0000000000..430ba44784
--- /dev/null
+++ b/usr/src/tools/smatch/src/sort.c
@@ -0,0 +1,290 @@
+/*
+ * sort_list: a stable sort for lists.
+ *
+ * Time complexity: O(n*log n)
+ *   [assuming limited zero-element fragments]
+ *
+ * Space complexity: O(1).
+ *
+ * Stable: yes.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "lib.h"
+#include "allocate.h"
+
+#undef PARANOIA
+#undef COVERAGE
+
+#ifdef PARANOIA
+#include <assert.h>
+#else
+#define assert(x)
+#endif
+
+#ifdef COVERAGE
+static unsigned char been_there[256];
+#define BEEN_THERE(_c)					\
+  do {							\
+	if (!been_there[_c]) {				\
+		been_there[_c] = 1;			\
+		printf ("Been there: %c\n", _c);	\
+	}						\
+  } while (0)
+#else
+#define BEEN_THERE(_c) do { } while (0)
+#endif
+
+// Sort one fragment.  LIST_NODE_NR (==29) is a bit too high for my
+// taste for something this simple.  But, hey, it's O(1).
+//
+// I would use libc qsort for this, but its comparison function
+// gets a pointer indirection extra.
+static void array_sort(void **ptr, int nr, int (*cmp)(const void *, const void *))
+{
+	int i;
+	for (i = 1; i < nr; i++) {
+		void *p = ptr[i];
+		if (cmp(ptr[i-1],p) > 0) {
+			int j = i;
+			do {
+				ptr[j] = ptr[j-1];
+				if (!--j)
+					break;
+			} while (cmp(ptr[j-1], p) > 0);
+			ptr[j] = p;
+		}
+	}
+}
+
+#ifdef PARANOIA
+static void verify_seq_sorted (struct ptr_list *l, int n,
+			       int (*cmp)(const void *, const void *))
+{
+	int i = 0;
+	const void *a;
+	struct ptr_list *head = l;
+
+	while (l->nr == 0) {
+		l = l->next;
+		if (--n == 0)
+			return;
+		assert (l != head);
+	}
+
+	a = l->list[0];
+	while (n > 0) {
+		const void *b;
+		if (++i >= l->nr) {
+			i = 0;
+			l = l->next;
+			n--;
+			assert (l != head || n == 0);
+			continue;
+		}
+		b = l->list[i];
+		assert (cmp (a, b) <= 0);
+		a = b;
+	}
+}
+#endif
+
+
+#define FLUSH_TO(b)						\
+  do {								\
+	int nr = (b)->nr;					\
+	assert (nbuf >= nr);					\
+	memcpy ((b)->list, buffer, nr * sizeof (void *));	\
+	nbuf -= nr;						\
+	memmove (buffer, buffer + nr, nbuf * sizeof (void *));	\
+  } while (0)
+
+#define DUMP_TO(b)						\
+  do {								\
+        assert (nbuf <= (b)->nr);				\
+	memcpy ((b)->list, buffer, nbuf * sizeof (void *));	\
+  } while (0)
+
+
+// Merge two already-sorted sequences of blocks:
+//   (b1_1, ..., b1_n)  and  (b2_1, ..., b2_m)
+// Since we may be moving blocks around, we return the new head
+// of the merged list.
+static struct ptr_list *
+merge_block_seqs (struct ptr_list *b1, int n,
+		  struct ptr_list *b2, int m,
+		  int (*cmp)(const void *, const void *))
+{
+	int i1 = 0, i2 = 0;
+	const void *buffer[2 * LIST_NODE_NR];
+	int nbuf = 0;
+	struct ptr_list *newhead = b1;
+
+	// printf ("Merging %d blocks at %p with %d blocks at %p\n", n, b1, m, b2);
+
+	// Skip empty blocks in b2.
+	while (b2->nr == 0) {
+		BEEN_THERE('F');
+		b2 = b2->next;
+		if (--m == 0) {
+			BEEN_THERE('G');
+			return newhead;
+		}
+	}
+
+	// Do a quick skip in case entire blocks from b1 are
+	// already less than smallest element in b2.
+	while (b1->nr == 0 ||
+	       cmp (PTR_ENTRY(b1, b1->nr - 1), PTR_ENTRY(b2,0)) < 0) {
+		// printf ("Skipping whole block.\n");
+		BEEN_THERE('H');
+		b1 = b1->next;
+		if (--n == 0) {
+			BEEN_THERE('I');
+			return newhead;	
+		}
+	}
+
+	while (1) {
+		const void *d1 = PTR_ENTRY(b1,i1);
+		const void *d2 = PTR_ENTRY(b2,i2);
+
+		assert (i1 >= 0 && i1 < b1->nr);
+		assert (i2 >= 0 && i2 < b2->nr);
+		assert (b1 != b2);
+		assert (n > 0);
+		assert (m > 0);
+
+		if (cmp (d1, d2) <= 0) {
+			BEEN_THERE('J');
+			buffer[nbuf++] = d1;
+			// Element from b1 is smaller
+			if (++i1 >= b1->nr) {
+				BEEN_THERE('L');
+				FLUSH_TO(b1);
+				do {
+					b1 = b1->next;
+					if (--n == 0) {
+						BEEN_THERE('O');
+						while (b1 != b2) {
+							BEEN_THERE('P');
+							FLUSH_TO(b1);
+							b1 = b1->next;
+						}
+						assert (nbuf == i2);
+						DUMP_TO(b2);
+						return newhead;
+					}
+				} while (b1->nr == 0);
+				i1 = 0;
+			}
+		} else {
+			BEEN_THERE('K');
+			// Element from b2 is smaller
+			buffer[nbuf++] = d2;
+			if (++i2 >= b2->nr) {
+				struct ptr_list *l = b2;
+				BEEN_THERE('M');
+				// OK, we finished with b2.  Pull it out
+				// and plug it in before b1.
+
+				b2 = b2->next;
+				b2->prev = l->prev;
+				b2->prev->next = b2;
+				l->next = b1;
+				l->prev = b1->prev;
+				l->next->prev = l;
+				l->prev->next = l;
+
+				if (b1 == newhead) {
+					BEEN_THERE('N');
+					newhead = l;
+				}
+
+				FLUSH_TO(l);
+				b2 = b2->prev;
+				do {
+					b2 = b2->next;
+					if (--m == 0) {
+						BEEN_THERE('Q');
+						assert (nbuf == i1);
+						DUMP_TO(b1);
+						return newhead;
+					}
+				} while (b2->nr == 0);
+				i2 = 0;
+			}
+		}
+	}
+}
+
+
+void sort_list(struct ptr_list **plist, int (*cmp)(const void *, const void *))
+{
+	struct ptr_list *head = *plist, *list = head;
+	int blocks = 1;
+
+	if (!head)
+		return;
+
+	// Sort all the sub-lists
+	do {
+		array_sort(list->list, list->nr, cmp);
+#ifdef PARANOIA
+		verify_seq_sorted (list, 1, cmp);
+#endif
+		list = list->next;
+	} while (list != head);
+
+	// Merge the damn things together
+	while (1) {
+		struct ptr_list *block1 = head;
+
+		do {
+			struct ptr_list *block2 = block1;
+			struct ptr_list *next, *newhead;
+			int i;
+
+			for (i = 0; i < blocks; i++) {
+				block2 = block2->next;
+				if (block2 == head) {
+					if (block1 == head) {
+						BEEN_THERE('A');
+						*plist = head;
+						return;
+					}
+					BEEN_THERE('B');
+					goto next_pass;
+				}						
+			}
+
+			next = block2;
+			for (i = 0; i < blocks; ) {
+				next = next->next;
+				i++;
+				if (next == head) {
+					BEEN_THERE('C');
+					break;
+				}
+				BEEN_THERE('D');
+			}
+
+			newhead = merge_block_seqs (block1, blocks,
+						    block2, i,
+						    cmp);
+#ifdef PARANOIA
+			verify_seq_sorted (newhead, blocks + i, cmp);
+#endif
+			if (block1 == head) {
+				BEEN_THERE('E');
+				head = newhead;
+			}
+			block1 = next;
+		} while (block1 != head);
+	next_pass:
+		blocks <<= 1;
+	}
+}
diff --git a/usr/src/tools/smatch/src/sparse-llvm.c b/usr/src/tools/smatch/src/sparse-llvm.c
new file mode 100644
index 0000000000..31f87f0b9b
--- /dev/null
+++ b/usr/src/tools/smatch/src/sparse-llvm.c
@@ -0,0 +1,1176 @@
+/*
+ * Example usage:
+ *	./sparse-llvm hello.c | llc | as -o hello.o
+ */
+
+#include <llvm-c/Core.h>
+#include <llvm-c/BitWriter.h>
+#include <llvm-c/Analysis.h>
+#include <llvm-c/Target.h>
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <assert.h>
+
+#include "symbol.h"
+#include "expression.h"
+#include "linearize.h"
+#include "flow.h"
+
+struct function {
+	LLVMBuilderRef			builder;
+	LLVMTypeRef			type;
+	LLVMValueRef			fn;
+	LLVMModuleRef			module;
+};
+
+static inline bool symbol_is_fp_type(struct symbol *sym)
+{
+	if (!sym)
+		return false;
+
+	return sym->ctype.base_type == &fp_type;
+}
+
+static LLVMTypeRef symbol_type(LLVMModuleRef module, struct symbol *sym);
+
+static LLVMTypeRef func_return_type(LLVMModuleRef module, struct symbol *sym)
+{
+	return symbol_type(module, sym->ctype.base_type);
+}
+
+static LLVMTypeRef sym_func_type(LLVMModuleRef module, struct symbol *sym)
+{
+	LLVMTypeRef *arg_type;
+	LLVMTypeRef func_type;
+	LLVMTypeRef ret_type;
+	struct symbol *arg;
+	int n_arg = 0;
+
+	/* to avoid strangeness with varargs [for now], we build
+	 * the function and type anew, for each call.  This
+	 * is probably wrong.  We should look up the
+	 * symbol declaration info.
+	 */
+
+	ret_type = func_return_type(module, sym);
+
+	/* count args, build argument type information */
+	FOR_EACH_PTR(sym->arguments, arg) {
+		n_arg++;
+	} END_FOR_EACH_PTR(arg);
+
+	arg_type = calloc(n_arg, sizeof(LLVMTypeRef));
+
+	int idx = 0;
+	FOR_EACH_PTR(sym->arguments, arg) {
+		struct symbol *arg_sym = arg->ctype.base_type;
+
+		arg_type[idx++] = symbol_type(module, arg_sym);
+	} END_FOR_EACH_PTR(arg);
+	func_type = LLVMFunctionType(ret_type, arg_type, n_arg,
+				     sym->variadic);
+
+	return func_type;
+}
+
+static LLVMTypeRef sym_array_type(LLVMModuleRef module, struct symbol *sym)
+{
+	LLVMTypeRef elem_type;
+	struct symbol *base_type;
+
+	base_type = sym->ctype.base_type;
+	/* empty struct is undefined [6.7.2.1(8)] */
+	assert(base_type->bit_size > 0);
+
+	elem_type = symbol_type(module, base_type);
+	if (!elem_type)
+		return NULL;
+
+	return LLVMArrayType(elem_type, sym->bit_size / base_type->bit_size);
+}
+
+#define MAX_STRUCT_MEMBERS 64
+
+static LLVMTypeRef sym_struct_type(LLVMModuleRef module, struct symbol *sym)
+{
+	LLVMTypeRef elem_types[MAX_STRUCT_MEMBERS];
+	struct symbol *member;
+	char buffer[256];
+	LLVMTypeRef ret;
+	unsigned nr = 0;
+
+	snprintf(buffer, sizeof(buffer), "struct.%s", sym->ident ? sym->ident->name : "anno");
+	ret = LLVMStructCreateNamed(LLVMGetGlobalContext(), buffer);
+	/* set ->aux to avoid recursion */
+	sym->aux = ret;
+
+	FOR_EACH_PTR(sym->symbol_list, member) {
+		LLVMTypeRef member_type;
+
+		assert(nr < MAX_STRUCT_MEMBERS);
+
+		member_type = symbol_type(module, member);
+
+		elem_types[nr++] = member_type; 
+	} END_FOR_EACH_PTR(member);
+
+	LLVMStructSetBody(ret, elem_types, nr, 0 /* packed? */); 
+	return ret;
+}
+
+static LLVMTypeRef sym_union_type(LLVMModuleRef module, struct symbol *sym)
+{
+	LLVMTypeRef elements;
+	unsigned union_size;
+
+	/*
+	 * There's no union support in the LLVM API so we treat unions as
+	 * opaque structs. The downside is that we lose type information on the
+	 * members but as LLVM doesn't care, neither do we.
+	 */
+	union_size = sym->bit_size / 8;
+
+	elements = LLVMArrayType(LLVMInt8Type(), union_size);
+
+	return LLVMStructType(&elements, 1, 0 /* packed? */);
+}
+
+static LLVMTypeRef sym_ptr_type(LLVMModuleRef module, struct symbol *sym)
+{
+	LLVMTypeRef type;
+
+	/* 'void *' is treated like 'char *' */
+	if (is_void_type(sym->ctype.base_type))
+		type = LLVMInt8Type();
+	else
+		type = symbol_type(module, sym->ctype.base_type);
+
+	return LLVMPointerType(type, 0);
+}
+
+static LLVMTypeRef sym_basetype_type(struct symbol *sym)
+{
+	LLVMTypeRef ret = NULL;
+
+	if (symbol_is_fp_type(sym)) {
+		switch (sym->bit_size) {
+		case 32:
+			ret = LLVMFloatType();
+			break;
+		case 64:
+			ret = LLVMDoubleType();
+			break;
+		case 80:
+			ret = LLVMX86FP80Type();
+			break;
+		default:
+			die("invalid bit size %d for type %d", sym->bit_size, sym->type);
+			break;
+		}
+	} else {
+		switch (sym->bit_size) {
+		case -1:
+			ret = LLVMVoidType();
+			break;
+		case 1:
+			ret = LLVMInt1Type();
+			break;
+		case 8:
+			ret = LLVMInt8Type();
+			break;
+		case 16:
+			ret = LLVMInt16Type();
+			break;
+		case 32:
+			ret = LLVMInt32Type();
+			break;
+		case 64:
+			ret = LLVMInt64Type();
+			break;
+		default:
+			die("invalid bit size %d for type %d", sym->bit_size, sym->type);
+			break;
+		}
+	}
+
+	return ret;
+}
+
+static LLVMTypeRef symbol_type(LLVMModuleRef module, struct symbol *sym)
+{
+	LLVMTypeRef ret = NULL;
+
+	/* don't cache the result for SYM_NODE */
+	if (sym->type == SYM_NODE)
+		return symbol_type(module, sym->ctype.base_type);
+
+	if (sym->aux)
+		return sym->aux;
+
+	switch (sym->type) {
+	case SYM_BITFIELD:
+	case SYM_ENUM:
+		ret = symbol_type(module, sym->ctype.base_type);
+		break;
+	case SYM_BASETYPE:
+		ret = sym_basetype_type(sym);
+		break;
+	case SYM_PTR:
+		ret = sym_ptr_type(module, sym);
+		break;
+	case SYM_UNION:
+		ret = sym_union_type(module, sym);
+		break;
+	case SYM_STRUCT:
+		ret = sym_struct_type(module, sym);
+		break;
+	case SYM_ARRAY:
+		ret = sym_array_type(module, sym);
+		break;
+	case SYM_FN:
+		ret = sym_func_type(module, sym);
+		break;
+	default:
+		assert(0);
+	}
+
+	/* cache the result */
+	sym->aux = ret;
+	return ret;
+}
+
+static LLVMTypeRef int_type_by_size(int size)
+{
+	switch (size) {
+		case 1:		return LLVMInt1Type();
+		case 8:		return LLVMInt8Type();
+		case 16:	return LLVMInt16Type();
+		case 32:	return LLVMInt32Type();
+		case 64:	return LLVMInt64Type();
+
+		default:
+			die("invalid bit size %d", size);
+			break;
+	}
+	return NULL;	/* not reached */
+}
+
+static LLVMTypeRef insn_symbol_type(LLVMModuleRef module, struct instruction *insn)
+{
+	if (insn->type)
+		return symbol_type(module, insn->type);
+
+	return int_type_by_size(insn->size);
+}
+
+static LLVMLinkage data_linkage(struct symbol *sym)
+{
+	if (sym->ctype.modifiers & MOD_STATIC)
+		return LLVMPrivateLinkage;
+
+	return LLVMExternalLinkage;
+}
+
+static LLVMLinkage function_linkage(struct symbol *sym)
+{
+	if (sym->ctype.modifiers & MOD_STATIC)
+		return LLVMInternalLinkage;
+
+	return LLVMExternalLinkage;
+}
+
+#define MAX_PSEUDO_NAME 64
+
+static void pseudo_name(pseudo_t pseudo, char *buf)
+{
+	switch (pseudo->type) {
+	case PSEUDO_REG:
+		snprintf(buf, MAX_PSEUDO_NAME, "R%d", pseudo->nr);
+		break;
+	case PSEUDO_SYM:
+		assert(0);
+		break;
+	case PSEUDO_VAL:
+		assert(0);
+		break;
+	case PSEUDO_ARG: {
+		assert(0);
+		break;
+	}
+	case PSEUDO_PHI:
+		snprintf(buf, MAX_PSEUDO_NAME, "PHI%d", pseudo->nr);
+		break;
+	default:
+		assert(0);
+	}
+}
+
+static LLVMValueRef pseudo_to_value(struct function *fn, struct instruction *insn, pseudo_t pseudo)
+{
+	LLVMValueRef result = NULL;
+
+	switch (pseudo->type) {
+	case PSEUDO_REG:
+		result = pseudo->priv;
+		break;
+	case PSEUDO_SYM: {
+		struct symbol *sym = pseudo->sym;
+		struct expression *expr;
+
+		assert(sym->bb_target == NULL);
+
+		expr = sym->initializer;
+		if (expr) {
+			switch (expr->type) {
+			case EXPR_STRING: {
+				const char *s = expr->string->data;
+				LLVMValueRef indices[] = { LLVMConstInt(LLVMInt64Type(), 0, 0), LLVMConstInt(LLVMInt64Type(), 0, 0) };
+				LLVMValueRef data;
+
+				data = LLVMAddGlobal(fn->module, LLVMArrayType(LLVMInt8Type(), strlen(s) + 1), ".str");
+				LLVMSetLinkage(data, LLVMPrivateLinkage);
+				LLVMSetGlobalConstant(data, 1);
+				LLVMSetInitializer(data, LLVMConstString(strdup(s), strlen(s) + 1, true));
+
+				result = LLVMConstGEP(data, indices, ARRAY_SIZE(indices));
+				break;
+			}
+			case EXPR_SYMBOL: {
+				struct symbol *sym = expr->symbol;
+
+				result = LLVMGetNamedGlobal(fn->module, show_ident(sym->ident));
+				assert(result != NULL);
+				break;
+			}
+			default:
+				assert(0);
+			}
+		} else {
+			const char *name = show_ident(sym->ident);
+			LLVMTypeRef type = symbol_type(fn->module, sym);
+
+			if (LLVMGetTypeKind(type) == LLVMFunctionTypeKind) {
+				result = LLVMGetNamedFunction(fn->module, name);
+				if (!result)
+					result = LLVMAddFunction(fn->module, name, type);
+			} else {
+				result = LLVMGetNamedGlobal(fn->module, name);
+				if (!result)
+					result = LLVMAddGlobal(fn->module, type, name);
+			}
+		}
+		break;
+	}
+	case PSEUDO_VAL:
+		result = LLVMConstInt(int_type_by_size(pseudo->size), pseudo->value, 1);
+		break;
+	case PSEUDO_ARG: {
+		result = LLVMGetParam(fn->fn, pseudo->nr - 1);
+		break;
+	}
+	case PSEUDO_PHI:
+		result = pseudo->priv;
+		break;
+	case PSEUDO_VOID:
+		result = NULL;
+		break;
+	default:
+		assert(0);
+	}
+
+	return result;
+}
+
+static LLVMValueRef calc_gep(LLVMBuilderRef builder, LLVMValueRef base, LLVMValueRef off)
+{
+	LLVMTypeRef type = LLVMTypeOf(base);
+	unsigned int as = LLVMGetPointerAddressSpace(type);
+	LLVMTypeRef bytep = LLVMPointerType(LLVMInt8Type(), as);
+	LLVMValueRef addr;
+
+	/* convert base to char* type */
+	base = LLVMBuildPointerCast(builder, base, bytep, "");
+	/* addr = base + off */
+	addr = LLVMBuildInBoundsGEP(builder, base, &off, 1, "");
+	/* convert back to the actual pointer type */
+	addr = LLVMBuildPointerCast(builder, addr, type, "");
+	return addr;
+}
+
+static LLVMRealPredicate translate_fop(int opcode)
+{
+	static const LLVMRealPredicate trans_tbl[] = {
+		[OP_SET_EQ]	= LLVMRealOEQ,
+		[OP_SET_NE]	= LLVMRealUNE,
+		[OP_SET_LE]	= LLVMRealOLE,
+		[OP_SET_GE]	= LLVMRealOGE,
+		[OP_SET_LT]	= LLVMRealOLT,
+		[OP_SET_GT]	= LLVMRealOGT,
+		/* Are these used with FP? */
+		[OP_SET_B]	= LLVMRealOLT,
+		[OP_SET_A]	= LLVMRealOGT,
+		[OP_SET_BE]	= LLVMRealOLE,
+		[OP_SET_AE]	= LLVMRealOGE,
+	};
+
+	return trans_tbl[opcode];
+}
+
+static LLVMIntPredicate translate_op(int opcode)
+{
+	static const LLVMIntPredicate trans_tbl[] = {
+		[OP_SET_EQ]	= LLVMIntEQ,
+		[OP_SET_NE]	= LLVMIntNE,
+		[OP_SET_LE]	= LLVMIntSLE,
+		[OP_SET_GE]	= LLVMIntSGE,
+		[OP_SET_LT]	= LLVMIntSLT,
+		[OP_SET_GT]	= LLVMIntSGT,
+		[OP_SET_B]	= LLVMIntULT,
+		[OP_SET_A]	= LLVMIntUGT,
+		[OP_SET_BE]	= LLVMIntULE,
+		[OP_SET_AE]	= LLVMIntUGE,
+	};
+
+	return trans_tbl[opcode];
+}
+
+static void output_op_binary(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef lhs, rhs, target;
+	char target_name[64];
+
+	lhs = pseudo_to_value(fn, insn, insn->src1);
+
+	rhs = pseudo_to_value(fn, insn, insn->src2);
+
+	pseudo_name(insn->target, target_name);
+
+	switch (insn->opcode) {
+	/* Binary */
+	case OP_ADD:
+		if (symbol_is_fp_type(insn->type))
+			target = LLVMBuildFAdd(fn->builder, lhs, rhs, target_name);
+		else
+			target = LLVMBuildAdd(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_SUB:
+		if (symbol_is_fp_type(insn->type))
+			target = LLVMBuildFSub(fn->builder, lhs, rhs, target_name);
+		else
+			target = LLVMBuildSub(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_MULU:
+		if (symbol_is_fp_type(insn->type))
+			target = LLVMBuildFMul(fn->builder, lhs, rhs, target_name);
+		else
+			target = LLVMBuildMul(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_MULS:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildMul(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_DIVU:
+		if (symbol_is_fp_type(insn->type))
+			target = LLVMBuildFDiv(fn->builder, lhs, rhs, target_name);
+		else
+			target = LLVMBuildUDiv(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_DIVS:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildSDiv(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_MODU:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildURem(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_MODS:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildSRem(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_SHL:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildShl(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_LSR:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildLShr(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_ASR:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildAShr(fn->builder, lhs, rhs, target_name);
+		break;
+	
+	/* Logical */
+	case OP_AND:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildAnd(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_OR:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildOr(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_XOR:
+		assert(!symbol_is_fp_type(insn->type));
+		target = LLVMBuildXor(fn->builder, lhs, rhs, target_name);
+		break;
+	case OP_AND_BOOL: {
+		LLVMValueRef lhs_nz, rhs_nz;
+		LLVMTypeRef dst_type;
+
+		lhs_nz = LLVMBuildIsNotNull(fn->builder, lhs, "");
+		rhs_nz = LLVMBuildIsNotNull(fn->builder, rhs, "");
+		target = LLVMBuildAnd(fn->builder, lhs_nz, rhs_nz, target_name);
+
+		dst_type = insn_symbol_type(fn->module, insn);
+		target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
+		break;
+	}
+	case OP_OR_BOOL: {
+		LLVMValueRef lhs_nz, rhs_nz;
+		LLVMTypeRef dst_type;
+
+		lhs_nz = LLVMBuildIsNotNull(fn->builder, lhs, "");
+		rhs_nz = LLVMBuildIsNotNull(fn->builder, rhs, "");
+		target = LLVMBuildOr(fn->builder, lhs_nz, rhs_nz, target_name);
+
+		dst_type = insn_symbol_type(fn->module, insn);
+		target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
+		break;
+	}
+	default:
+		assert(0);
+		break;
+	}
+
+	insn->target->priv = target;
+}
+
+static void output_op_compare(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef lhs, rhs, target;
+	char target_name[64];
+
+	lhs = pseudo_to_value(fn, insn, insn->src1);
+
+	if (insn->src2->type == PSEUDO_VAL)
+		rhs = LLVMConstInt(LLVMTypeOf(lhs), insn->src2->value, 1);
+	else
+		rhs = pseudo_to_value(fn, insn, insn->src2);
+
+	pseudo_name(insn->target, target_name);
+
+	LLVMTypeRef dst_type = insn_symbol_type(fn->module, insn);
+
+	if (LLVMGetTypeKind(LLVMTypeOf(lhs)) == LLVMIntegerTypeKind) {
+		LLVMIntPredicate op = translate_op(insn->opcode);
+
+		target = LLVMBuildICmp(fn->builder, op, lhs, rhs, target_name);
+	} else {
+		LLVMRealPredicate op = translate_fop(insn->opcode);
+
+		target = LLVMBuildFCmp(fn->builder, op, lhs, rhs, target_name);
+	}
+
+	target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
+
+	insn->target->priv = target;
+}
+
+static void output_op_ret(struct function *fn, struct instruction *insn)
+{
+	pseudo_t pseudo = insn->src;
+
+	if (pseudo && pseudo != VOID) {
+		LLVMValueRef result = pseudo_to_value(fn, insn, pseudo);
+
+		LLVMBuildRet(fn->builder, result);
+	} else
+		LLVMBuildRetVoid(fn->builder);
+}
+
+static LLVMValueRef calc_memop_addr(struct function *fn, struct instruction *insn)
+{
+	LLVMTypeRef int_type, addr_type;
+	LLVMValueRef src, off, addr;
+	unsigned int as;
+
+	/* int type large enough to hold a pointer */
+	int_type = LLVMIntType(bits_in_pointer);
+	off = LLVMConstInt(int_type, insn->offset, 0);
+
+	/* convert src to the effective pointer type */
+	src = pseudo_to_value(fn, insn, insn->src);
+	as = LLVMGetPointerAddressSpace(LLVMTypeOf(src));
+	addr_type = LLVMPointerType(insn_symbol_type(fn->module, insn), as);
+	src = LLVMBuildPointerCast(fn->builder, src, addr_type, "");
+
+	/* addr = src + off */
+	addr = calc_gep(fn->builder, src, off);
+	return addr;
+}
+
+
+static void output_op_load(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef addr, target;
+
+	addr = calc_memop_addr(fn, insn);
+
+	/* perform load */
+	target = LLVMBuildLoad(fn->builder, addr, "load_target");
+
+	insn->target->priv = target;
+}
+
+static void output_op_store(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef addr, target, target_in;
+
+	addr = calc_memop_addr(fn, insn);
+
+	target_in = pseudo_to_value(fn, insn, insn->target);
+
+	/* perform store */
+	target = LLVMBuildStore(fn->builder, target_in, addr);
+
+	insn->target->priv = target;
+}
+
+static LLVMValueRef bool_value(struct function *fn, LLVMValueRef value)
+{
+	if (LLVMTypeOf(value) != LLVMInt1Type())
+		value = LLVMBuildIsNotNull(fn->builder, value, "cond");
+
+	return value;
+}
+
+static void output_op_cbr(struct function *fn, struct instruction *br)
+{
+	LLVMValueRef cond = bool_value(fn,
+			pseudo_to_value(fn, br, br->cond));
+
+	LLVMBuildCondBr(fn->builder, cond,
+			br->bb_true->priv,
+			br->bb_false->priv);
+}
+
+static void output_op_br(struct function *fn, struct instruction *br)
+{
+	LLVMBuildBr(fn->builder, br->bb_true->priv);
+}
+
+static void output_op_sel(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef target, src1, src2, src3;
+
+	src1 = bool_value(fn, pseudo_to_value(fn, insn, insn->src1));
+	src2 = pseudo_to_value(fn, insn, insn->src2);
+	src3 = pseudo_to_value(fn, insn, insn->src3);
+
+	target = LLVMBuildSelect(fn->builder, src1, src2, src3, "select");
+
+	insn->target->priv = target;
+}
+
+static void output_op_switch(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef sw_val, target;
+	struct basic_block *def = NULL;
+	struct multijmp *jmp;
+	int n_jmp = 0;
+
+	FOR_EACH_PTR(insn->multijmp_list, jmp) {
+		if (jmp->begin == jmp->end) {		/* case N */
+			n_jmp++;
+		} else if (jmp->begin < jmp->end) {	/* case M..N */
+			assert(0);
+		} else					/* default case */
+			def = jmp->target;
+	} END_FOR_EACH_PTR(jmp);
+
+	sw_val = pseudo_to_value(fn, insn, insn->target);
+	target = LLVMBuildSwitch(fn->builder, sw_val,
+				 def ? def->priv : NULL, n_jmp);
+
+	FOR_EACH_PTR(insn->multijmp_list, jmp) {
+		if (jmp->begin == jmp->end) {		/* case N */
+			LLVMAddCase(target,
+				LLVMConstInt(LLVMInt32Type(), jmp->begin, 0),
+				jmp->target->priv);
+		} else if (jmp->begin < jmp->end) {	/* case M..N */
+			assert(0);
+		}
+	} END_FOR_EACH_PTR(jmp);
+
+	insn->target->priv = target;
+}
+
+static void output_op_call(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef target, func;
+	int n_arg = 0, i;
+	struct pseudo *arg;
+	LLVMValueRef *args;
+
+	FOR_EACH_PTR(insn->arguments, arg) {
+		n_arg++;
+	} END_FOR_EACH_PTR(arg);
+
+	args = calloc(n_arg, sizeof(LLVMValueRef));
+
+	i = 0;
+	FOR_EACH_PTR(insn->arguments, arg) {
+		args[i++] = pseudo_to_value(fn, insn, arg);
+	} END_FOR_EACH_PTR(arg);
+
+	func = pseudo_to_value(fn, insn, insn->func);
+	target = LLVMBuildCall(fn->builder, func, args, n_arg, "");
+
+	insn->target->priv = target;
+}
+
+static void output_op_phisrc(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef v;
+	struct instruction *phi;
+
+	assert(insn->target->priv == NULL);
+
+	/* target = src */
+	v = pseudo_to_value(fn, insn, insn->phi_src);
+
+	FOR_EACH_PTR(insn->phi_users, phi) {
+		LLVMValueRef load, ptr;
+
+		assert(phi->opcode == OP_PHI);
+		/* phi must be load from alloca */
+		load = phi->target->priv;
+		assert(LLVMGetInstructionOpcode(load) == LLVMLoad);
+		ptr = LLVMGetOperand(load, 0);
+		/* store v to alloca */
+		LLVMBuildStore(fn->builder, v, ptr);
+	} END_FOR_EACH_PTR(phi);
+}
+
+static void output_op_phi(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef load = insn->target->priv;
+
+	/* forward load */
+	assert(LLVMGetInstructionOpcode(load) == LLVMLoad);
+	/* forward load has no parent block */
+	assert(!LLVMGetInstructionParent(load));
+	/* finalize load in current block  */
+	LLVMInsertIntoBuilder(fn->builder, load);
+}
+
+static void output_op_ptrcast(struct function *fn, struct instruction *insn)
+{
+	LLVMValueRef src, target;
+	char target_name[64];
+
+	src = insn->src->priv;
+	if (!src)
+		src = pseudo_to_value(fn, insn, insn->src);
+
+	pseudo_name(insn->target, target_name);
+
+	assert(!symbol_is_fp_type(insn->type));
+
+	target = LLVMBuildBitCast(fn->builder, src, insn_symbol_type(fn->module, insn), target_name);
+
+	insn->target->priv = target;
+}
+
+static void output_op_cast(struct function *fn, struct instruction *insn, LLVMOpcode op)
+{
+	LLVMValueRef src, target;
+	char target_name[64];
+
+	src = insn->src->priv;
+	if (!src)
+		src = pseudo_to_value(fn, insn, insn->src);
+
+	pseudo_name(insn->target, target_name);
+
+	assert(!symbol_is_fp_type(insn->type));
+
+	if (insn->size < LLVMGetIntTypeWidth(LLVMTypeOf(src)))
+		target = LLVMBuildTrunc(fn->builder, src, insn_symbol_type(fn->module, insn), target_name);
+	else
+		target = LLVMBuildCast(fn->builder, op, src, insn_symbol_type(fn->module, insn), target_name);
+
+	insn->target->priv = target;
+}
+
+static void output_insn(struct function *fn, struct instruction *insn)
+{
+	switch (insn->opcode) {
+	case OP_RET:
+		output_op_ret(fn, insn);
+		break;
+	case OP_BR:
+		output_op_br(fn, insn);
+		break;
+	case OP_CBR:
+		output_op_cbr(fn, insn);
+		break;
+	case OP_SYMADDR:
+		assert(0);
+		break;
+	case OP_SETVAL:
+		assert(0);
+		break;
+	case OP_SWITCH:
+		output_op_switch(fn, insn);
+		break;
+	case OP_COMPUTEDGOTO:
+		assert(0);
+		break;
+	case OP_PHISOURCE:
+		output_op_phisrc(fn, insn);
+		break;
+	case OP_PHI:
+		output_op_phi(fn, insn);
+		break;
+	case OP_LOAD:
+		output_op_load(fn, insn);
+		break;
+	case OP_LNOP:
+		assert(0);
+		break;
+	case OP_STORE:
+		output_op_store(fn, insn);
+		break;
+	case OP_SNOP:
+		assert(0);
+		break;
+	case OP_INLINED_CALL:
+		assert(0);
+		break;
+	case OP_CALL:
+		output_op_call(fn, insn);
+		break;
+	case OP_CAST:
+		output_op_cast(fn, insn, LLVMZExt);
+		break;
+	case OP_SCAST:
+		output_op_cast(fn, insn, LLVMSExt);
+		break;
+	case OP_FPCAST:
+		assert(0);
+		break;
+	case OP_PTRCAST:
+		output_op_ptrcast(fn, insn);
+		break;
+	case OP_BINARY ... OP_BINARY_END:
+		output_op_binary(fn, insn);
+		break;
+	case OP_BINCMP ... OP_BINCMP_END:
+		output_op_compare(fn, insn);
+		break;
+	case OP_SEL:
+		output_op_sel(fn, insn);
+		break;
+	case OP_SLICE:
+		assert(0);
+		break;
+	case OP_NOT: {
+		LLVMValueRef src, target;
+		char target_name[64];
+
+		src = pseudo_to_value(fn, insn, insn->src);
+
+		pseudo_name(insn->target, target_name);
+
+		target = LLVMBuildNot(fn->builder, src, target_name);
+
+		insn->target->priv = target;
+		break;
+	}
+	case OP_NEG:
+		assert(0);
+		break;
+	case OP_CONTEXT:
+		assert(0);
+		break;
+	case OP_RANGE:
+		assert(0);
+		break;
+	case OP_NOP:
+		assert(0);
+		break;
+	case OP_DEATHNOTE:
+		break;
+	case OP_ASM:
+		assert(0);
+		break;
+	case OP_COPY:
+		assert(0);
+		break;
+	default:
+		break;
+	}
+}
+
+static void output_bb(struct function *fn, struct basic_block *bb, unsigned long generation)
+{
+	struct instruction *insn;
+
+	bb->generation = generation;
+
+	FOR_EACH_PTR(bb->insns, insn) {
+		if (!insn->bb)
+			continue;
+
+		output_insn(fn, insn);
+	}
+	END_FOR_EACH_PTR(insn);
+}
+
+#define MAX_ARGS	64
+
+static void output_fn(LLVMModuleRef module, struct entrypoint *ep)
+{
+	unsigned long generation = ++bb_generation;
+	struct symbol *sym = ep->name;
+	struct symbol *base_type = sym->ctype.base_type;
+	struct symbol *ret_type = sym->ctype.base_type->ctype.base_type;
+	LLVMTypeRef arg_types[MAX_ARGS];
+	LLVMTypeRef return_type;
+	struct function function = { .module = module };
+	struct basic_block *bb;
+	struct symbol *arg;
+	const char *name;
+	int nr_args = 0;
+
+	FOR_EACH_PTR(base_type->arguments, arg) {
+		struct symbol *arg_base_type = arg->ctype.base_type;
+
+		arg_types[nr_args++] = symbol_type(module, arg_base_type);
+	} END_FOR_EACH_PTR(arg);
+
+	name = show_ident(sym->ident);
+
+	return_type = symbol_type(module, ret_type);
+
+	function.type = LLVMFunctionType(return_type, arg_types, nr_args, 0);
+
+	function.fn = LLVMAddFunction(module, name, function.type);
+	LLVMSetFunctionCallConv(function.fn, LLVMCCallConv);
+
+	LLVMSetLinkage(function.fn, function_linkage(sym));
+
+	function.builder = LLVMCreateBuilder();
+
+	static int nr_bb;
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		if (bb->generation == generation)
+			continue;
+
+		LLVMBasicBlockRef bbr;
+		char bbname[32];
+		struct instruction *insn;
+
+		sprintf(bbname, "L%d", nr_bb++);
+		bbr = LLVMAppendBasicBlock(function.fn, bbname);
+
+		bb->priv = bbr;
+
+		/* allocate alloca for each phi */
+		FOR_EACH_PTR(bb->insns, insn) {
+			LLVMBasicBlockRef entrybbr;
+			LLVMTypeRef phi_type;
+			LLVMValueRef ptr;
+
+			if (!insn->bb || insn->opcode != OP_PHI)
+				continue;
+			/* insert alloca into entry block */
+			entrybbr = LLVMGetEntryBasicBlock(function.fn);
+			LLVMPositionBuilderAtEnd(function.builder, entrybbr);
+			phi_type = insn_symbol_type(module, insn);
+			ptr = LLVMBuildAlloca(function.builder, phi_type, "");
+			/* emit forward load for phi */
+			LLVMClearInsertionPosition(function.builder);
+			insn->target->priv = LLVMBuildLoad(function.builder, ptr, "phi");
+		} END_FOR_EACH_PTR(insn);
+	}
+	END_FOR_EACH_PTR(bb);
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		if (bb->generation == generation)
+			continue;
+
+		LLVMPositionBuilderAtEnd(function.builder, bb->priv);
+
+		output_bb(&function, bb, generation);
+	}
+	END_FOR_EACH_PTR(bb);
+}
+
+static LLVMValueRef output_data(LLVMModuleRef module, struct symbol *sym)
+{
+	struct expression *initializer = sym->initializer;
+	LLVMValueRef initial_value;
+	LLVMValueRef data;
+	const char *name;
+
+	if (initializer) {
+		switch (initializer->type) {
+		case EXPR_VALUE:
+			initial_value = LLVMConstInt(symbol_type(module, sym), initializer->value, 1);
+			break;
+		case EXPR_SYMBOL: {
+			struct symbol *sym = initializer->symbol;
+
+			initial_value = LLVMGetNamedGlobal(module, show_ident(sym->ident));
+			if (!initial_value)
+				initial_value = output_data(module, sym);
+			break;
+		}
+		case EXPR_STRING: {
+			const char *s = initializer->string->data;
+
+			initial_value = LLVMConstString(strdup(s), strlen(s) + 1, true);
+			break;
+		}
+		default:
+			assert(0);
+		}
+	} else {
+		LLVMTypeRef type = symbol_type(module, sym);
+
+		initial_value = LLVMConstNull(type);
+	}
+
+	name = show_ident(sym->ident);
+
+	data = LLVMAddGlobal(module, LLVMTypeOf(initial_value), name);
+
+	LLVMSetLinkage(data, data_linkage(sym));
+	if (sym->ctype.modifiers & MOD_CONST)
+		LLVMSetGlobalConstant(data, 1);
+	if (sym->ctype.modifiers & MOD_TLS)
+		LLVMSetThreadLocal(data, 1);
+	if (sym->ctype.alignment)
+		LLVMSetAlignment(data, sym->ctype.alignment);
+
+	if (!(sym->ctype.modifiers & MOD_EXTERN))
+		LLVMSetInitializer(data, initial_value);
+
+	return data;
+}
+
+static int is_prototype(struct symbol *sym)
+{
+	if (sym->type == SYM_NODE)
+		sym = sym->ctype.base_type;
+	return sym && sym->type == SYM_FN && !sym->stmt;
+}
+
+static int compile(LLVMModuleRef module, struct symbol_list *list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		struct entrypoint *ep;
+		expand_symbol(sym);
+
+		if (is_prototype(sym))
+			continue;
+
+		ep = linearize_symbol(sym);
+		if (ep)
+			output_fn(module, ep);
+		else
+			output_data(module, sym);
+	}
+	END_FOR_EACH_PTR(sym);
+
+	return 0;
+}
+
+#ifndef LLVM_DEFAULT_TARGET_TRIPLE
+#define LLVM_DEFAULT_TARGET_TRIPLE LLVM_HOSTTRIPLE
+#endif
+
+#define X86_LINUX_LAYOUT \
+	"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" \
+	"i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-" \
+	"a0:0:64-f80:32:32-n8:16:32-S128"
+
+#define X86_64_LINUX_LAYOUT \
+	"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" \
+	"i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-" \
+	"a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
+
+static void set_target(LLVMModuleRef module)
+{
+	char target[] = LLVM_DEFAULT_TARGET_TRIPLE;
+	const char *arch, *vendor, *os, *env, *layout = NULL;
+	char triple[256];
+
+	arch = strtok(target, "-");
+	vendor = strtok(NULL, "-");
+	os = strtok(NULL, "-");
+	env = strtok(NULL, "-");
+
+	if (!os)
+		return;
+	if (!env)
+		env = "unknown";
+
+	if (!strcmp(arch, "x86_64") && !strcmp(os, "linux")) {
+		if (arch_m64) {
+			layout = X86_64_LINUX_LAYOUT;
+		} else {
+			arch = "i386";
+			layout = X86_LINUX_LAYOUT;
+		}
+	}
+
+	/* unsupported target */
+	if (!layout)
+		return;
+
+	snprintf(triple, sizeof(triple), "%s-%s-%s-%s", arch, vendor, os, env);
+	LLVMSetTarget(module, triple);
+	LLVMSetDataLayout(module, layout);
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	struct symbol_list *symlist;
+	LLVMModuleRef module;
+	char *file;
+
+	symlist = sparse_initialize(argc, argv, &filelist);
+
+	module = LLVMModuleCreateWithName("sparse");
+	set_target(module);
+
+	compile(module, symlist);
+
+	/* need ->phi_users */
+	dbg_dead = 1;
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		symlist = sparse(file);
+		if (die_if_error)
+			return 1;
+		compile(module, symlist);
+	} END_FOR_EACH_PTR_NOTAG(file);
+
+	LLVMVerifyModule(module, LLVMPrintMessageAction, NULL);
+
+	LLVMWriteBitcodeToFD(module, STDOUT_FILENO, 0, 0);
+
+	LLVMDisposeModule(module);
+
+	report_stats();
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/sparse.1 b/usr/src/tools/smatch/src/sparse.1
new file mode 100644
index 0000000000..9be66c4c05
--- /dev/null
+++ b/usr/src/tools/smatch/src/sparse.1
@@ -0,0 +1,446 @@
+.\" Sparse manpage by Josh Triplett
+.TH sparse "1"
+.
+.SH NAME
+sparse \- Semantic Parser for C
+.
+.SH SYNOPSIS
+.B sparse
+[\fIWARNING OPTIONS\fR]... \fIfile.c\fR
+.
+.SH DESCRIPTION
+Sparse parses C source and looks for errors, producing warnings on standard
+error.
+.P
+Sparse accepts options controlling the set of warnings to generate.  To turn
+on warnings Sparse does not issue by default, use the corresponding warning
+option \fB\-Wsomething\fR.  Sparse issues some warnings by default; to turn
+off those warnings, pass the negation of the associated warning option,
+\fB\-Wno\-something\fR.
+.
+.SH WARNING OPTIONS
+.TP
+.B \-Wsparse\-all
+Turn on all sparse warnings, except for those explicitly disabled via
+\fB\-Wno\-something\fR.
+.TP
+.B \-Wsparse\-error
+Turn all sparse warnings into errors.
+.TP
+.B \-Waddress\-space
+Warn about code which mixes pointers to different address spaces.
+
+Sparse allows an extended attribute
+.BI __attribute__((address_space( num )))
+on pointers, which designates a pointer target in address space \fInum\fR (a
+constant integer).  With \fB\-Waddress\-space\fR, Sparse treats pointers with
+identical target types but different address spaces as distinct types.  To
+override this warning, such as for functions which convert pointers between
+address spaces, use a type that includes \fB__attribute__((force))\fR.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-address\-space\fR.
+.
+.TP
+.B \-Wbitwise
+Warn about unsupported operations or type mismatches with restricted integer
+types.
+
+Sparse supports an extended attribute, \fB__attribute__((bitwise))\fR, which
+creates a new restricted integer type from a base integer type, distinct from
+the base integer type and from any other restricted integer type not declared
+in the same declaration or \fBtypedef\fR.  For example, this allows programs
+to create \fBtypedef\fRs for integer types with specific endianness.  With
+\fB-Wbitwise\fR, Sparse will warn on any use of a restricted type in
+arithmetic operations other than bitwise operations, and on any conversion of
+one restricted type into another, except via a cast that includes
+\fB__attribute__((force))\fR.
+
+__bitwise ends up being a "stronger integer separation", one that
+doesn't allow you to mix with non-bitwise integers, so now it's much
+harder to lose the type by mistake.
+
+__bitwise is for *unique types* that cannot be mixed with other
+types, and that you'd never want to just use as a random integer (the
+integer 0 is special, though, and gets silently accepted iirc - it's
+kind of like "NULL" for pointers). So "gfp_t" or the "safe endianness"
+types would be __bitwise: you can only operate on them by doing
+specific operations that know about *that* particular type.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-bitwise\fR.
+.
+.TP
+.B \-Wcast\-to\-as
+Warn about casts which add an address space to a pointer type.
+
+A cast that includes \fB__attribute__((force))\fR will suppress this warning.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wcast\-truncate
+Warn about casts that truncate constant values.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-cast\-truncate\fR.
+.
+.TP
+.B \-Wconstant\-suffix
+Warn if an integer constant is larger than the maximum representable value
+of the type indicated by its type suffix (if any). For example, on a
+system where ints are 32-bit and longs 64-bit, the constant \fB0x100000000U\fR
+is larger than can be represented by an \fBunsigned int\fR but fits in an
+\fBunsigned long\fR. So its type is \fBunsigned long\fR but this is not
+indicated by its suffix. In this case, the warning could be suppressed by
+using the suffix \fBUL\fR: \fB0x100000000UL\fR.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wconstexpr-not-const
+Warn if a non-constant expression is encountered when really expecting a
+constant expression instead.
+Currently, this warns when initializing an object of static storage duration
+with an initializer which is not a constant expression.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wcontext
+Warn about potential errors in synchronization or other delimited contexts.
+
+Sparse supports several means of designating functions or statements that
+delimit contexts, such as synchronization.  Functions with the extended
+attribute
+.BI __attribute__((context( expression , in_context , out_context ))
+require the context \fIexpression\fR (for instance, a lock) to have the value
+\fIin_context\fR (a constant nonnegative integer) when called, and return with
+the value \fIout_context\fR (a constant nonnegative integer).  For APIs
+defined via macros, use the statement form
+.BI __context__( expression , in_value , out_value )
+in the body of the macro.
+
+With \fB-Wcontext\fR Sparse will warn when it sees a function change the
+context without indicating this with a \fBcontext\fR attribute, either by
+decreasing a context below zero (such as by releasing a lock without acquiring
+it), or returning with a changed context (such as by acquiring a lock without
+releasing it).  Sparse will also warn about blocks of code which may
+potentially execute with different contexts.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-context\fR.
+.
+.TP
+.B \-Wdecl
+Warn about any non-\fBstatic\fR variable or function definition that has no
+previous declaration.
+
+Private symbols (functions and variables) internal to a given source file
+should use \fBstatic\fR, to allow additional compiler optimizations, allow
+detection of unused symbols, and prevent other code from relying on these
+internal symbols.  Public symbols used by other source files will need
+declarations visible to those other source files, such as in a header file.
+All declarations should fall into one of these two categories.  Thus, with
+\fB-Wdecl\fR, Sparse warns about any symbol definition with neither
+\fBstatic\fR nor a declaration.  To fix this warning, declare private symbols
+\fBstatic\fR, and ensure that the files defining public symbols have the
+symbol declarations available first (such as by including the appropriate
+header file).
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-decl\fR.
+.
+.TP
+.B \-Wdeclaration-after-statement
+Warn about declarations that are not at the start of a block.
+
+These declarations are permitted in C99 but not in C89.
+
+Sparse issues these warnings by default only when the C dialect is
+C89 (i.e. -ansi or -std=c89).  To turn them off, use
+\fB\-Wno\-declaration\-after\-statement\fR.
+.
+.TP
+.B \-Wdefault\-bitfield\-sign
+Warn about any bitfield with no explicit signedness.
+
+Bitfields have no standard-specified default signedness. (C99 6.7.2) A
+bitfield without an explicit \fBsigned\fR or \fBunsigned\fR creates a
+portability problem for software that relies on the available range of values.
+To fix this, specify the bitfield type as \fBsigned\fR or \fBunsigned\fR
+explicitly.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wdesignated\-init
+Warn about positional initialization of structs marked as requiring designated
+initializers.
+
+Sparse allows an attribute
+.BI __attribute__((designated_init))
+which marks a struct as requiring designated initializers.  Sparse will warn
+about positional initialization of a struct variable or struct literal of a
+type that has this attribute.
+
+Requiring designated initializers for a particular struct type will insulate
+code using that struct type from changes to the layout of the type, avoiding
+the need to change initializers for that type unless they initialize a removed
+or incompatibly changed field.
+
+Common examples of this type of struct include collections of function pointers
+for the implementations of a class of related operations, for which the default
+NULL for an unmentioned field in a designated initializer will correctly
+indicate the absence of that operation.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-designated\-init\fR.
+.
+.TP
+.B \-Wdo\-while
+Warn about do-while loops that do not delimit the loop body with braces.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wenum\-mismatch
+Warn about the use of an expression of an incorrect \fBenum\fR type when
+initializing another \fBenum\fR type, assigning to another \fBenum\fR type, or
+passing an argument to a function which expects another \fBenum\fR type.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-enum\-mismatch\fR.
+.
+.TP
+.B \-Wempty\-character\-constant
+Warn about a constant such as ''.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-empty\-character\-constant\fR.
+.
+.TP
+.B \-Wexternal\-function\-has\-definition
+Warn about function definitions that are declared with external linkage.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-external\-function\-has\-definition\fR.
+.
+.TP
+.B \-Winit\-cstring
+Warn about initialization of a char array with a too long constant C string.
+
+If the size of the char array and the length of the string are the same,
+there is no space for the last nul char of the string in the array:
+
+.nf
+char s[3] = "abc";
+.fi
+
+If the array is used as a byte array, not as C string, this
+warning is just noise. However, if the array is passed to functions
+dealing with C string like printf(%s) and strcmp, it may cause a
+trouble.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wmemcpy\-max\-count
+Warn about call of \fBmemcpy()\fR, \fBmemset()\fR, \fBcopy_from_user()\fR, or
+\fBcopy_to_user()\fR with a large compile-time byte count.
+
+Sparse issues these warnings by default. To turn them off, use
+\fB\-Wno\-memcpy\-max\-count\fR.
+
+The limit can be changed with \fB\-fmemcpy\-max\-count=COUNT\fR,
+the default being \fB100000\fR.
+.
+.TP
+.B \-Wnon\-ansi\-function\-declaration
+Warn about non-ANSI function declarations.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-non\-ansi\-function\-declaration\fR.
+.
+.TP
+.B \-Wnon\-pointer\-null
+Warn about the use of 0 as a NULL pointer.
+
+0 has integer type.  NULL has pointer type.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-non\-pointer\-null\fR.
+.
+.TP
+.B \-Wold\-initializer
+Warn about the use of the pre-C99 GCC syntax for designated initializers.
+
+C99 provides a standard syntax for designated fields in \fBstruct\fR or
+\fBunion\fR initializers:
+
+.nf
+struct structname var = { .field = value };
+.fi
+
+GCC also has an old, non-standard syntax for designated initializers which
+predates C99:
+
+.nf
+struct structname var = { field: value };
+.fi
+
+Sparse will warn about the use of GCC's non-standard syntax for designated
+initializers.  To fix this warning, convert designated initializers to use the
+standard C99 syntax.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-old\-initializer\fR.
+.
+.TP
+.B \-Wone\-bit\-signed\-bitfield
+Warn about any one-bit \fBsigned\fR bitfields.
+
+A one-bit \fBsigned\fR bitfield can only have the values 0 and -1, or with
+some compilers only 0; this results in unexpected behavior for programs which
+expected the ability to store 0 and 1.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-one\-bit\-signed\-bitfield\fR.
+.
+.TP
+.B \-Wparen\-string
+Warn about the use of a parenthesized string to initialize an array.
+
+Standard C syntax does not permit a parenthesized string as an array
+initializer.  GCC allows this syntax as an extension.  With
+\fB\-Wparen\-string\fR, Sparse will warn about this syntax.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wpointer\-arith
+Warn about anything that depends on the \fBsizeof\fR a void or function type.
+
+C99 does not allow the \fBsizeof\fR operator to be applied to function types
+or to incomplete types such as void. GCC allows \fBsizeof\fR to be applied to
+these types as an extension and assigns these types a size of \fI1\fR. With
+\fB\-pointer\-arith\fR, Sparse will warn about pointer arithmetic on void
+or function pointers, as well as expressions which directly apply the
+\fBsizeof\fR operator to void or function types.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wptr\-subtraction\-blows
+Warn when subtracting two pointers to a type with a non-power-of-two size.
+
+Subtracting two pointers to a given type gives a difference in terms of the
+number of items of that type.  To generate this value, compilers will usually
+need to divide the difference by the size of the type, an potentially
+expensive operation for sizes other than powers of two.
+
+Code written using pointer subtraction can often use another approach instead,
+such as array indexing with an explicit array index variable, which may allow
+compilers to generate more efficient code.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wreturn\-void
+Warn if a function with return type void returns a void expression.
+
+C99 permits this, and in some cases this allows for more generic code in
+macros that use typeof or take a type as a macro argument.  However, some
+programs consider this poor style, and those programs can use
+\fB\-Wreturn\-void\fR to get warnings about it.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wshadow
+Warn when declaring a symbol which shadows a declaration with the same name in
+an outer scope.
+
+Such declarations can lead to error-prone code.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wsizeof-bool
+Warn when checking the sizeof a _Bool.
+
+C99 does not specify the sizeof a _Bool.  gcc uses 1.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wtransparent\-union
+Warn about any declaration using the GCC extension
+\fB__attribute__((transparent_union))\fR.
+
+Sparse issues these warnings by default.  To turn them off, use
+\fB\-Wno\-transparent\-union\fR.
+.
+.TP
+.B \-Wtypesign
+Warn when converting a pointer to an integer type into a pointer to an integer
+type with different signedness.
+
+Sparse does not issue these warnings by default.
+.
+.TP
+.B \-Wundef
+Warn about preprocessor conditionals that use the value of an undefined
+preprocessor symbol.
+
+Standard C (C99 6.10.1) permits using the value of an undefined preprocessor
+symbol in preprocessor conditionals, and specifies it has a value of 0.
+However, this behavior can lead to subtle errors.
+
+Sparse does not issue these warnings by default.
+.
+.SH MISC OPTIONS
+.TP
+.B \-gcc-base-dir \fIdir\fR
+Look for compiler-provided system headers in \fIdir\fR/include/ and \fIdir\fR/include-fixed/.
+.
+.TP
+.B \-multiarch-dir \fIdir\fR
+Look for system headers in the multiarch subdirectory \fIdir\fR.
+The \fIdir\fR name would normally take the form of the target's
+normalized GNU triplet. (e.g. i386-linux-gnu).
+.
+.SH DEBUG OPTIONS
+.TP
+.B \-fdump-linearize[=only]
+Dump the IR code of a function directly after its linearization,
+before any simplifications are made. If the argument \fB=only\fR is
+also given no further processing is done on the function.
+.
+.B \-fmem-report
+Report some statistics about memory allocation used by the tool.
+.
+.SH OTHER OPTIONS
+.TP
+.B \-fmemcpy-max-count=COUNT
+Set the limit for the warnings given by \fB-Wmemcpy-max-count\fR.
+A COUNT of 0, useless in itself, will effectively disable the warning.
+The default limit is 100000.
+.
+.TP
+.B \-ftabstop=WIDTH
+Set the distance between tab stops.  This helps sparse report correct
+column numbers in warnings or errors.  If the value is less than 1 or
+greater than 100, the option is ignored.  The default is 8.
+.
+.SH SEE ALSO
+.BR cgcc (1)
+.
+.SH HOMEPAGE
+http://www.kernel.org/pub/software/devel/sparse/
+.
+.SH MAILING LIST
+linux-sparse@vger.kernel.org
+.
+.SH MAINTAINER
+Christopher Li <sparse@chrisli.org>
diff --git a/usr/src/tools/smatch/src/sparse.c b/usr/src/tools/smatch/src/sparse.c
new file mode 100644
index 0000000000..bceacd94e6
--- /dev/null
+++ b/usr/src/tools/smatch/src/sparse.c
@@ -0,0 +1,308 @@
+/*
+ * Example trivial client program that uses the sparse library
+ * to tokenize, preprocess and parse a C file, and prints out
+ * the results.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+#include "linearize.h"
+
+static int context_increase(struct basic_block *bb, int entry)
+{
+	int sum = 0;
+	struct instruction *insn;
+
+	FOR_EACH_PTR(bb->insns, insn) {
+		int val;
+		if (insn->opcode != OP_CONTEXT)
+			continue;
+		val = insn->increment;
+		if (insn->check) {
+			int current = sum + entry;
+			if (!val) {
+				if (!current)
+					continue;
+			} else if (current >= val)
+				continue;
+			warning(insn->pos, "context check failure");
+			continue;
+		}
+		sum += val;
+	} END_FOR_EACH_PTR(insn);
+	return sum;
+}
+
+static int imbalance(struct entrypoint *ep, struct basic_block *bb, int entry, int exit, const char *why)
+{
+	if (Wcontext) {
+		struct symbol *sym = ep->name;
+		warning(bb->pos, "context imbalance in '%s' - %s", show_ident(sym->ident), why);
+	}
+	return -1;
+}
+
+static int check_bb_context(struct entrypoint *ep, struct basic_block *bb, int entry, int exit);
+
+static int check_children(struct entrypoint *ep, struct basic_block *bb, int entry, int exit)
+{
+	struct instruction *insn;
+	struct basic_block *child;
+
+	insn = last_instruction(bb->insns);
+	if (!insn)
+		return 0;
+	if (insn->opcode == OP_RET)
+		return entry != exit ? imbalance(ep, bb, entry, exit, "wrong count at exit") : 0;
+
+	FOR_EACH_PTR(bb->children, child) {
+		if (check_bb_context(ep, child, entry, exit))
+			return -1;
+	} END_FOR_EACH_PTR(child);
+	return 0;
+}
+
+static int check_bb_context(struct entrypoint *ep, struct basic_block *bb, int entry, int exit)
+{
+	if (!bb)
+		return 0;
+	if (bb->context == entry)
+		return 0;
+
+	/* Now that's not good.. */
+	if (bb->context >= 0)
+		return imbalance(ep, bb, entry, bb->context, "different lock contexts for basic block");
+
+	bb->context = entry;
+	entry += context_increase(bb, entry);
+	if (entry < 0)
+		return imbalance(ep, bb, entry, exit, "unexpected unlock");
+
+	return check_children(ep, bb, entry, exit);
+}
+
+static void check_cast_instruction(struct instruction *insn)
+{
+	struct symbol *orig_type = insn->orig_type;
+	if (orig_type) {
+		int old = orig_type->bit_size;
+		int new = insn->size;
+		int oldsigned = (orig_type->ctype.modifiers & MOD_SIGNED) != 0;
+		int newsigned = insn->opcode == OP_SCAST;
+
+		if (new > old) {
+			if (oldsigned == newsigned)
+				return;
+			if (newsigned)
+				return;
+			warning(insn->pos, "cast loses sign");
+			return;
+		}
+		if (new < old) {
+			warning(insn->pos, "cast drops bits");
+			return;
+		}
+		if (oldsigned == newsigned) {
+			warning(insn->pos, "cast wasn't removed");
+			return;
+		}
+		warning(insn->pos, "cast changes sign");
+	}
+}
+
+static void check_range_instruction(struct instruction *insn)
+{
+	warning(insn->pos, "value out of range");
+}
+
+static void check_byte_count(struct instruction *insn, pseudo_t count)
+{
+	if (!count)
+		return;
+	if (count->type == PSEUDO_VAL) {
+		unsigned long long val = count->value;
+		if (Wmemcpy_max_count && val > fmemcpy_max_count)
+			warning(insn->pos, "%s with byte count of %llu",
+				show_ident(insn->func->sym->ident), val);
+		return;
+	}
+	/* OK, we could try to do the range analysis here */
+}
+
+static pseudo_t argument(struct instruction *call, unsigned int argno)
+{
+	pseudo_t args[8];
+	struct ptr_list *arg_list = (struct ptr_list *) call->arguments;
+
+	argno--;
+	if (linearize_ptr_list(arg_list, (void *)args, 8) > argno)
+		return args[argno];
+	return NULL;
+}
+
+static void check_memset(struct instruction *insn)
+{
+	check_byte_count(insn, argument(insn, 3));
+}
+
+#define check_memcpy check_memset
+#define check_ctu check_memset
+#define check_cfu check_memset
+
+struct checkfn {
+	struct ident *id;
+	void (*check)(struct instruction *insn);
+};
+
+static void check_call_instruction(struct instruction *insn)
+{
+	pseudo_t fn = insn->func;
+	struct ident *ident;
+	static const struct checkfn check_fn[] = {
+		{ &memset_ident, check_memset },
+		{ &memcpy_ident, check_memcpy },
+		{ &copy_to_user_ident, check_ctu },
+		{ &copy_from_user_ident, check_cfu },
+	};
+	int i;
+
+	if (fn->type != PSEUDO_SYM)
+		return;
+	ident = fn->sym->ident;
+	if (!ident)
+		return;
+	for (i = 0; i < ARRAY_SIZE(check_fn); i++) {
+		if (check_fn[i].id != ident)
+			continue;
+		check_fn[i].check(insn);
+		break;
+	}
+}
+
+static void check_one_instruction(struct instruction *insn)
+{
+	switch (insn->opcode) {
+	case OP_CAST: case OP_SCAST:
+		if (verbose)
+			check_cast_instruction(insn);
+		break;
+	case OP_RANGE:
+		check_range_instruction(insn);
+		break;
+	case OP_CALL:
+		check_call_instruction(insn);
+		break;
+	default:
+		break;
+	}
+}
+
+static void check_bb_instructions(struct basic_block *bb)
+{
+	struct instruction *insn;
+	FOR_EACH_PTR(bb->insns, insn) {
+		if (!insn->bb)
+			continue;
+		check_one_instruction(insn);
+	} END_FOR_EACH_PTR(insn);
+}
+
+static void check_instructions(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+	FOR_EACH_PTR(ep->bbs, bb) {
+		check_bb_instructions(bb);
+	} END_FOR_EACH_PTR(bb);
+}
+
+static void check_context(struct entrypoint *ep)
+{
+	struct symbol *sym = ep->name;
+	struct context *context;
+	unsigned int in_context = 0, out_context = 0;
+
+	if (Wuninitialized && verbose && ep->entry->bb->needs) {
+		pseudo_t pseudo;
+		FOR_EACH_PTR(ep->entry->bb->needs, pseudo) {
+			if (pseudo->type != PSEUDO_ARG)
+				warning(sym->pos, "%s: possible uninitialized variable (%s)",
+					show_ident(sym->ident), show_pseudo(pseudo));
+		} END_FOR_EACH_PTR(pseudo);
+	}
+
+	check_instructions(ep);
+
+	FOR_EACH_PTR(sym->ctype.contexts, context) {
+		in_context += context->in;
+		out_context += context->out;
+	} END_FOR_EACH_PTR(context);
+	check_bb_context(ep, ep->entry->bb, in_context, out_context);
+}
+
+static void check_symbols(struct symbol_list *list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		struct entrypoint *ep;
+
+		expand_symbol(sym);
+		ep = linearize_symbol(sym);
+		if (ep) {
+			if (dbg_entry)
+				show_entry(ep);
+
+			check_context(ep);
+		}
+	} END_FOR_EACH_PTR(sym);
+
+	if (Wsparse_error && die_if_error)
+		exit(1);
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	char *file;
+
+	// Expand, linearize and show it.
+	check_symbols(sparse_initialize(argc, argv, &filelist));
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		check_symbols(sparse(file));
+	} END_FOR_EACH_PTR_NOTAG(file);
+
+	report_stats();
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/sparse.pc.in b/usr/src/tools/smatch/src/sparse.pc.in
new file mode 100644
index 0000000000..f1281c97a5
--- /dev/null
+++ b/usr/src/tools/smatch/src/sparse.pc.in
@@ -0,0 +1,9 @@
+prefix=@prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: Sparse
+Description: Semantic parser for C
+Version: @version@
+Libs: -L${libdir} -lsparse
+Cflags: -I${includedir}
diff --git a/usr/src/tools/smatch/src/sparsec b/usr/src/tools/smatch/src/sparsec
new file mode 100755
index 0000000000..9dc96c956e
--- /dev/null
+++ b/usr/src/tools/smatch/src/sparsec
@@ -0,0 +1,54 @@
+#!/bin/sh
+#
+# GCC compatible C compiler based on Sparse LLVM
+
+set +e
+
+SPARSEOPTS=""
+DIRNAME=`dirname $0`
+
+NEED_LINK=1
+
+if [ $# -eq 0 ]; then
+  echo "`basename $0`: no input files"
+  exit 1
+fi
+
+while [ $# -gt 0 ]; do
+	case $1 in
+	'-o')
+		OUTFILE=$2
+		shift
+		;;
+	'-c')
+		NEED_LINK=0
+		;;
+	*)
+		SPARSEOPTS="$SPARSEOPTS $1 " ;;
+	esac
+	shift
+done
+
+TMPLLVM=`mktemp -t tmp.XXXXXX`".llvm"
+TMPFILE=`mktemp -t tmp.XXXXXX`".o"
+
+$DIRNAME/sparse-llvm $SPARSEOPTS > $TMPLLVM
+
+LLC=`"${LLVM_CONFIG:-llvm-config}" --bindir`/llc
+
+$LLC -o - $TMPLLVM | as -o $TMPFILE
+
+if [ $NEED_LINK -eq 1 ]; then
+	if [ -z $OUTFILE ]; then
+		OUTFILE=a.out
+	fi
+	gcc $TMPFILE -o $OUTFILE
+else
+	if [ -z $OUTFILE ]; then
+		echo "`basename $0`: no output file"
+		exit 1
+	fi
+	mv $TMPFILE $OUTFILE
+fi
+
+rm -f $TMPLLVM
diff --git a/usr/src/tools/smatch/src/sparsei b/usr/src/tools/smatch/src/sparsei
new file mode 100755
index 0000000000..3431a9f0b5
--- /dev/null
+++ b/usr/src/tools/smatch/src/sparsei
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+set +e
+
+DIRNAME=`dirname $0`
+LLI=`"${LLVM_CONFIG:-llvm-config}" --bindir`/lli
+
+if [ $# -eq 0 ]; then
+  echo "`basename $0`: no input files"
+  exit 1
+fi
+
+$DIRNAME/sparse-llvm $@ | $LLI
diff --git a/usr/src/tools/smatch/src/stats.c b/usr/src/tools/smatch/src/stats.c
new file mode 100644
index 0000000000..cda18fcaed
--- /dev/null
+++ b/usr/src/tools/smatch/src/stats.c
@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include "allocate.h"
+#include "linearize.h"
+#include "storage.h"
+
+__DECLARE_ALLOCATOR(struct ptr_list, ptrlist);
+
+
+typedef void (*get_t)(struct allocator_stats*);
+
+static void show_stats(get_t get, struct allocator_stats * tot)
+{
+	struct allocator_stats x;
+
+	if (get)
+		get(&x);
+	else
+		x = *tot;
+	fprintf(stderr, "%16s: %8d, %10ld, %10ld, %6.2f%%, %8.2f\n",
+		x.name, x.allocations, x.useful_bytes, x.total_bytes,
+		100 * (double) x.useful_bytes / (x.total_bytes ? : 1),
+		(double) x.useful_bytes / (x.allocations ? : 1));
+
+	tot->allocations += x.allocations;
+	tot->useful_bytes += x.useful_bytes;
+	tot->total_bytes += x.total_bytes;
+}
+
+void show_allocation_stats(void)
+{
+	struct allocator_stats tot = { .name = "total", };
+
+	fprintf(stderr, "%16s: %8s, %10s, %10s, %7s, %8s\n", "allocator", "allocs",
+		"bytes", "total", "%usage", "average");
+	show_stats(get_token_stats, &tot);
+	show_stats(get_ident_stats, &tot);
+	show_stats(get_symbol_stats, &tot);
+	show_stats(get_expression_stats, &tot);
+	show_stats(get_statement_stats, &tot);
+	show_stats(get_scope_stats, &tot);
+	show_stats(get_basic_block_stats, &tot);
+	show_stats(get_instruction_stats, &tot);
+	show_stats(get_pseudo_stats, &tot);
+	show_stats(get_pseudo_user_stats, &tot);
+	show_stats(get_ptrlist_stats, &tot);
+	show_stats(get_multijmp_stats, &tot);
+	show_stats(get_asm_rules_stats, &tot);
+	show_stats(get_asm_constraint_stats, &tot);
+	show_stats(get_context_stats, &tot);
+	show_stats(get_string_stats, &tot);
+	show_stats(get_bytes_stats, &tot);
+	//show_stats(get_storage_stats, &tot);
+	//show_stats(get_storage_hash_stats, &tot);
+
+	show_stats(NULL, &tot);
+}
+
+void report_stats(void)
+{
+	if (fmem_report)
+		show_allocation_stats();
+}
diff --git a/usr/src/tools/smatch/src/storage.c b/usr/src/tools/smatch/src/storage.c
new file mode 100644
index 0000000000..acbc477d5f
--- /dev/null
+++ b/usr/src/tools/smatch/src/storage.c
@@ -0,0 +1,307 @@
+/*
+ * Storage - associate pseudos with "storage" that keeps them alive
+ * between basic blocks.  The aim is to be able to turn as much of
+ * the global storage allocation problem as possible into a local
+ * per-basic-block one.
+ *
+ * Copyright (C) 2004 Linus Torvalds
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "symbol.h"
+#include "expression.h"
+#include "linearize.h"
+#include "storage.h"
+
+ALLOCATOR(storage, "storages");
+ALLOCATOR(storage_hash, "storage hash");
+
+#define MAX_STORAGE_HASH 64
+static struct storage_hash_list *storage_hash_table[MAX_STORAGE_HASH];
+
+static inline unsigned int storage_hash(struct basic_block *bb, pseudo_t pseudo, enum inout_enum inout)
+{
+	unsigned hash = hashval(bb) + hashval(pseudo) + hashval(inout);
+	hash += hash / MAX_STORAGE_HASH;
+	return hash & (MAX_STORAGE_HASH-1);
+}
+
+static int hash_list_cmp(const void *_a, const void *_b)
+{
+	const struct storage_hash *a = _a;
+	const struct storage_hash *b = _b;
+	if (a->pseudo != b->pseudo)
+		return a->pseudo < b->pseudo ? -1 : 1;
+	return 0;
+}
+
+static void sort_hash_list(struct storage_hash_list **listp)
+{
+	sort_list((struct ptr_list **)listp, hash_list_cmp);
+}
+
+struct storage_hash_list *gather_storage(struct basic_block *bb, enum inout_enum inout)
+{
+	int i;
+	struct storage_hash *entry, *prev;
+	struct storage_hash_list *list = NULL;
+
+	for (i = 0; i < MAX_STORAGE_HASH; i++) {
+		struct storage_hash *hash;
+		FOR_EACH_PTR(storage_hash_table[i], hash) {
+			if (hash->bb == bb && hash->inout == inout)
+				add_ptr_list(&list, hash);
+		} END_FOR_EACH_PTR(hash);
+	}
+	sort_hash_list(&list);
+
+	prev = NULL;
+	FOR_EACH_PTR(list, entry) {
+		if (prev && entry->pseudo == prev->pseudo) {
+			assert(entry == prev);
+			DELETE_CURRENT_PTR(entry);
+		}
+		prev = entry;
+	} END_FOR_EACH_PTR(entry);
+	PACK_PTR_LIST(&list);
+	return list;
+}
+
+static void name_storage(void)
+{
+	int i;
+	int name = 0;
+
+	for (i = 0; i < MAX_STORAGE_HASH; i++) {
+		struct storage_hash *hash;
+		FOR_EACH_PTR(storage_hash_table[i], hash) {
+			struct storage *storage = hash->storage;
+			if (storage->name)
+				continue;
+			storage->name = ++name;
+		} END_FOR_EACH_PTR(hash);
+	}
+}
+
+struct storage *lookup_storage(struct basic_block *bb, pseudo_t pseudo, enum inout_enum inout)
+{
+	struct storage_hash_list *list = storage_hash_table[storage_hash(bb,pseudo,inout)];
+	struct storage_hash *hash;
+
+	FOR_EACH_PTR(list, hash) {
+		if (hash->bb == bb && hash->pseudo == pseudo && hash->inout == inout)
+			return hash->storage;
+	} END_FOR_EACH_PTR(hash);
+	return NULL;
+}
+
+void add_storage(struct storage *storage, struct basic_block *bb, pseudo_t pseudo, enum inout_enum inout)
+{
+	struct storage_hash_list **listp = storage_hash_table + storage_hash(bb,pseudo,inout);
+	struct storage_hash *hash = alloc_storage_hash(storage);
+
+	hash->bb = bb;
+	hash->pseudo = pseudo;
+	hash->inout = inout;
+
+	add_ptr_list(listp, hash);
+}
+
+
+static int storage_hash_cmp(const void *_a, const void *_b)
+{
+	const struct storage_hash *a = _a;
+	const struct storage_hash *b = _b;
+	struct storage *aa = a->storage;
+	struct storage *bb = b->storage;
+
+	if (a->bb != b->bb)
+		return a->bb < b->bb ? -1 : 1;
+	if (a->inout != b->inout)
+		return a->inout < b->inout ? -1 : 1;
+	if (aa->type != bb->type)
+		return aa->type < bb->type ? -1 : 1;
+	if (aa->regno != bb->regno)
+		return aa->regno < bb->regno ? -1 : 1;
+	return 0;
+}
+
+static void vrfy_storage(struct storage_hash_list **listp)
+{
+	struct storage_hash *entry, *last;
+
+	sort_list((struct ptr_list **)listp, storage_hash_cmp);
+	last = NULL;
+	FOR_EACH_PTR(*listp, entry) {
+		if (last) {
+			struct storage *a = last->storage;
+			struct storage *b = entry->storage;
+			if (a == b)
+				continue;
+			if (last->bb == entry->bb
+			    && last->inout == entry->inout
+			    && a->type != REG_UDEF
+			    && a->type == b->type
+			    && a->regno == b->regno) {
+				printf("\t BAD: same storage as %s in %p: %s (%s and %s)\n",
+					last->inout == STOR_IN ? "input" : "output",
+					last->bb,
+					show_storage(a),
+					show_pseudo(last->pseudo),
+					show_pseudo(entry->pseudo));
+			}
+		}
+		last = entry;
+	} END_FOR_EACH_PTR(entry);
+}
+
+void free_storage(void)
+{
+	int i;
+
+	for (i = 0; i < MAX_STORAGE_HASH; i++) {
+		vrfy_storage(storage_hash_table + i);
+		free_ptr_list(storage_hash_table + i);
+	}
+}
+
+const char *show_storage(struct storage *s)
+{
+	static char buffer[1024];
+	if (!s)
+		return "none";
+	switch (s->type) {
+	case REG_REG:
+		sprintf(buffer, "reg%d (%d)", s->regno, s->name);
+		break;
+	case REG_STACK:
+		sprintf(buffer, "%d(SP) (%d)", s->offset, s->name);
+		break;
+	case REG_ARG:
+		sprintf(buffer, "ARG%d (%d)", s->regno, s->name);
+		break;
+	default:
+		sprintf(buffer, "%d:%d (%d)", s->type, s->regno, s->name);
+		break;
+	}
+	return buffer;
+}
+
+/*
+ * Combine two storage allocations into one.
+ *
+ * We just randomly pick one over the other, and replace
+ * the other uses.
+ */
+static struct storage * combine_storage(struct storage *src, struct storage *dst)
+{
+	struct storage **usep;
+
+	/* Remove uses of "src_storage", replace with "dst" */
+	FOR_EACH_PTR(src->users, usep) {
+		assert(*usep == src);
+		*usep = dst;
+		add_ptr_list(&dst->users, usep);
+	} END_FOR_EACH_PTR(usep);
+
+	/* Mark it unused */
+	src->type = REG_BAD;
+	src->users = NULL;
+	return dst;
+}
+
+static void set_up_bb_storage(struct basic_block *bb)
+{
+	struct basic_block *child;
+
+	FOR_EACH_PTR(bb->children, child) {
+		pseudo_t pseudo;
+		FOR_EACH_PTR(child->needs, pseudo) {
+			struct storage *child_in, *parent_out;
+
+			parent_out = lookup_storage(bb, pseudo, STOR_OUT);
+			child_in = lookup_storage(child, pseudo, STOR_IN);
+
+			if (parent_out) {
+				if (!child_in) {
+					add_storage(parent_out, child, pseudo, STOR_IN);
+					continue;
+				}
+				if (parent_out == child_in)
+					continue;
+				combine_storage(parent_out, child_in);
+				continue;
+			}
+			if (child_in) {
+				add_storage(child_in, bb, pseudo, STOR_OUT);
+				continue;
+			}
+			parent_out = alloc_storage();
+			add_storage(parent_out, bb, pseudo, STOR_OUT);
+			add_storage(parent_out, child, pseudo, STOR_IN);
+		} END_FOR_EACH_PTR(pseudo);
+	} END_FOR_EACH_PTR(child);
+}
+
+static void set_up_argument_storage(struct entrypoint *ep, struct basic_block *bb)
+{
+	pseudo_t arg;
+
+	FOR_EACH_PTR(bb->needs, arg) {
+		struct storage *storage = alloc_storage();
+
+		/* FIXME! Totally made-up argument passing conventions */
+		if (arg->type == PSEUDO_ARG) {
+			storage->type = REG_ARG;
+			storage->regno = arg->nr;
+		}
+		add_storage(storage, bb, arg, STOR_IN);
+	} END_FOR_EACH_PTR(arg);
+}
+
+/*
+ * One phi-source may feed multiple phi nodes. If so, combine
+ * the storage output for this bb into one entry to reduce
+ * storage pressure.
+ */
+static void combine_phi_storage(struct basic_block *bb)
+{
+	struct instruction *insn;
+	FOR_EACH_PTR(bb->insns, insn) {
+		struct instruction *phi;
+		struct storage *last;
+
+		if (!insn->bb || insn->opcode != OP_PHISOURCE)
+			continue;
+		last = NULL;
+		FOR_EACH_PTR(insn->phi_users, phi) {
+			struct storage *storage = lookup_storage(bb, phi->target, STOR_OUT);
+			if (!storage) {
+				DELETE_CURRENT_PTR(phi);
+				continue;
+			}
+			if (last && storage != last)
+				storage = combine_storage(storage, last);
+			last = storage;
+		} END_FOR_EACH_PTR(phi);
+		PACK_PTR_LIST(&insn->phi_users);
+	} END_FOR_EACH_PTR(insn);
+}
+
+void set_up_storage(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+
+	/* First set up storage for the incoming arguments */
+	set_up_argument_storage(ep, ep->entry->bb);
+
+	/* Then do a list of all the inter-bb storage */
+	FOR_EACH_PTR(ep->bbs, bb) {
+		set_up_bb_storage(bb);
+		combine_phi_storage(bb);
+	} END_FOR_EACH_PTR(bb);
+
+	name_storage();
+}
diff --git a/usr/src/tools/smatch/src/storage.h b/usr/src/tools/smatch/src/storage.h
new file mode 100644
index 0000000000..e049e235bd
--- /dev/null
+++ b/usr/src/tools/smatch/src/storage.h
@@ -0,0 +1,79 @@
+#ifndef STORAGE_H
+#define STORAGE_H
+
+#include "allocate.h"
+#include "lib.h"
+
+/*
+ * The "storage" that underlies an incoming/outgoing pseudo. It's
+ * basically the backing store for a pseudo, and may be a real hardware
+ * register, a stack slot or a static symbol. Or nothing at all,
+ * since some pseudos can just be recalculated on the fly.
+ */
+enum storage_type {
+	REG_UDEF,
+	REG_REG,
+	REG_STACK,
+	REG_FRAME,
+	REG_SYM,
+	REG_ARG,
+	REG_BAD,
+};
+
+enum inout_enum {
+	STOR_IN,
+	STOR_OUT
+};
+
+struct storage;
+DECLARE_PTR_LIST(storage_ptr_list, struct storage *);
+
+struct storage {
+	enum storage_type type;
+	int name;
+	struct storage_ptr_list *users;
+	union {
+		int regno;
+		int offset;
+		struct symbol *sym;
+	};
+};
+
+DECLARE_PTR_LIST(storage_list, struct storage);
+
+struct storage_hash {
+	struct basic_block *bb;
+	pseudo_t pseudo;
+	enum inout_enum inout;
+	struct storage *storage;
+	unsigned long flags;
+};
+
+DECLARE_PTR_LIST(storage_hash_list, struct storage_hash);
+
+extern struct storage_hash_list *gather_storage(struct basic_block *, enum inout_enum);
+extern void free_storage(void);
+extern const char *show_storage(struct storage *);
+extern void set_up_storage(struct entrypoint *);
+struct storage *lookup_storage(struct basic_block *, pseudo_t, enum inout_enum);
+void add_storage(struct storage *, struct basic_block *, pseudo_t, enum inout_enum);
+
+DECLARE_ALLOCATOR(storage);
+DECLARE_ALLOCATOR(storage_hash);
+
+static inline struct storage *alloc_storage(void)
+{
+	return __alloc_storage(0);
+}
+
+static inline struct storage_hash *alloc_storage_hash(struct storage *s)
+{
+	struct storage_hash *entry = __alloc_storage_hash(0);
+	struct storage **usep = &entry->storage;
+
+	*usep = s;
+	add_ptr_list(&s->users, usep);
+	return entry;
+}
+
+#endif /* STORAGE_H */
diff --git a/usr/src/tools/smatch/src/symbol.c b/usr/src/tools/smatch/src/symbol.c
new file mode 100644
index 0000000000..bf3250e524
--- /dev/null
+++ b/usr/src/tools/smatch/src/symbol.c
@@ -0,0 +1,776 @@
+/*
+ * Symbol lookup and handling.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "scope.h"
+#include "expression.h"
+
+#include "target.h"
+
+/*
+ * Secondary symbol list for stuff that needs to be output because it
+ * was used. 
+ */
+struct symbol_list *translation_unit_used_list = NULL;
+
+/*
+ * If the symbol is an inline symbol, add it to the list of symbols to parse
+ */
+void access_symbol(struct symbol *sym)
+{
+	if (sym->ctype.modifiers & MOD_INLINE) {
+		if (!(sym->ctype.modifiers & MOD_ACCESSED)) {
+			add_symbol(&translation_unit_used_list, sym);
+			sym->ctype.modifiers |= MOD_ACCESSED;
+		}
+	}
+}
+
+struct symbol *lookup_symbol(struct ident *ident, enum namespace ns)
+{
+	struct symbol *sym;
+
+	for (sym = ident->symbols; sym; sym = sym->next_id) {
+		if (sym->namespace & ns) {
+			sym->used = 1;
+			return sym;
+		}
+	}
+	return NULL;
+}
+
+struct context *alloc_context(void)
+{
+	return __alloc_context(0);
+}
+
+struct symbol *alloc_symbol(struct position pos, int type)
+{
+	struct symbol *sym = __alloc_symbol(0);
+	sym->type = type;
+	sym->pos = pos;
+	sym->endpos.type = 0;
+	return sym;
+}
+
+struct struct_union_info {
+	unsigned long max_align;
+	unsigned long bit_size;
+	int align_size;
+};
+
+/*
+ * Unions are fairly easy to lay out ;)
+ */
+static void lay_out_union(struct symbol *sym, struct struct_union_info *info)
+{
+	examine_symbol_type(sym);
+
+	// Unnamed bitfields do not affect alignment.
+	if (sym->ident || !is_bitfield_type(sym)) {
+		if (sym->ctype.alignment > info->max_align)
+			info->max_align = sym->ctype.alignment;
+	}
+
+	if (sym->bit_size > info->bit_size)
+		info->bit_size = sym->bit_size;
+
+	sym->offset = 0;
+}
+
+static int bitfield_base_size(struct symbol *sym)
+{
+	if (sym->type == SYM_NODE)
+		sym = sym->ctype.base_type;
+	if (sym->type == SYM_BITFIELD)
+		sym = sym->ctype.base_type;
+	return sym->bit_size;
+}
+
+/*
+ * Structures are a bit more interesting to lay out
+ */
+static void lay_out_struct(struct symbol *sym, struct struct_union_info *info)
+{
+	unsigned long bit_size, align_bit_mask;
+	int base_size;
+
+	examine_symbol_type(sym);
+
+	// Unnamed bitfields do not affect alignment.
+	if (sym->ident || !is_bitfield_type(sym)) {
+		if (sym->ctype.alignment > info->max_align)
+			info->max_align = sym->ctype.alignment;
+	}
+
+	bit_size = info->bit_size;
+	base_size = sym->bit_size; 
+
+	/*
+	 * Unsized arrays cause us to not align the resulting
+	 * structure size
+	 */
+	if (base_size < 0) {
+		info->align_size = 0;
+		base_size = 0;
+	}
+
+	align_bit_mask = bytes_to_bits(sym->ctype.alignment) - 1;
+
+	/*
+	 * Bitfields have some very special rules..
+	 */
+	if (is_bitfield_type (sym)) {
+		unsigned long bit_offset = bit_size & align_bit_mask;
+		int room = bitfield_base_size(sym) - bit_offset;
+		// Zero-width fields just fill up the unit.
+		int width = base_size ? : (bit_offset ? room : 0);
+
+		if (width > room) {
+			bit_size = (bit_size + align_bit_mask) & ~align_bit_mask;
+			bit_offset = 0;
+		}
+		sym->offset = bits_to_bytes(bit_size - bit_offset);
+		sym->bit_offset = bit_offset;
+		sym->ctype.base_type->bit_offset = bit_offset;
+		info->bit_size = bit_size + width;
+		// warning (sym->pos, "bitfield: offset=%d:%d  size=:%d", sym->offset, sym->bit_offset, width);
+
+		return;
+	}
+
+	/*
+	 * Otherwise, just align it right and add it up..
+	 */
+	bit_size = (bit_size + align_bit_mask) & ~align_bit_mask;
+	sym->offset = bits_to_bytes(bit_size);
+
+	info->bit_size = bit_size + base_size;
+	// warning (sym->pos, "regular: offset=%d", sym->offset);
+}
+
+static struct symbol * examine_struct_union_type(struct symbol *sym, int advance)
+{
+	struct struct_union_info info = {
+		.max_align = 1,
+		.bit_size = 0,
+		.align_size = 1
+	};
+	unsigned long bit_size, bit_align;
+	void (*fn)(struct symbol *, struct struct_union_info *);
+	struct symbol *member;
+
+	fn = advance ? lay_out_struct : lay_out_union;
+	FOR_EACH_PTR(sym->symbol_list, member) {
+		fn(member, &info);
+	} END_FOR_EACH_PTR(member);
+
+	if (!sym->ctype.alignment)
+		sym->ctype.alignment = info.max_align;
+	bit_size = info.bit_size;
+	if (info.align_size) {
+		bit_align = bytes_to_bits(sym->ctype.alignment)-1;
+		bit_size = (bit_size + bit_align) & ~bit_align;
+	}
+	sym->bit_size = bit_size;
+	return sym;
+}
+
+static struct symbol *examine_base_type(struct symbol *sym)
+{
+	struct symbol *base_type;
+
+	/* Check the base type */
+	base_type = examine_symbol_type(sym->ctype.base_type);
+	if (!base_type || base_type->type == SYM_PTR)
+		return base_type;
+	sym->ctype.as |= base_type->ctype.as;
+	sym->ctype.modifiers |= base_type->ctype.modifiers & MOD_PTRINHERIT;
+	concat_ptr_list((struct ptr_list *)base_type->ctype.contexts,
+			(struct ptr_list **)&sym->ctype.contexts);
+	if (base_type->type == SYM_NODE) {
+		base_type = base_type->ctype.base_type;
+		sym->ctype.base_type = base_type;
+	}
+	return base_type;
+}
+
+static struct symbol * examine_array_type(struct symbol *sym)
+{
+	struct symbol *base_type = examine_base_type(sym);
+	unsigned long bit_size = -1, alignment;
+	struct expression *array_size = sym->array_size;
+
+	if (!base_type)
+		return sym;
+
+	if (array_size) {	
+		bit_size = array_element_offset(base_type->bit_size,
+						get_expression_value_silent(array_size));
+		if (array_size->type != EXPR_VALUE) {
+			if (Wvla)
+				warning(array_size->pos, "Variable length array is used.");
+			bit_size = -1;
+		}
+	}
+	alignment = base_type->ctype.alignment;
+	if (!sym->ctype.alignment)
+		sym->ctype.alignment = alignment;
+	sym->bit_size = bit_size;
+	return sym;
+}
+
+static struct symbol *examine_bitfield_type(struct symbol *sym)
+{
+	struct symbol *base_type = examine_base_type(sym);
+	unsigned long bit_size, alignment, modifiers;
+
+	if (!base_type)
+		return sym;
+	bit_size = base_type->bit_size;
+	if (sym->bit_size > bit_size)
+		warning(sym->pos, "impossible field-width, %d, for this type",  sym->bit_size);
+
+	alignment = base_type->ctype.alignment;
+	if (!sym->ctype.alignment)
+		sym->ctype.alignment = alignment;
+	modifiers = base_type->ctype.modifiers;
+
+	/* Bitfields are unsigned, unless the base type was explicitly signed */
+	if (!(modifiers & MOD_EXPLICITLY_SIGNED))
+		modifiers = (modifiers & ~MOD_SIGNED) | MOD_UNSIGNED;
+	sym->ctype.modifiers |= modifiers & MOD_SIGNEDNESS;
+	return sym;
+}
+
+/*
+ * "typeof" will have to merge the types together
+ */
+void merge_type(struct symbol *sym, struct symbol *base_type)
+{
+	sym->ctype.as |= base_type->ctype.as;
+	sym->ctype.modifiers |= (base_type->ctype.modifiers & ~MOD_STORAGE);
+	concat_ptr_list((struct ptr_list *)base_type->ctype.contexts,
+	                (struct ptr_list **)&sym->ctype.contexts);
+	sym->ctype.base_type = base_type->ctype.base_type;
+	if (sym->ctype.base_type->type == SYM_NODE)
+		merge_type(sym, sym->ctype.base_type);
+}
+
+static int count_array_initializer(struct symbol *t, struct expression *expr)
+{
+	int nr = 0;
+	int is_char = 0;
+
+	/*
+	 * Arrays of character types are special; they can be initialized by
+	 * string literal _or_ by string literal in braces.  The latter means
+	 * that with T x[] = {<string literal>} number of elements in x depends
+	 * on T - if it's a character type, we get the length of string literal
+	 * (including NUL), otherwise we have one element here.
+	 */
+	if (t->ctype.base_type == &int_type && t->ctype.modifiers & MOD_CHAR)
+		is_char = 1;
+
+	switch (expr->type) {
+	case EXPR_INITIALIZER: {
+		struct expression *entry;
+		int count = 0;
+		int str_len = 0;
+		FOR_EACH_PTR(expr->expr_list, entry) {
+			count++;
+			switch (entry->type) {
+			case EXPR_INDEX:
+				if (entry->idx_to >= nr)
+					nr = entry->idx_to+1;
+				break;
+			case EXPR_PREOP: {
+				struct expression *e = entry;
+				if (is_char) {
+					while (e && e->type == EXPR_PREOP && e->op == '(')
+						e = e->unop;
+					if (e && e->type == EXPR_STRING) {
+						entry = e;
+			case EXPR_STRING:
+						if (is_char)
+							str_len = entry->string->length;
+					}
+
+
+				}
+			}
+			default:
+				nr++;
+			}
+		} END_FOR_EACH_PTR(entry);
+		if (count == 1 && str_len)
+			nr = str_len;
+		break;
+	}
+	case EXPR_PREOP:
+		if (is_char) { 
+			struct expression *e = expr;
+			while (e && e->type == EXPR_PREOP && e->op == '(')
+				e = e->unop;
+			if (e && e->type == EXPR_STRING) {
+				expr = e;
+	case EXPR_STRING:
+				if (is_char)
+					nr = expr->string->length;
+			}
+		}
+		break;
+	default:
+		break;
+	}
+	return nr;
+}
+
+static struct expression *get_symbol_initializer(struct symbol *sym)
+{
+	do {
+		if (sym->initializer)
+			return sym->initializer;
+	} while ((sym = sym->same_symbol) != NULL);
+	return NULL;
+}
+
+static struct symbol * examine_node_type(struct symbol *sym)
+{
+	struct symbol *base_type = examine_base_type(sym);
+	int bit_size;
+	unsigned long alignment;
+
+	/* SYM_NODE - figure out what the type of the node was.. */
+	bit_size = 0;
+	alignment = 0;
+	if (!base_type)
+		return sym;
+
+	bit_size = base_type->bit_size;
+	alignment = base_type->ctype.alignment;
+
+	/* Pick up signedness information into the node */
+	sym->ctype.modifiers |= (MOD_SIGNEDNESS & base_type->ctype.modifiers);
+
+	if (!sym->ctype.alignment)
+		sym->ctype.alignment = alignment;
+
+	/* Unsized array? The size might come from the initializer.. */
+	if (bit_size < 0 && base_type->type == SYM_ARRAY) {
+		struct expression *initializer = get_symbol_initializer(sym);
+		if (initializer) {
+			struct symbol *node_type = base_type->ctype.base_type;
+			int count = count_array_initializer(node_type, initializer);
+
+			if (node_type && node_type->bit_size >= 0)
+				bit_size = array_element_offset(node_type->bit_size, count);
+		}
+	}
+	
+	sym->bit_size = bit_size;
+	return sym;
+}
+
+static struct symbol *examine_enum_type(struct symbol *sym)
+{
+	struct symbol *base_type = examine_base_type(sym);
+
+	sym->ctype.modifiers |= (base_type->ctype.modifiers & MOD_SIGNEDNESS);
+	sym->bit_size = bits_in_enum;
+	if (base_type->bit_size > sym->bit_size)
+		sym->bit_size = base_type->bit_size;
+	sym->ctype.alignment = enum_alignment;
+	if (base_type->ctype.alignment > sym->ctype.alignment)
+		sym->ctype.alignment = base_type->ctype.alignment;
+	return sym;
+}
+
+static struct symbol *examine_pointer_type(struct symbol *sym)
+{
+	/*
+	 * We need to set the pointer size first, and
+	 * examine the thing we point to only afterwards.
+	 * That's because this pointer type may end up
+	 * being needed for the base type size evaluation.
+	 */
+	if (!sym->bit_size)
+		sym->bit_size = bits_in_pointer;
+	if (!sym->ctype.alignment)
+		sym->ctype.alignment = pointer_alignment;
+	return sym;
+}
+
+/*
+ * Fill in type size and alignment information for
+ * regular SYM_TYPE things.
+ */
+struct symbol *examine_symbol_type(struct symbol * sym)
+{
+	if (!sym)
+		return sym;
+
+	/* Already done? */
+	if (sym->examined)
+		return sym;
+	sym->examined = 1;
+
+	switch (sym->type) {
+	case SYM_FN:
+	case SYM_NODE:
+		return examine_node_type(sym);
+	case SYM_ARRAY:
+		return examine_array_type(sym);
+	case SYM_STRUCT:
+		return examine_struct_union_type(sym, 1);
+	case SYM_UNION:
+		return examine_struct_union_type(sym, 0);
+	case SYM_PTR:
+		return examine_pointer_type(sym);
+	case SYM_ENUM:
+		return examine_enum_type(sym);
+	case SYM_BITFIELD:
+		return examine_bitfield_type(sym);
+	case SYM_BASETYPE:
+		/* Size and alignment had better already be set up */
+		return sym;
+	case SYM_TYPEOF: {
+		struct symbol *base = evaluate_expression(sym->initializer);
+		if (base) {
+			unsigned long mod = 0;
+
+			if (is_bitfield_type(base))
+				warning(base->pos, "typeof applied to bitfield type");
+			if (base->type == SYM_NODE) {
+				mod |= base->ctype.modifiers & MOD_TYPEOF;
+				base = base->ctype.base_type;
+			}
+			sym->type = SYM_NODE;
+			sym->ctype.modifiers = mod;
+			sym->ctype.base_type = base;
+			return examine_node_type(sym);
+		}
+		break;
+	}
+	case SYM_PREPROCESSOR:
+		sparse_error(sym->pos, "ctype on preprocessor command? (%s)", show_ident(sym->ident));
+		return NULL;
+	case SYM_UNINITIALIZED:
+//		sparse_error(sym->pos, "ctype on uninitialized symbol %p", sym);
+		return NULL;
+	case SYM_RESTRICT:
+		examine_base_type(sym);
+		return sym;
+	case SYM_FOULED:
+		examine_base_type(sym);
+		return sym;
+	default:
+//		sparse_error(sym->pos, "Examining unknown symbol type %d", sym->type);
+		break;
+	}
+	return sym;
+}
+
+const char* get_type_name(enum type type)
+{
+	const char *type_lookup[] = {
+	[SYM_UNINITIALIZED] = "uninitialized",
+	[SYM_PREPROCESSOR] = "preprocessor",
+	[SYM_BASETYPE] = "basetype",
+	[SYM_NODE] = "node",
+	[SYM_PTR] = "pointer",
+	[SYM_FN] = "function",
+	[SYM_ARRAY] = "array",
+	[SYM_STRUCT] = "struct",
+	[SYM_UNION] = "union",
+	[SYM_ENUM] = "enum",
+	[SYM_TYPEDEF] = "typedef",
+	[SYM_TYPEOF] = "typeof",
+	[SYM_MEMBER] = "member",
+	[SYM_BITFIELD] = "bitfield",
+	[SYM_LABEL] = "label",
+	[SYM_RESTRICT] = "restrict",
+	[SYM_FOULED] = "fouled",
+	[SYM_KEYWORD] = "keyword",
+	[SYM_BAD] = "bad"};
+
+	if (type <= SYM_BAD)
+		return type_lookup[type];
+	else
+		return NULL;
+}
+
+struct symbol *examine_pointer_target(struct symbol *sym)
+{
+	return examine_base_type(sym);
+}
+
+static struct symbol_list *restr, *fouled;
+
+void create_fouled(struct symbol *type)
+{
+	if (type->bit_size < bits_in_int) {
+		struct symbol *new = alloc_symbol(type->pos, type->type);
+		*new = *type;
+		new->bit_size = bits_in_int;
+		new->type = SYM_FOULED;
+		new->ctype.base_type = type;
+		add_symbol(&restr, type);
+		add_symbol(&fouled, new);
+	}
+}
+
+struct symbol *befoul(struct symbol *type)
+{
+	struct symbol *t1, *t2;
+	while (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	PREPARE_PTR_LIST(restr, t1);
+	PREPARE_PTR_LIST(fouled, t2);
+	for (;;) {
+		if (t1 == type)
+			return t2;
+		if (!t1)
+			break;
+		NEXT_PTR_LIST(t1);
+		NEXT_PTR_LIST(t2);
+	}
+	FINISH_PTR_LIST(t2);
+	FINISH_PTR_LIST(t1);
+	return NULL;
+}
+
+void check_declaration(struct symbol *sym)
+{
+	int warned = 0;
+	struct symbol *next = sym;
+
+	while ((next = next->next_id) != NULL) {
+		if (next->namespace != sym->namespace)
+			continue;
+		if (sym->scope == next->scope) {
+			sym->same_symbol = next;
+			return;
+		}
+		/* Extern in block level matches a TOPLEVEL non-static symbol */
+		if (sym->ctype.modifiers & MOD_EXTERN) {
+			if ((next->ctype.modifiers & (MOD_TOPLEVEL|MOD_STATIC)) == MOD_TOPLEVEL) {
+				sym->same_symbol = next;
+				return;
+			}
+		}
+
+		if (!Wshadow || warned)
+			continue;
+		if (get_sym_type(next) == SYM_FN)
+			continue;
+		warned = 1;
+		warning(sym->pos, "symbol '%s' shadows an earlier one", show_ident(sym->ident));
+		info(next->pos, "originally declared here");
+	}
+}
+
+void bind_symbol(struct symbol *sym, struct ident *ident, enum namespace ns)
+{
+	struct scope *scope;
+	if (sym->bound) {
+		sparse_error(sym->pos, "internal error: symbol type already bound");
+		return;
+	}
+	if (ident->reserved && (ns & (NS_TYPEDEF | NS_STRUCT | NS_LABEL | NS_SYMBOL))) {
+		sparse_error(sym->pos, "Trying to use reserved word '%s' as identifier", show_ident(ident));
+		return;
+	}
+	sym->namespace = ns;
+	sym->next_id = ident->symbols;
+	ident->symbols = sym;
+	if (sym->ident && sym->ident != ident)
+		warning(sym->pos, "Symbol '%s' already bound", show_ident(sym->ident));
+	sym->ident = ident;
+	sym->bound = 1;
+
+	scope = block_scope;
+	if (ns == NS_SYMBOL && toplevel(scope)) {
+		unsigned mod = MOD_ADDRESSABLE | MOD_TOPLEVEL;
+
+		scope = global_scope;
+		if (sym->ctype.modifiers & MOD_STATIC ||
+		    is_extern_inline(sym)) {
+			scope = file_scope;
+			mod = MOD_TOPLEVEL;
+		}
+		sym->ctype.modifiers |= mod;
+	}
+	if (ns == NS_MACRO)
+		scope = file_scope;
+	if (ns == NS_LABEL)
+		scope = function_scope;
+	bind_scope(sym, scope);
+}
+
+struct symbol *create_symbol(int stream, const char *name, int type, int namespace)
+{
+	struct ident *ident = built_in_ident(name);
+	struct symbol *sym = lookup_symbol(ident, namespace);
+
+	if (sym && sym->type != type)
+		die("symbol %s created with different types: %d old %d", name,
+				type, sym->type);
+
+	if (!sym) {
+		struct token *token = built_in_token(stream, ident);
+
+		sym = alloc_symbol(token->pos, type);
+		bind_symbol(sym, token->ident, namespace);
+	}
+	return sym;
+}
+
+
+/*
+ * Abstract types
+ */
+struct symbol	int_type,
+		fp_type;
+
+/*
+ * C types (i.e. actual instances that the abstract types
+ * can map onto)
+ */
+struct symbol	bool_ctype, void_ctype, type_ctype,
+		char_ctype, schar_ctype, uchar_ctype,
+		short_ctype, sshort_ctype, ushort_ctype,
+		int_ctype, sint_ctype, uint_ctype,
+		long_ctype, slong_ctype, ulong_ctype,
+		llong_ctype, sllong_ctype, ullong_ctype,
+		lllong_ctype, slllong_ctype, ulllong_ctype,
+		float_ctype, double_ctype, ldouble_ctype,
+		string_ctype, ptr_ctype, lazy_ptr_ctype,
+		incomplete_ctype, label_ctype, bad_ctype,
+		null_ctype;
+
+struct symbol	zero_int;
+
+#define __INIT_IDENT(str, res) { .len = sizeof(str)-1, .name = str, .reserved = res }
+#define __IDENT(n,str,res) \
+	struct ident n  = __INIT_IDENT(str,res)
+
+#include "ident-list.h"
+
+void init_symbols(void)
+{
+	int stream = init_stream("builtin", -1, includepath);
+
+#define __IDENT(n,str,res) \
+	hash_ident(&n)
+#include "ident-list.h"
+
+	init_parser(stream);
+	init_builtins(stream);
+}
+
+#ifdef __CHAR_UNSIGNED__
+#define CHAR_SIGNEDNESS MOD_UNSIGNED
+#else
+#define CHAR_SIGNEDNESS MOD_SIGNED
+#endif
+
+#define MOD_ESIGNED (MOD_SIGNED | MOD_EXPLICITLY_SIGNED)
+#define MOD_LL (MOD_LONG | MOD_LONGLONG)
+#define MOD_LLL MOD_LONGLONGLONG
+static const struct ctype_declare {
+	struct symbol *ptr;
+	enum type type;
+	unsigned long modifiers;
+	int *bit_size;
+	int *maxalign;
+	struct symbol *base_type;
+} ctype_declaration[] = {
+	{ &bool_ctype,	    SYM_BASETYPE, MOD_UNSIGNED,		    &bits_in_bool,	     &max_int_alignment, &int_type },
+	{ &void_ctype,	    SYM_BASETYPE, 0,			    NULL,	     NULL,		 NULL },
+	{ &type_ctype,	    SYM_BASETYPE, MOD_TYPE,		    NULL,		     NULL,		 NULL },
+	{ &incomplete_ctype,SYM_BASETYPE, 0,			    NULL,		     NULL,		 NULL },
+	{ &bad_ctype,	    SYM_BASETYPE, 0,			    NULL,		     NULL,		 NULL },
+
+	{ &char_ctype,	    SYM_BASETYPE, CHAR_SIGNEDNESS | MOD_CHAR,    &bits_in_char,	     &max_int_alignment, &int_type },
+	{ &schar_ctype,	    SYM_BASETYPE, MOD_ESIGNED | MOD_CHAR,   &bits_in_char,	     &max_int_alignment, &int_type },
+	{ &uchar_ctype,	    SYM_BASETYPE, MOD_UNSIGNED | MOD_CHAR,  &bits_in_char,	     &max_int_alignment, &int_type },
+	{ &short_ctype,	    SYM_BASETYPE, MOD_SIGNED | MOD_SHORT,   &bits_in_short,	     &max_int_alignment, &int_type },
+	{ &sshort_ctype,    SYM_BASETYPE, MOD_ESIGNED | MOD_SHORT,  &bits_in_short,	     &max_int_alignment, &int_type },
+	{ &ushort_ctype,    SYM_BASETYPE, MOD_UNSIGNED | MOD_SHORT, &bits_in_short,	     &max_int_alignment, &int_type },
+	{ &int_ctype,	    SYM_BASETYPE, MOD_SIGNED,		    &bits_in_int,	     &max_int_alignment, &int_type },
+	{ &sint_ctype,	    SYM_BASETYPE, MOD_ESIGNED,		    &bits_in_int,	     &max_int_alignment, &int_type },
+	{ &uint_ctype,	    SYM_BASETYPE, MOD_UNSIGNED,		    &bits_in_int,	     &max_int_alignment, &int_type },
+	{ &long_ctype,	    SYM_BASETYPE, MOD_SIGNED | MOD_LONG,    &bits_in_long,	     &max_int_alignment, &int_type },
+	{ &slong_ctype,	    SYM_BASETYPE, MOD_ESIGNED | MOD_LONG,   &bits_in_long,	     &max_int_alignment, &int_type },
+	{ &ulong_ctype,	    SYM_BASETYPE, MOD_UNSIGNED | MOD_LONG,  &bits_in_long,	     &max_int_alignment, &int_type },
+	{ &llong_ctype,	    SYM_BASETYPE, MOD_SIGNED | MOD_LL,	    &bits_in_longlong,       &max_int_alignment, &int_type },
+	{ &sllong_ctype,    SYM_BASETYPE, MOD_ESIGNED | MOD_LL,	    &bits_in_longlong,       &max_int_alignment, &int_type },
+	{ &ullong_ctype,    SYM_BASETYPE, MOD_UNSIGNED | MOD_LL,    &bits_in_longlong,       &max_int_alignment, &int_type },
+	{ &lllong_ctype,    SYM_BASETYPE, MOD_SIGNED | MOD_LLL,	    &bits_in_longlonglong,   &max_int_alignment, &int_type },
+	{ &slllong_ctype,   SYM_BASETYPE, MOD_ESIGNED | MOD_LLL,    &bits_in_longlonglong,   &max_int_alignment, &int_type },
+	{ &ulllong_ctype,   SYM_BASETYPE, MOD_UNSIGNED | MOD_LLL,   &bits_in_longlonglong,   &max_int_alignment, &int_type },
+
+	{ &float_ctype,	    SYM_BASETYPE,  0,			    &bits_in_float,          &max_fp_alignment,  &fp_type },
+	{ &double_ctype,    SYM_BASETYPE, MOD_LONG,		    &bits_in_double,         &max_fp_alignment,  &fp_type },
+	{ &ldouble_ctype,   SYM_BASETYPE, MOD_LONG | MOD_LONGLONG,  &bits_in_longdouble,     &max_fp_alignment,  &fp_type },
+
+	{ &string_ctype,    SYM_PTR,	  0,			    &bits_in_pointer,        &pointer_alignment, &char_ctype },
+	{ &ptr_ctype,	    SYM_PTR,	  0,			    &bits_in_pointer,        &pointer_alignment, &void_ctype },
+	{ &null_ctype,	    SYM_PTR,	  0,			    &bits_in_pointer,        &pointer_alignment, &void_ctype },
+	{ &label_ctype,	    SYM_PTR,	  0,			    &bits_in_pointer,        &pointer_alignment, &void_ctype },
+	{ &lazy_ptr_ctype,  SYM_PTR,	  0,			    &bits_in_pointer,        &pointer_alignment, &void_ctype },
+	{ NULL, }
+};
+#undef MOD_LLL
+#undef MOD_LL
+#undef MOD_ESIGNED
+
+void init_ctype(void)
+{
+	const struct ctype_declare *ctype;
+
+	for (ctype = ctype_declaration ; ctype->ptr; ctype++) {
+		struct symbol *sym = ctype->ptr;
+		unsigned long bit_size = ctype->bit_size ? *ctype->bit_size : -1;
+		unsigned long maxalign = ctype->maxalign ? *ctype->maxalign : 0;
+		unsigned long alignment = bits_to_bytes(bit_size);
+
+		if (alignment > maxalign)
+			alignment = maxalign;
+		sym->type = ctype->type;
+		sym->bit_size = bit_size;
+		sym->ctype.alignment = alignment;
+		sym->ctype.base_type = ctype->base_type;
+		sym->ctype.modifiers = ctype->modifiers;
+	}
+}
diff --git a/usr/src/tools/smatch/src/symbol.h b/usr/src/tools/smatch/src/symbol.h
new file mode 100644
index 0000000000..88959603c8
--- /dev/null
+++ b/usr/src/tools/smatch/src/symbol.h
@@ -0,0 +1,448 @@
+#ifndef SYMBOL_H
+#define SYMBOL_H
+/*
+ * Basic symbol and namespace definitions.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "token.h"
+#include "target.h"
+
+/*
+ * An identifier with semantic meaning is a "symbol".
+ *
+ * There's a 1:n relationship: each symbol is always
+ * associated with one identifier, while each identifier
+ * can have one or more semantic meanings due to C scope
+ * rules.
+ *
+ * The progression is symbol -> token -> identifier. The
+ * token contains the information on where the symbol was
+ * declared.
+ */
+enum namespace {
+	NS_NONE = 0,
+	NS_MACRO = 1,
+	NS_TYPEDEF = 2,
+	NS_STRUCT = 4,  // Also used for unions and enums.
+	NS_LABEL = 8,
+	NS_SYMBOL = 16,
+	NS_ITERATOR = 32,
+	NS_PREPROCESSOR = 64,
+	NS_UNDEF = 128,
+	NS_KEYWORD = 256,
+};
+
+enum type {
+	SYM_UNINITIALIZED,
+	SYM_PREPROCESSOR,
+	SYM_BASETYPE,
+	SYM_NODE,
+	SYM_PTR,
+	SYM_FN,
+	SYM_ARRAY,
+	SYM_STRUCT,
+	SYM_UNION,
+	SYM_ENUM,
+	SYM_TYPEDEF,
+	SYM_TYPEOF,
+	SYM_MEMBER,
+	SYM_BITFIELD,
+	SYM_LABEL,
+	SYM_RESTRICT,
+	SYM_FOULED,
+	SYM_KEYWORD,
+	SYM_BAD,
+};
+
+enum keyword {
+	KW_SPECIFIER 	= 1 << 0,
+	KW_MODIFIER	= 1 << 1,
+	KW_QUALIFIER	= 1 << 2,
+	KW_ATTRIBUTE	= 1 << 3,
+	KW_STATEMENT	= 1 << 4,
+	KW_ASM		= 1 << 5,
+	KW_MODE		= 1 << 6,
+	KW_SHORT	= 1 << 7,
+	KW_LONG		= 1 << 8,
+	KW_EXACT	= 1 << 9,
+};
+
+struct context {
+	struct expression *context;
+	unsigned int in, out;
+};
+
+extern struct context *alloc_context(void);
+
+DECLARE_PTR_LIST(context_list, struct context);
+
+struct ctype {
+	unsigned long modifiers;
+	unsigned long alignment;
+	struct context_list *contexts;
+	unsigned int as;
+	struct symbol *base_type;
+};
+
+struct decl_state {
+	struct ctype ctype;
+	struct ident **ident;
+	struct symbol_op *mode;
+	unsigned char prefer_abstract, is_inline, storage_class, is_tls;
+};
+
+struct symbol_op {
+	enum keyword type;
+	int (*evaluate)(struct expression *);
+	int (*expand)(struct expression *, int);
+	int (*args)(struct expression *);
+
+	/* keywords */
+	struct token *(*declarator)(struct token *token, struct decl_state *ctx);
+	struct token *(*statement)(struct token *token, struct statement *stmt);
+	struct token *(*toplevel)(struct token *token, struct symbol_list **list);
+	struct token *(*attribute)(struct token *token, struct symbol *attr, struct decl_state *ctx);
+	struct symbol *(*to_mode)(struct symbol *);
+
+	int test, set, class;
+};
+
+
+#define SYM_ATTR_WEAK		0
+#define SYM_ATTR_NORMAL		1
+#define SYM_ATTR_STRONG		2
+
+struct symbol {
+	enum type type:8;
+	enum namespace namespace:9;
+	unsigned char used:1, attr:2, enum_member:1, bound:1;
+	struct position pos;		/* Where this symbol was declared */
+	struct position endpos;		/* Where this symbol ends*/
+	struct ident *ident;		/* What identifier this symbol is associated with */
+	struct symbol *next_id;		/* Next semantic symbol that shares this identifier */
+	struct symbol	*replace;	/* What is this symbol shadowed by in copy-expression */
+	struct scope	*scope;
+	union {
+		struct symbol	*same_symbol;
+		struct symbol	*next_subobject;
+	};
+
+	struct symbol_op *op;
+
+	union {
+		struct /* NS_MACRO */ {
+			struct token *expansion;
+			struct token *arglist;
+			struct scope *used_in;
+		};
+		struct /* NS_PREPROCESSOR */ {
+			int (*handler)(struct stream *, struct token **, struct token *);
+			int normal;
+		};
+		struct /* NS_SYMBOL */ {
+			unsigned long	offset;
+			int		bit_size;
+			unsigned int	bit_offset:8,
+					arg_count:10,
+					variadic:1,
+					initialized:1,
+					examined:1,
+					expanding:1,
+					evaluated:1,
+					string:1,
+					designated_init:1,
+					forced_arg:1,
+					transparent_union:1;
+			struct expression *array_size;
+			struct ctype ctype;
+			struct symbol_list *arguments;
+			struct statement *stmt;
+			struct symbol_list *symbol_list;
+			struct statement *inline_stmt;
+			struct symbol_list *inline_symbol_list;
+			struct expression *initializer;
+			struct entrypoint *ep;
+			long long value;		/* Initial value */
+			struct symbol *definition;
+		};
+	};
+	union /* backend */ {
+		struct basic_block *bb_target;	/* label */
+		void *aux;			/* Auxiliary info, e.g. backend information */
+		struct {			/* sparse ctags */
+			char kind;
+			unsigned char visited:1;
+		};
+	};
+	pseudo_t pseudo;
+};
+
+/* Modifiers */
+#define MOD_AUTO	0x0001
+#define MOD_REGISTER	0x0002
+#define MOD_STATIC	0x0004
+#define MOD_EXTERN	0x0008
+
+#define MOD_CONST	0x0010
+#define MOD_VOLATILE	0x0020
+#define MOD_SIGNED	0x0040
+#define MOD_UNSIGNED	0x0080
+
+#define MOD_CHAR	0x0100
+#define MOD_SHORT	0x0200
+#define MOD_LONG	0x0400
+#define MOD_LONGLONG	0x0800
+#define MOD_LONGLONGLONG	0x1000
+#define MOD_PURE	0x2000
+
+#define MOD_TYPEDEF	0x10000
+
+#define MOD_TLS		0x20000
+#define MOD_INLINE	0x40000
+#define MOD_ADDRESSABLE	0x80000
+
+#define MOD_NOCAST	0x100000
+#define MOD_NODEREF	0x200000
+#define MOD_ACCESSED	0x400000
+#define MOD_TOPLEVEL	0x800000	// scoping..
+
+#define MOD_ASSIGNED	0x2000000
+#define MOD_TYPE	0x4000000
+#define MOD_SAFE	0x8000000	// non-null/non-trapping pointer
+
+#define MOD_USERTYPE	0x10000000
+#define MOD_NORETURN	0x20000000
+#define MOD_EXPLICITLY_SIGNED	0x40000000
+#define MOD_BITWISE	0x80000000
+
+
+#define MOD_NONLOCAL	(MOD_EXTERN | MOD_TOPLEVEL)
+#define MOD_STORAGE	(MOD_AUTO | MOD_REGISTER | MOD_STATIC | MOD_EXTERN | MOD_INLINE | MOD_TOPLEVEL)
+#define MOD_SIGNEDNESS	(MOD_SIGNED | MOD_UNSIGNED | MOD_EXPLICITLY_SIGNED)
+#define MOD_LONG_ALL	(MOD_LONG | MOD_LONGLONG | MOD_LONGLONGLONG)
+#define MOD_SPECIFIER	(MOD_CHAR | MOD_SHORT | MOD_LONG_ALL | MOD_SIGNEDNESS)
+#define MOD_SIZE	(MOD_CHAR | MOD_SHORT | MOD_LONG_ALL)
+#define MOD_IGNORE (MOD_TOPLEVEL | MOD_STORAGE | MOD_ADDRESSABLE |	\
+	MOD_ASSIGNED | MOD_USERTYPE | MOD_ACCESSED | MOD_EXPLICITLY_SIGNED)
+#define MOD_PTRINHERIT (MOD_VOLATILE | MOD_CONST | MOD_NODEREF | MOD_NORETURN | MOD_NOCAST)
+/* modifiers preserved by typeof() operator */
+#define MOD_TYPEOF	(MOD_VOLATILE | MOD_CONST | MOD_NOCAST | MOD_SPECIFIER)
+
+
+/* Current parsing/evaluation function */
+extern struct symbol *current_fn;
+
+/* Abstract types */
+extern struct symbol	int_type,
+			fp_type;
+
+/* C types */
+extern struct symbol	bool_ctype, void_ctype, type_ctype,
+			char_ctype, schar_ctype, uchar_ctype,
+			short_ctype, sshort_ctype, ushort_ctype,
+			int_ctype, sint_ctype, uint_ctype,
+			long_ctype, slong_ctype, ulong_ctype,
+			llong_ctype, sllong_ctype, ullong_ctype,
+			lllong_ctype, slllong_ctype, ulllong_ctype,
+			float_ctype, double_ctype, ldouble_ctype,
+			string_ctype, ptr_ctype, lazy_ptr_ctype,
+			incomplete_ctype, label_ctype, bad_ctype,
+			null_ctype;
+
+/* Special internal symbols */
+extern struct symbol	zero_int;
+
+#define __IDENT(n,str,res) \
+	extern struct ident n
+#include "ident-list.h"
+
+#define symbol_is_typename(sym) ((sym)->type == SYM_TYPE)
+
+extern struct symbol_list *translation_unit_used_list;
+
+extern void access_symbol(struct symbol *);
+
+extern const char * type_difference(struct ctype *c1, struct ctype *c2,
+	unsigned long mod1, unsigned long mod2);
+
+extern struct symbol *lookup_symbol(struct ident *, enum namespace);
+extern struct symbol *create_symbol(int stream, const char *name, int type, int namespace);
+extern void init_symbols(void);
+extern void init_builtins(int stream);
+extern void init_ctype(void);
+extern struct symbol *alloc_symbol(struct position, int type);
+extern void show_type(struct symbol *);
+extern const char *modifier_string(unsigned long mod);
+extern void show_symbol(struct symbol *);
+extern int show_symbol_expr_init(struct symbol *sym);
+extern void show_type_list(struct symbol *);
+extern void show_symbol_list(struct symbol_list *, const char *);
+extern void add_symbol(struct symbol_list **, struct symbol *);
+extern void bind_symbol(struct symbol *, struct ident *, enum namespace);
+
+extern struct symbol *examine_symbol_type(struct symbol *);
+extern struct symbol *examine_pointer_target(struct symbol *);
+extern void examine_simple_symbol_type(struct symbol *);
+extern const char *show_typename(struct symbol *sym);
+extern const char *builtin_typename(struct symbol *sym);
+extern const char *builtin_ctypename(struct ctype *ctype);
+extern const char* get_type_name(enum type type);
+
+extern void debug_symbol(struct symbol *);
+extern void merge_type(struct symbol *sym, struct symbol *base_type);
+extern void check_declaration(struct symbol *sym);
+
+static inline struct symbol *get_base_type(const struct symbol *sym)
+{
+	return examine_symbol_type(sym->ctype.base_type);
+}
+
+static inline int is_int_type(const struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	if (type->type == SYM_ENUM)
+		type = type->ctype.base_type;
+	return type->type == SYM_BITFIELD ||
+	       type->ctype.base_type == &int_type;
+}
+
+static inline int is_enum_type(const struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	return (type->type == SYM_ENUM);
+}
+
+static inline int is_type_type(struct symbol *type)
+{
+	return (type->ctype.modifiers & MOD_TYPE) != 0;
+}
+
+static inline int is_ptr_type(struct symbol *type)
+{
+	if (!type)
+		return 0;
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	return type->type == SYM_PTR || type->type == SYM_ARRAY || type->type == SYM_FN;
+}
+
+static inline int is_func_type(struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	return type->type == SYM_FN;
+}
+
+static inline int is_array_type(struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	return type->type == SYM_ARRAY;
+}
+
+static inline int is_float_type(struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	return type->ctype.base_type == &fp_type;
+}
+
+static inline int is_byte_type(struct symbol *type)
+{
+	return type->bit_size == bits_in_char && type->type != SYM_BITFIELD;
+}
+
+static inline int is_void_type(struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	return type == &void_ctype;
+}
+
+static inline int is_bool_type(struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	return type == &bool_ctype;
+}
+
+static inline int is_scalar_type(struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	switch (type->type) {
+	case SYM_ENUM:
+	case SYM_BITFIELD:
+	case SYM_PTR:
+	case SYM_RESTRICT:	// OK, always integer types
+		return 1;
+	default:
+		break;
+	}
+	if (type->ctype.base_type == &int_type)
+		return 1;
+	if (type->ctype.base_type == &fp_type)
+		return 1;
+	return 0;
+}
+
+static inline int is_function(struct symbol *type)
+{
+	return type && type->type == SYM_FN;
+}
+
+static inline int is_extern_inline(struct symbol *sym)
+{
+	return (sym->ctype.modifiers & MOD_EXTERN) &&
+		(sym->ctype.modifiers & MOD_INLINE) &&
+		is_function(sym->ctype.base_type);
+}
+
+static inline int get_sym_type(struct symbol *type)
+{
+	if (type->type == SYM_NODE)
+		type = type->ctype.base_type;
+	if (type->type == SYM_ENUM)
+		type = type->ctype.base_type;
+	return type->type;
+}
+
+static inline struct symbol *lookup_keyword(struct ident *ident, enum namespace ns)
+{
+	if (!ident->keyword)
+		return NULL;
+	return lookup_symbol(ident, ns);
+}
+
+#define is_restricted_type(type) (get_sym_type(type) == SYM_RESTRICT)
+#define is_fouled_type(type) (get_sym_type(type) == SYM_FOULED)
+#define is_bitfield_type(type)   (get_sym_type(type) == SYM_BITFIELD)
+extern int is_ptr_type(struct symbol *);
+
+void create_fouled(struct symbol *type);
+struct symbol *befoul(struct symbol *type);
+
+#endif /* SYMBOL_H */
diff --git a/usr/src/tools/smatch/src/target.c b/usr/src/tools/smatch/src/target.c
new file mode 100644
index 0000000000..40a9bf1eac
--- /dev/null
+++ b/usr/src/tools/smatch/src/target.c
@@ -0,0 +1,48 @@
+#include <stdio.h>
+
+#include "symbol.h"
+#include "target.h"
+
+struct symbol *size_t_ctype = &ulong_ctype;
+struct symbol *ssize_t_ctype = &long_ctype;
+
+/*
+ * For "__attribute__((aligned))"
+ */
+int max_alignment = 16;
+
+/*
+ * Integer data types
+ */
+int bits_in_bool = 1;
+int bits_in_char = 8;
+int bits_in_short = 16;
+int bits_in_int = 32;
+int bits_in_long = 32;
+int bits_in_longlong = 64;
+int bits_in_longlonglong = 128;
+
+int bits_in_wchar = 32;
+
+int max_int_alignment = 4;
+
+/*
+ * Floating point data types
+ */
+int bits_in_float = 32;
+int bits_in_double = 64;
+int bits_in_longdouble = 80;
+
+int max_fp_alignment = 8;
+
+/*
+ * Pointer data type
+ */
+int bits_in_pointer = 32;
+int pointer_alignment = 4;
+
+/*
+ * Enum data types
+ */
+int bits_in_enum = 32;
+int enum_alignment = 4;
diff --git a/usr/src/tools/smatch/src/target.h b/usr/src/tools/smatch/src/target.h
new file mode 100644
index 0000000000..8326fa21a4
--- /dev/null
+++ b/usr/src/tools/smatch/src/target.h
@@ -0,0 +1,70 @@
+#ifndef TARGET_H
+#define TARGET_H
+
+extern struct symbol *size_t_ctype;
+extern struct symbol *ssize_t_ctype;
+
+/*
+ * For "__attribute__((aligned))"
+ */
+extern int max_alignment;
+
+/*
+ * Integer data types
+ */
+extern int bits_in_bool;
+extern int bits_in_char;
+extern int bits_in_short;
+extern int bits_in_int;
+extern int bits_in_long;
+extern int bits_in_longlong;
+extern int bits_in_longlonglong;
+
+extern int bits_in_wchar;
+
+extern int max_int_alignment;
+
+/*
+ * Floating point data types
+ */
+extern int bits_in_float;
+extern int bits_in_double;
+extern int bits_in_longdouble;
+
+extern int max_fp_alignment;
+
+/*
+ * Pointer data type
+ */
+extern int bits_in_pointer;
+extern int pointer_alignment;
+
+/*
+ * Enum data types
+ */
+extern int bits_in_enum;
+extern int enum_alignment;
+
+/*
+ * Helper functions for converting bits to bytes and vice versa.
+ */
+
+static inline int bits_to_bytes(int bits)
+{
+	return bits >= 0 ? (bits + bits_in_char - 1) / bits_in_char : -1;
+}
+
+static inline int bytes_to_bits(int bytes)
+{
+	return bytes * bits_in_char;
+}
+
+static inline unsigned long array_element_offset(unsigned long base_bits, int idx)
+{
+	int fragment = base_bits % bits_in_char;
+	if (fragment)
+		base_bits += bits_in_char - fragment;
+	return base_bits * idx;
+}
+
+#endif
diff --git a/usr/src/tools/smatch/src/test-dissect.c b/usr/src/tools/smatch/src/test-dissect.c
new file mode 100644
index 0000000000..862318f81a
--- /dev/null
+++ b/usr/src/tools/smatch/src/test-dissect.c
@@ -0,0 +1,97 @@
+#include "dissect.h"
+
+static unsigned dotc_stream;
+
+static inline char storage(struct symbol *sym)
+{
+	int t = sym->type;
+	unsigned m = sym->ctype.modifiers;
+
+	if (m & MOD_INLINE || t == SYM_STRUCT || t == SYM_UNION /*|| t == SYM_ENUM*/)
+		return sym->pos.stream == dotc_stream ? 's' : 'g';
+
+	return (m & MOD_STATIC) ? 's' : (m & MOD_NONLOCAL) ? 'g' : 'l';
+}
+
+static inline const char *show_mode(unsigned mode)
+{
+	static char str[3];
+
+	if (mode == -1)
+		return "def";
+
+#define	U(u_r)	"-rwm"[(mode / u_r) & 3]
+	str[0] = U(U_R_AOF);
+	str[1] = U(U_R_VAL);
+	str[2] = U(U_R_PTR);
+#undef	U
+
+	return str;
+}
+
+static void print_usage(struct position *pos, struct symbol *sym, unsigned mode)
+{
+	static unsigned curr_stream = -1;
+
+	if (curr_stream != pos->stream) {
+		curr_stream = pos->stream;
+		printf("\nFILE: %s\n\n", stream_name(curr_stream));
+	}
+
+	printf("%4d:%-3d %c %-5.3s",
+		pos->line, pos->pos, storage(sym), show_mode(mode));
+}
+
+static void r_symbol(unsigned mode, struct position *pos, struct symbol *sym)
+{
+	print_usage(pos, sym, mode);
+
+	if (!sym->ident)
+		sym->ident = built_in_ident("__asm__");
+
+	printf("%-32.*s %s\n",
+		sym->ident->len, sym->ident->name,
+		show_typename(sym->ctype.base_type));
+}
+
+static void r_member(unsigned mode, struct position *pos, struct symbol *sym, struct symbol *mem)
+{
+	struct ident *ni, *si, *mi;
+
+	print_usage(pos, sym, mode);
+
+	ni = built_in_ident("?");
+	si = sym->ident ?: ni;
+	/* mem == NULL means entire struct accessed */
+	mi = mem ? (mem->ident ?: ni) : built_in_ident("*");
+
+	printf("%.*s.%-*.*s %s\n",
+		si->len, si->name,
+		32-1 - si->len, mi->len, mi->name,
+		show_typename(mem ? mem->ctype.base_type : sym));
+}
+
+static void r_symdef(struct symbol *sym)
+{
+	r_symbol(-1, &sym->pos, sym);
+}
+
+int main(int argc, char **argv)
+{
+	static struct reporter reporter = {
+		.r_symdef = r_symdef,
+		.r_symbol = r_symbol,
+		.r_member = r_member,
+	};
+	struct string_list *filelist = NULL;
+	char *file;
+
+	sparse_initialize(argc, argv, &filelist);
+
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		dotc_stream = input_stream_nr;
+		dissect(__sparse(file), &reporter);
+	} END_FOR_EACH_PTR_NOTAG(file);
+
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/test-inspect.c b/usr/src/tools/smatch/src/test-inspect.c
new file mode 100644
index 0000000000..e437e11242
--- /dev/null
+++ b/usr/src/tools/smatch/src/test-inspect.c
@@ -0,0 +1,43 @@
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+
+#include "ast-view.h"
+
+static void expand_symbols(struct symbol_list *list)
+{
+	struct symbol *sym;
+	FOR_EACH_PTR(list, sym) {
+		expand_symbol(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	char *file;
+	struct symbol_list *view_syms = NULL;
+
+	gtk_init(&argc,&argv);
+	expand_symbols(sparse_initialize(argc, argv, &filelist));
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		struct symbol_list *syms = sparse(file);
+		expand_symbols(syms);
+		concat_symbol_list(syms, &view_syms);
+	} END_FOR_EACH_PTR_NOTAG(file);
+	treeview_main(view_syms);
+	return 0;
+}
+ 
diff --git a/usr/src/tools/smatch/src/test-lexing.c b/usr/src/tools/smatch/src/test-lexing.c
new file mode 100644
index 0000000000..5c7ab2adfc
--- /dev/null
+++ b/usr/src/tools/smatch/src/test-lexing.c
@@ -0,0 +1,49 @@
+/*
+ * Example test program that just uses the tokenization and
+ * preprocessing phases, and prints out the results.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "token.h"
+#include "symbol.h"
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	char *file;
+
+	preprocess_only = 1;
+	sparse_initialize(argc, argv, &filelist);
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		sparse(file);
+	} END_FOR_EACH_PTR_NOTAG(file);
+	show_identifier_stats();
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/test-linearize.c b/usr/src/tools/smatch/src/test-linearize.c
new file mode 100644
index 0000000000..fe0673befa
--- /dev/null
+++ b/usr/src/tools/smatch/src/test-linearize.c
@@ -0,0 +1,67 @@
+/*
+ * Parse and linearize the tree for testing.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003-2004 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+#include "linearize.h"
+
+static void clean_up_symbols(struct symbol_list *list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		struct entrypoint *ep;
+
+		expand_symbol(sym);
+		ep = linearize_symbol(sym);
+		if (ep)
+			show_entry(ep);
+	} END_FOR_EACH_PTR(sym);
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list *filelist = NULL;
+	char *file;
+
+	clean_up_symbols(sparse_initialize(argc, argv, &filelist));
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		clean_up_symbols(sparse(file));
+	} END_FOR_EACH_PTR_NOTAG(file);
+
+	report_stats();
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/test-parsing.c b/usr/src/tools/smatch/src/test-parsing.c
new file mode 100644
index 0000000000..7642205af3
--- /dev/null
+++ b/usr/src/tools/smatch/src/test-parsing.c
@@ -0,0 +1,91 @@
+/*
+ * Example trivial client program that uses the sparse library
+ * to tokenize, preprocess and parse a C file, and prints out
+ * the results.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+
+static void clean_up_symbols(struct symbol_list *list)
+{
+	struct symbol *sym;
+
+	FOR_EACH_PTR(list, sym) {
+		expand_symbol(sym);
+	} END_FOR_EACH_PTR(sym);
+}
+
+int main(int argc, char **argv)
+{
+	struct symbol_list * list;
+	struct string_list * filelist = NULL;
+	char *file;
+
+	list = sparse_initialize(argc, argv, &filelist);
+
+	// Simplification
+	clean_up_symbols(list);
+
+#if 1
+	show_symbol_list(list, "\n\n");
+	printf("\n\n");
+#endif
+
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		list = sparse(file);
+
+		// Simplification
+		clean_up_symbols(list);
+
+#if 1
+		// Show the end result.
+		show_symbol_list(list, "\n\n");
+		printf("\n\n");
+#endif
+	} END_FOR_EACH_PTR_NOTAG(file);
+
+#if 0
+	// And show the allocation statistics
+	show_ident_alloc();
+	show_token_alloc();
+	show_symbol_alloc();
+	show_expression_alloc();
+	show_statement_alloc();
+	show_string_alloc();
+	show_bytes_alloc();
+#endif
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/test-sort.c b/usr/src/tools/smatch/src/test-sort.c
new file mode 100644
index 0000000000..5f176769bb
--- /dev/null
+++ b/usr/src/tools/smatch/src/test-sort.c
@@ -0,0 +1,46 @@
+#include "lib.h"
+#include "allocate.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+static int
+int_cmp (const void *_a, const void *_b)
+{
+  const int *a = _a;
+  const int *b = _b;
+  return *a - *b;
+}
+
+#define MIN(_x,_y) ((_x) < (_y) ? (_x) : (_y))
+
+int
+main (int argc, char **argv)
+{
+  struct ptr_list *l = NULL, *l2;
+  int i, *e;
+  const int N = argv[1] ? atoi (argv[1]) : 10000;
+
+  srand (N);
+  for (i = 0; i < 1000; i++)
+    (void)rand ();
+
+  for (i = 0; i < N; i++) {
+    e = (int *)malloc (sizeof (int));
+    *e = rand ();
+    add_ptr_list (&l, e);
+  }
+  sort_list (&l, int_cmp);
+  // Sort already sorted stuff.
+  sort_list (&l, int_cmp);
+
+  l2 = l;
+  do {
+    l2->nr = MIN (l2->nr, rand () % 3);
+    for (i = 0; i < l2->nr; i++)
+      *((int *)(l2->list[i])) = rand();
+    l2 = l2->next;
+  } while (l2 != l);
+  sort_list (&l, int_cmp);
+
+  return 0;
+}
diff --git a/usr/src/tools/smatch/src/test-unssa.c b/usr/src/tools/smatch/src/test-unssa.c
new file mode 100644
index 0000000000..240d996016
--- /dev/null
+++ b/usr/src/tools/smatch/src/test-unssa.c
@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <assert.h>
+
+#include "symbol.h"
+#include "expression.h"
+#include "linearize.h"
+#include "flow.h"
+
+
+static void output_bb(struct basic_block *bb, unsigned long generation)
+{
+	struct instruction *insn;
+
+	bb->generation = generation;
+	printf(".L%u\n", bb->nr);
+
+	FOR_EACH_PTR(bb->insns, insn) {
+		if (!insn->bb)
+			continue;
+		printf("\t%s\n", show_instruction(insn));
+	}
+	END_FOR_EACH_PTR(insn);
+
+	printf("\n");
+}
+
+static void output_fn(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+	unsigned long generation = ++bb_generation;
+	struct symbol *sym = ep->name;
+	const char *name = show_ident(sym->ident);
+
+	if (sym->ctype.modifiers & MOD_STATIC)
+		printf("\n\n%s:\n", name);
+	else
+		printf("\n\n.globl %s\n%s:\n", name, name);
+
+	unssa(ep);
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		if (bb->generation == generation)
+			continue;
+		output_bb(bb, generation);
+	}
+	END_FOR_EACH_PTR(bb);
+}
+
+static int output_data(struct symbol *sym)
+{
+	printf("symbol %s:\n", show_ident(sym->ident));
+	printf("\ttype = %d\n", sym->ctype.base_type->type);
+	printf("\tmodif= %lx\n", sym->ctype.modifiers);
+
+	return 0;
+}
+
+static int compile(struct symbol_list *list)
+{
+	struct symbol *sym;
+	FOR_EACH_PTR(list, sym) {
+		struct entrypoint *ep;
+		expand_symbol(sym);
+		ep = linearize_symbol(sym);
+		if (ep)
+			output_fn(ep);
+		else
+			output_data(sym);
+	}
+	END_FOR_EACH_PTR(sym);
+
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	struct string_list * filelist = NULL;
+	char *file;
+
+	compile(sparse_initialize(argc, argv, &filelist));
+	FOR_EACH_PTR_NOTAG(filelist, file) {
+		compile(sparse(file));
+	} END_FOR_EACH_PTR_NOTAG(file);
+
+	report_stats();
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/token.h b/usr/src/tools/smatch/src/token.h
new file mode 100644
index 0000000000..3644613f58
--- /dev/null
+++ b/usr/src/tools/smatch/src/token.h
@@ -0,0 +1,252 @@
+#ifndef TOKEN_H
+#define TOKEN_H
+/*
+ * Basic tokenization structures. NOTE! Those tokens had better
+ * be pretty small, since we're going to keep them all in memory
+ * indefinitely.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include "lib.h"
+
+/*
+ * This describes the pure lexical elements (tokens), with
+ * no semantic meaning. In other words, an identifier doesn't
+ * have a type or meaning, it is only a specific string in
+ * the input stream.
+ *
+ * Semantic meaning is handled elsewhere.
+ */
+
+enum constantfile {
+  CONSTANT_FILE_MAYBE,    // To be determined, not inside any #ifs in this file
+  CONSTANT_FILE_IFNDEF,   // To be determined, currently inside #ifndef
+  CONSTANT_FILE_NOPE,     // No
+  CONSTANT_FILE_YES       // Yes
+};
+
+extern const char *includepath[];
+
+struct stream {
+	int fd;
+	const char *name;
+	const char *path;    // input-file path - see set_stream_include_path()
+	const char **next_path;
+
+	/* Use these to check for "already parsed" */
+	enum constantfile constant;
+	int dirty, next_stream, once;
+	struct ident *protect;
+	struct token *ifndef;
+	struct token *top_if;
+};
+
+extern int input_stream_nr;
+extern struct stream *input_streams;
+extern unsigned int tabstop;
+extern int no_lineno;
+extern int *hash_stream(const char *name);
+
+struct ident {
+	struct ident *next;	/* Hash chain of identifiers */
+	struct symbol *symbols;	/* Pointer to semantic meaning list */
+	unsigned char len;	/* Length of identifier name */
+	unsigned char tainted:1,
+	              reserved:1,
+		      keyword:1;
+	char name[];		/* Actual identifier */
+};
+
+enum token_type {
+	TOKEN_EOF,
+	TOKEN_ERROR,
+	TOKEN_IDENT,
+	TOKEN_ZERO_IDENT,
+	TOKEN_NUMBER,
+	TOKEN_CHAR,
+	TOKEN_CHAR_EMBEDDED_0,
+	TOKEN_CHAR_EMBEDDED_1,
+	TOKEN_CHAR_EMBEDDED_2,
+	TOKEN_CHAR_EMBEDDED_3,
+	TOKEN_WIDE_CHAR,
+	TOKEN_WIDE_CHAR_EMBEDDED_0,
+	TOKEN_WIDE_CHAR_EMBEDDED_1,
+	TOKEN_WIDE_CHAR_EMBEDDED_2,
+	TOKEN_WIDE_CHAR_EMBEDDED_3,
+	TOKEN_STRING,
+	TOKEN_WIDE_STRING,
+	TOKEN_SPECIAL,
+	TOKEN_STREAMBEGIN,
+	TOKEN_STREAMEND,
+	TOKEN_MACRO_ARGUMENT,
+	TOKEN_STR_ARGUMENT,
+	TOKEN_QUOTED_ARGUMENT,
+	TOKEN_CONCAT,
+	TOKEN_GNU_KLUDGE,
+	TOKEN_UNTAINT,
+	TOKEN_ARG_COUNT,
+	TOKEN_IF,
+	TOKEN_SKIP_GROUPS,
+	TOKEN_ELSE,
+};
+
+/* Combination tokens */
+#define COMBINATION_STRINGS {	\
+	"+=", "++",		\
+	"-=", "--", "->",	\
+	"*=",			\
+	"/=",			\
+	"%=",			\
+	"<=", ">=",		\
+	"==", "!=",		\
+	"&&", "&=",		\
+	"||", "|=",		\
+	"^=", "##",		\
+	"<<", ">>", "..",	\
+	"<<=", ">>=", "...",	\
+	"",			\
+	"<", ">", "<=", ">="	\
+}
+
+extern unsigned char combinations[][4];
+
+enum special_token {
+	SPECIAL_BASE = 256,
+	SPECIAL_ADD_ASSIGN = SPECIAL_BASE,
+	SPECIAL_INCREMENT,
+	SPECIAL_SUB_ASSIGN,
+	SPECIAL_DECREMENT,
+	SPECIAL_DEREFERENCE,
+	SPECIAL_MUL_ASSIGN,
+	SPECIAL_DIV_ASSIGN,
+	SPECIAL_MOD_ASSIGN,
+	SPECIAL_LTE,
+	SPECIAL_GTE,
+	SPECIAL_EQUAL,
+	SPECIAL_NOTEQUAL,
+	SPECIAL_LOGICAL_AND,
+	SPECIAL_AND_ASSIGN,
+	SPECIAL_LOGICAL_OR,
+	SPECIAL_OR_ASSIGN,
+	SPECIAL_XOR_ASSIGN,
+	SPECIAL_HASHHASH,
+	SPECIAL_LEFTSHIFT,
+	SPECIAL_RIGHTSHIFT,
+	SPECIAL_DOTDOT,
+	SPECIAL_SHL_ASSIGN,
+	SPECIAL_SHR_ASSIGN,
+	SPECIAL_ELLIPSIS,
+	SPECIAL_ARG_SEPARATOR,
+	SPECIAL_UNSIGNED_LT,
+	SPECIAL_UNSIGNED_GT,
+	SPECIAL_UNSIGNED_LTE,
+	SPECIAL_UNSIGNED_GTE,
+};
+
+struct string {
+	unsigned int length:31;
+	unsigned int immutable:1;
+	char data[];
+};
+
+/* will fit into 32 bits */
+struct argcount {
+	unsigned normal:10;
+	unsigned quoted:10;
+	unsigned str:10;
+	unsigned vararg:1;
+};
+
+/*
+ * This is a very common data structure, it should be kept
+ * as small as humanly possible. Big (rare) types go as
+ * pointers.
+ */
+struct token {
+	struct position pos;
+	struct token *next;
+	union {
+		const char *number;
+		struct ident *ident;
+		unsigned int special;
+		struct string *string;
+		int argnum;
+		struct argcount count;
+		char embedded[4];
+	};
+};
+
+#define MAX_STRING 8191
+
+static inline struct token *containing_token(struct token **p)
+{
+	void *addr = (char *)p - ((char *)&((struct token *)0)->next - (char *)0);
+	return addr;
+}
+
+#define token_type(x) ((x)->pos.type)
+
+/*
+ * Last token in the stream - points to itself.
+ * This allows us to not test for NULL pointers
+ * when following the token->next chain..
+ */
+extern struct token eof_token_entry;
+#define eof_token(x) ((x) == &eof_token_entry)
+
+extern int init_stream(const char *, int fd, const char **next_path);
+extern const char *stream_name(int stream);
+extern struct ident *hash_ident(struct ident *);
+extern struct ident *built_in_ident(const char *);
+extern struct token *built_in_token(int, struct ident *);
+extern const char *show_special(int);
+extern const char *show_ident(const struct ident *);
+extern const char *show_string(const struct string *string);
+extern const char *show_token(const struct token *);
+extern const char *quote_token(const struct token *);
+extern struct token * tokenize(const char *, int, struct token *, const char **next_path);
+extern struct token * tokenize_buffer(void *, unsigned long, struct token **);
+
+extern void show_identifier_stats(void);
+extern void init_include_path(void);
+extern struct token *preprocess(struct token *);
+
+extern void store_all_tokens(struct token *token);
+extern struct token *pos_get_token(struct position pos);
+extern char *pos_ident(struct position pos);
+
+extern void store_macro_pos(struct token *);
+extern char *get_macro_name(struct position pos);
+
+static inline int match_op(struct token *token, unsigned int op)
+{
+	return token->pos.type == TOKEN_SPECIAL && token->special == op;
+}
+
+static inline int match_ident(struct token *token, struct ident *id)
+{
+	return token->pos.type == TOKEN_IDENT && token->ident == id;
+}
+
+#endif
diff --git a/usr/src/tools/smatch/src/token_store.c b/usr/src/tools/smatch/src/token_store.c
new file mode 100644
index 0000000000..7924f2b80e
--- /dev/null
+++ b/usr/src/tools/smatch/src/token_store.c
@@ -0,0 +1,177 @@
+/*
+ * sparse/token_store.c
+ *
+ * Copyright (C) 2012 Oracle.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "lib.h"
+#include "parse.h"
+#include "allocate.h"
+
+struct line {
+	struct position pos;
+	struct line *prev;
+	struct token *token;
+	struct line *next;
+};
+
+__ALLOCATOR(struct token, "token store", perm_token);
+ALLOCATOR(line, "line of tokens");
+
+static struct token *copy_token(struct token *token)
+{
+	struct token *new;
+
+	new = __alloc_perm_token(0);
+	memcpy(new, token, sizeof(*token));
+	new->next = NULL;
+	return new;
+}
+
+static struct line *cursor;
+
+static void find_line(struct position pos)
+{
+	if (!cursor)
+		return;
+	if (pos.line == cursor->pos.line)
+		return;
+	if (pos.line < cursor->pos.line) {
+		if (!cursor->prev)
+			return;
+		cursor = cursor->prev;
+		find_line(pos);
+		return;
+	}
+	if (!cursor->next)
+		return;
+	if (pos.line < cursor->next->pos.line)
+		return;
+	cursor = cursor->next;
+	find_line(pos);
+}
+
+static void insert_into_line(struct token **current, struct token *new)
+{
+	if (!*current) {
+		*current = new;
+		return;
+	}
+
+	if (new->pos.pos < (*current)->pos.pos) {
+		new->next = *current;
+		*current = new;
+		return;
+	}
+
+	if (new->pos.pos == (*current)->pos.pos)
+		return;
+
+	insert_into_line(&(*current)->next, new);
+}
+
+static void store_token(struct token *token)
+{
+	token = copy_token(token);
+
+	find_line(token->pos);
+
+	if (!cursor) {
+		cursor = __alloc_line(0);
+		cursor->pos = token->pos;
+		cursor->token = token;
+		return;
+	}
+
+	if (token->pos.line < cursor->pos.line) {
+		cursor->prev = __alloc_line(0);
+		cursor->prev->next = cursor;
+		cursor = cursor->prev;
+		cursor->pos = token->pos;
+		cursor->token = token;
+		return;
+	}
+
+	if (token->pos.line == cursor->pos.line) {
+		insert_into_line(&cursor->token, token);
+		return;
+	}
+
+	cursor->next = __alloc_line(0);
+	cursor->next->prev = cursor;
+	cursor = cursor->next;
+	cursor->pos = token->pos;
+	cursor->token = token;
+}
+
+void store_all_tokens(struct token *token)
+{
+	while (token_type(token) != TOKEN_STREAMEND) {
+		store_token(token);
+		token = token->next;
+	}
+}
+
+struct token *first_token_from_line(struct position pos)
+{
+	find_line(pos);
+
+	if (!cursor)
+		return NULL;
+
+	if (cursor->pos.stream != pos.stream)
+		return NULL;
+	if (cursor->pos.line != pos.line)
+		return NULL;
+
+	return cursor->token;
+}
+
+struct token *pos_get_token(struct position pos)
+{
+	struct token *token;
+
+	token = first_token_from_line(pos);
+	while (token) {
+		if (pos.pos == token->pos.pos)
+			return token;
+		if (pos.pos < token->pos.pos)
+			return NULL;
+		token = token->next;
+	}
+	return NULL;
+}
+
+char *pos_ident(struct position pos)
+{
+	struct token *token;
+
+	token = pos_get_token(pos);
+	if (!token)
+		return NULL;
+	if (token_type(token) != TOKEN_IDENT)
+		return NULL;
+	return token->ident->name;
+}
+
diff --git a/usr/src/tools/smatch/src/tokenize.c b/usr/src/tools/smatch/src/tokenize.c
new file mode 100644
index 0000000000..ff5b1367fb
--- /dev/null
+++ b/usr/src/tools/smatch/src/tokenize.c
@@ -0,0 +1,1044 @@
+/*
+ * This is a really stupid C tokenizer. It doesn't do any include
+ * files or anything complex at all. That's the preprocessor.
+ *
+ * Copyright (C) 2003 Transmeta Corp.
+ *               2003 Linus Torvalds
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <stdint.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "symbol.h"
+
+#define EOF (-1)
+
+int input_stream_nr = 0;
+struct stream *input_streams;
+static int input_streams_allocated;
+unsigned int tabstop = 8;
+int no_lineno = 0;
+
+#define BUFSIZE (8192)
+
+typedef struct {
+	int fd, offset, size;
+	int pos, line, nr;
+	int newline, whitespace;
+	struct token **tokenlist;
+	struct token *token;
+	unsigned char *buffer;
+} stream_t;
+
+const char *stream_name(int stream)
+{
+	if (stream < 0 || stream > input_stream_nr)
+		return "<bad stream>";
+	return input_streams[stream].name;
+}
+
+static struct position stream_pos(stream_t *stream)
+{
+	struct position pos;
+	pos.type = 0;
+	pos.stream = stream->nr;
+	pos.newline = stream->newline;
+	pos.whitespace = stream->whitespace;
+	pos.pos = stream->pos;
+
+	pos.line = stream->line;
+	if (no_lineno)
+		pos.line = 123456;
+
+	pos.noexpand = 0;
+	return pos;
+}
+
+const char *show_special(int val)
+{
+	static char buffer[4];
+
+	buffer[0] = val;
+	buffer[1] = 0;
+	if (val >= SPECIAL_BASE)
+		strcpy(buffer, (char *) combinations[val - SPECIAL_BASE]);
+	return buffer;
+}
+
+const char *show_ident(const struct ident *ident)
+{
+	static char buffer[256];
+	if (!ident)
+		return "<noident>";
+	sprintf(buffer, "%.*s", ident->len, ident->name);
+	return buffer;
+}
+
+static char *charstr(char *ptr, unsigned char c, unsigned char escape, unsigned char next)
+{
+	if (isprint(c)) {
+		if (c == escape || c == '\\')
+			*ptr++ = '\\';
+		*ptr++ = c;
+		return ptr;
+	}
+	*ptr++ = '\\';
+	switch (c) {
+	case '\n':
+		*ptr++ = 'n';
+		return ptr;
+	case '\t':
+		*ptr++ = 't';
+		return ptr;
+	}
+	if (!isdigit(next))
+		return ptr + sprintf(ptr, "%o", c);
+		
+	return ptr + sprintf(ptr, "%03o", c);
+}
+
+const char *show_string(const struct string *string)
+{
+	static char buffer[4 * MAX_STRING + 3];
+	char *ptr;
+	int i;
+
+	if (!string->length)
+		return "<bad_string>";
+	ptr = buffer;
+	*ptr++ = '"';
+	for (i = 0; i < string->length-1; i++) {
+		const char *p = string->data + i;
+		ptr = charstr(ptr, p[0], '"', p[1]);
+	}
+	*ptr++ = '"';
+	*ptr = '\0';
+	return buffer;
+}
+
+static const char *show_char(const char *s, size_t len, char prefix, char delim)
+{
+	static char buffer[MAX_STRING + 4];
+	char *p = buffer;
+	if (prefix)
+		*p++ = prefix;
+	*p++ = delim;
+	memcpy(p, s, len);
+	p += len;
+	*p++ = delim;
+	*p++ = '\0';
+	return buffer;
+}
+
+static const char *quote_char(const char *s, size_t len, char prefix, char delim)
+{
+	static char buffer[2*MAX_STRING + 6];
+	size_t i;
+	char *p = buffer;
+	if (prefix)
+		*p++ = prefix;
+	if (delim == '"')
+		*p++ = '\\';
+	*p++ = delim;
+	for (i = 0; i < len; i++) {
+		if (s[i] == '"' || s[i] == '\\')
+			*p++ = '\\';
+		*p++ = s[i];
+	}
+	if (delim == '"')
+		*p++ = '\\';
+	*p++ = delim;
+	*p++ = '\0';
+	return buffer;
+}
+
+const char *show_token(const struct token *token)
+{
+	static char buffer[256];
+
+	if (!token)
+		return "<no token>";
+	switch (token_type(token)) {
+	case TOKEN_ERROR:
+		return "syntax error";
+
+	case TOKEN_EOF:
+		return "end-of-input";
+
+	case TOKEN_IDENT:
+		return show_ident(token->ident);
+
+	case TOKEN_NUMBER:
+		return token->number;
+
+	case TOKEN_SPECIAL:
+		return show_special(token->special);
+
+	case TOKEN_CHAR: 
+		return show_char(token->string->data,
+			token->string->length - 1, 0, '\'');
+	case TOKEN_CHAR_EMBEDDED_0 ... TOKEN_CHAR_EMBEDDED_3:
+		return show_char(token->embedded,
+			token_type(token) - TOKEN_CHAR, 0, '\'');
+	case TOKEN_WIDE_CHAR: 
+		return show_char(token->string->data,
+			token->string->length - 1, 'L', '\'');
+	case TOKEN_WIDE_CHAR_EMBEDDED_0 ... TOKEN_WIDE_CHAR_EMBEDDED_3:
+		return show_char(token->embedded,
+			token_type(token) - TOKEN_WIDE_CHAR, 'L', '\'');
+	case TOKEN_STRING: 
+		return show_char(token->string->data,
+			token->string->length - 1, 0, '"');
+	case TOKEN_WIDE_STRING: 
+		return show_char(token->string->data,
+			token->string->length - 1, 'L', '"');
+
+	case TOKEN_STREAMBEGIN:
+		sprintf(buffer, "<beginning of '%s'>", stream_name(token->pos.stream));
+		return buffer;
+
+	case TOKEN_STREAMEND:
+		sprintf(buffer, "<end of '%s'>", stream_name(token->pos.stream));
+		return buffer;
+
+	case TOKEN_UNTAINT:
+		sprintf(buffer, "<untaint>");
+		return buffer;
+
+	case TOKEN_ARG_COUNT:
+		sprintf(buffer, "<argcnt>");
+		return buffer;
+
+	default:
+		sprintf(buffer, "unhandled token type '%d' ", token_type(token));
+		return buffer;
+	}
+}
+
+const char *quote_token(const struct token *token)
+{
+	static char buffer[256];
+
+	switch (token_type(token)) {
+	case TOKEN_ERROR:
+		return "syntax error";
+
+	case TOKEN_IDENT:
+		return show_ident(token->ident);
+
+	case TOKEN_NUMBER:
+		return token->number;
+
+	case TOKEN_SPECIAL:
+		return show_special(token->special);
+
+	case TOKEN_CHAR: 
+		return quote_char(token->string->data,
+			token->string->length - 1, 0, '\'');
+	case TOKEN_CHAR_EMBEDDED_0 ... TOKEN_CHAR_EMBEDDED_3:
+		return quote_char(token->embedded,
+			token_type(token) - TOKEN_CHAR, 0, '\'');
+	case TOKEN_WIDE_CHAR: 
+		return quote_char(token->string->data,
+			token->string->length - 1, 'L', '\'');
+	case TOKEN_WIDE_CHAR_EMBEDDED_0 ... TOKEN_WIDE_CHAR_EMBEDDED_3:
+		return quote_char(token->embedded,
+			token_type(token) - TOKEN_WIDE_CHAR, 'L', '\'');
+	case TOKEN_STRING: 
+		return quote_char(token->string->data,
+			token->string->length - 1, 0, '"');
+	case TOKEN_WIDE_STRING: 
+		return quote_char(token->string->data,
+			token->string->length - 1, 'L', '"');
+	default:
+		sprintf(buffer, "unhandled token type '%d' ", token_type(token));
+		return buffer;
+	}
+}
+
+#define HASHED_INPUT_BITS (6)
+#define HASHED_INPUT (1 << HASHED_INPUT_BITS)
+#define HASH_PRIME 0x9e370001UL
+
+static int input_stream_hashes[HASHED_INPUT] = { [0 ... HASHED_INPUT-1] = -1 };
+
+int *hash_stream(const char *name)
+{
+	uint32_t hash = 0;
+	unsigned char c;
+
+	while ((c = *name++) != 0)
+		hash = (hash + (c << 4) + (c >> 4)) * 11;
+
+	hash *= HASH_PRIME;
+	hash >>= 32 - HASHED_INPUT_BITS;
+	return input_stream_hashes + hash;
+}
+
+int init_stream(const char *name, int fd, const char **next_path)
+{
+	int stream = input_stream_nr, *hash;
+	struct stream *current;
+
+	if (stream >= input_streams_allocated) {
+		int newalloc = stream * 4 / 3 + 10;
+		input_streams = realloc(input_streams, newalloc * sizeof(struct stream));
+		if (!input_streams)
+			die("Unable to allocate more streams space");
+		input_streams_allocated = newalloc;
+	}
+	current = input_streams + stream;
+	memset(current, 0, sizeof(*current));
+	current->name = name;
+	current->fd = fd;
+	current->next_path = next_path;
+	current->path = NULL;
+	current->constant = CONSTANT_FILE_MAYBE;
+	input_stream_nr = stream+1;
+	hash = hash_stream(name);
+	current->next_stream = *hash;
+	*hash = stream;
+	return stream;
+}
+
+static struct token * alloc_token(stream_t *stream)
+{
+	struct token *token = __alloc_token(0);
+	token->pos = stream_pos(stream);
+	return token;
+}
+
+/*
+ *  Argh...  That was surprisingly messy - handling '\r' complicates the
+ *  things a _lot_.
+ */
+static int nextchar_slow(stream_t *stream)
+{
+	int offset = stream->offset;
+	int size = stream->size;
+	int c;
+	int spliced = 0, had_cr, had_backslash;
+
+restart:
+	had_cr = had_backslash = 0;
+
+repeat:
+	if (offset >= size) {
+		if (stream->fd < 0)
+			goto got_eof;
+		size = read(stream->fd, stream->buffer, BUFSIZE);
+		if (size <= 0)
+			goto got_eof;
+		stream->size = size;
+		stream->offset = offset = 0;
+	}
+
+	c = stream->buffer[offset++];
+	if (had_cr)
+		goto check_lf;
+
+	if (c == '\r') {
+		had_cr = 1;
+		goto repeat;
+	}
+
+norm:
+	if (!had_backslash) {
+		switch (c) {
+		case '\t':
+			stream->pos += tabstop - stream->pos % tabstop;
+			break;
+		case '\n':
+			stream->line++;
+			stream->pos = 0;
+			stream->newline = 1;
+			break;
+		case '\\':
+			had_backslash = 1;
+			stream->pos++;
+			goto repeat;
+		default:
+			stream->pos++;
+		}
+	} else {
+		if (c == '\n') {
+			stream->line++;
+			stream->pos = 0;
+			spliced = 1;
+			goto restart;
+		}
+		offset--;
+		c = '\\';
+	}
+out:
+	stream->offset = offset;
+
+	return c;
+
+check_lf:
+	if (c != '\n')
+		offset--;
+	c = '\n';
+	goto norm;
+
+got_eof:
+	if (had_backslash) {
+		c = '\\';
+		goto out;
+	}
+	if (stream->pos)
+		warning(stream_pos(stream), "no newline at end of file");
+	else if (spliced)
+		warning(stream_pos(stream), "backslash-newline at end of file");
+	return EOF;
+}
+
+/*
+ *  We want that as light as possible while covering all normal cases.
+ *  Slow path (including the logics with line-splicing and EOF sanity
+ *  checks) is in nextchar_slow().
+ */
+static inline int nextchar(stream_t *stream)
+{
+	int offset = stream->offset;
+
+	if (offset < stream->size) {
+		int c = stream->buffer[offset++];
+		static const char special[256] = {
+			['\t'] = 1, ['\r'] = 1, ['\n'] = 1, ['\\'] = 1
+		};
+		if (!special[c]) {
+			stream->offset = offset;
+			stream->pos++;
+			return c;
+		}
+	}
+	return nextchar_slow(stream);
+}
+
+struct token eof_token_entry;
+
+static struct token *mark_eof(stream_t *stream)
+{
+	struct token *end;
+
+	end = alloc_token(stream);
+	token_type(end) = TOKEN_STREAMEND;
+	end->pos.newline = 1;
+
+	eof_token_entry.next = &eof_token_entry;
+	eof_token_entry.pos.newline = 1;
+
+	end->next =  &eof_token_entry;
+	*stream->tokenlist = end;
+	stream->tokenlist = NULL;
+	return end;
+}
+
+static void add_token(stream_t *stream)
+{
+	struct token *token = stream->token;
+
+	stream->token = NULL;
+	token->next = NULL;
+	*stream->tokenlist = token;
+	stream->tokenlist = &token->next;
+}
+
+static void drop_token(stream_t *stream)
+{
+	stream->newline |= stream->token->pos.newline;
+	stream->whitespace |= stream->token->pos.whitespace;
+	stream->token = NULL;
+}
+
+enum {
+	Letter = 1,
+	Digit = 2,
+	Hex = 4,
+	Exp = 8,
+	Dot = 16,
+	ValidSecond = 32,
+	Quote = 64,
+};
+
+static const long cclass[257] = {
+	['0' + 1 ... '7' + 1] = Digit | Hex,	/* \<octal> */
+	['8' + 1 ... '9' + 1] = Digit | Hex,
+	['A' + 1 ... 'D' + 1] = Letter | Hex,
+	['E' + 1] = Letter | Hex | Exp,	/* E<exp> */
+	['F' + 1] = Letter | Hex,
+	['G' + 1 ... 'O' + 1] = Letter,
+	['P' + 1] = Letter | Exp,	/* P<exp> */
+	['Q' + 1 ... 'Z' + 1] = Letter,
+	['a' + 1 ... 'b' + 1] = Letter | Hex, /* \a, \b */
+	['c' + 1 ... 'd' + 1] = Letter | Hex,
+	['e' + 1] = Letter | Hex | Exp,/* \e, e<exp> */
+	['f' + 1] = Letter | Hex,	/* \f */
+	['g' + 1 ... 'm' + 1] = Letter,
+	['n' + 1] = Letter,	/* \n */
+	['o' + 1] = Letter,
+	['p' + 1] = Letter | Exp,	/* p<exp> */
+	['q' + 1] = Letter,
+	['r' + 1] = Letter,	/* \r */
+	['s' + 1] = Letter,
+	['t' + 1] = Letter,	/* \t */
+	['u' + 1] = Letter,
+	['v' + 1] = Letter,	/* \v */
+	['w' + 1] = Letter,
+	['x' + 1] = Letter,	/* \x<hex> */
+	['y' + 1 ... 'z' + 1] = Letter,
+	['_' + 1] = Letter,
+	['.' + 1] = Dot | ValidSecond,
+	['=' + 1] = ValidSecond,
+	['+' + 1] = ValidSecond,
+	['-' + 1] = ValidSecond,
+	['>' + 1] = ValidSecond,
+	['<' + 1] = ValidSecond,
+	['&' + 1] = ValidSecond,
+	['|' + 1] = ValidSecond,
+	['#' + 1] = ValidSecond,
+	['\'' + 1] = Quote,
+	['"' + 1] = Quote,
+};
+
+/*
+ * pp-number:
+ *	digit
+ *	. digit
+ *	pp-number digit
+ *	pp-number identifier-nodigit
+ *	pp-number e sign
+ *	pp-number E sign
+ *	pp-number p sign
+ *	pp-number P sign
+ *	pp-number .
+ */
+static int get_one_number(int c, int next, stream_t *stream)
+{
+	struct token *token;
+	static char buffer[4095];
+	char *p = buffer, *buf, *buffer_end = buffer + sizeof (buffer);
+	int len;
+
+	*p++ = c;
+	for (;;) {
+		long class =  cclass[next + 1];
+		if (!(class & (Dot | Digit | Letter)))
+			break;
+		if (p != buffer_end)
+			*p++ = next;
+		next = nextchar(stream);
+		if (class & Exp) {
+			if (next == '-' || next == '+') {
+				if (p != buffer_end)
+					*p++ = next;
+				next = nextchar(stream);
+			}
+		}
+	}
+
+	if (p == buffer_end) {
+		sparse_error(stream_pos(stream), "number token exceeds %td characters",
+		      buffer_end - buffer);
+		// Pretend we saw just "1".
+		buffer[0] = '1';
+		p = buffer + 1;
+	}
+
+	*p++ = 0;
+	len = p - buffer;
+	buf = __alloc_bytes(len);
+	memcpy(buf, buffer, len);
+
+	token = stream->token;
+	token_type(token) = TOKEN_NUMBER;
+	token->number = buf;
+	add_token(stream);
+
+	return next;
+}
+
+static int eat_string(int next, stream_t *stream, enum token_type type)
+{
+	static char buffer[MAX_STRING];
+	struct string *string;
+	struct token *token = stream->token;
+	int len = 0;
+	int escape;
+	int want_hex = 0;
+	char delim = type < TOKEN_STRING ? '\'' : '"';
+
+	for (escape = 0; escape || next != delim; next = nextchar(stream)) {
+		if (len < MAX_STRING)
+			buffer[len] = next;
+		len++;
+		if (next == '\n') {
+			warning(stream_pos(stream),
+				"Newline in string or character constant");
+			if (delim == '\'') /* assume it's lost ' */
+				break;
+		}
+		if (next == EOF) {
+			warning(stream_pos(stream),
+				"End of file in middle of string");
+			return next;
+		}
+		if (!escape) {
+			if (want_hex && !(cclass[next + 1] & Hex))
+				warning(stream_pos(stream),
+					"\\x used with no following hex digits");
+			want_hex = 0;
+			escape = next == '\\';
+		} else {
+			escape = 0;
+			want_hex = next == 'x';
+		}
+	}
+	if (want_hex)
+		warning(stream_pos(stream),
+			"\\x used with no following hex digits");
+	if (len > MAX_STRING) {
+		warning(stream_pos(stream), "string too long (%d bytes, %d bytes max)", len, MAX_STRING);
+		len = MAX_STRING;
+	}
+	if (delim == '\'' && len <= 4) {
+		if (len == 0) {
+			sparse_error(stream_pos(stream),
+				"empty character constant");
+			return nextchar(stream);
+		}
+		token_type(token) = type + len;
+		memset(buffer + len, '\0', 4 - len);
+		memcpy(token->embedded, buffer, 4);
+	} else {
+		token_type(token) = type;
+		string = __alloc_string(len+1);
+		memcpy(string->data, buffer, len);
+		string->data[len] = '\0';
+		string->length = len+1;
+		token->string = string;
+	}
+
+	/* Pass it on.. */
+	token = stream->token;
+	add_token(stream);
+	return nextchar(stream);
+}
+
+static int drop_stream_eoln(stream_t *stream)
+{
+	drop_token(stream);
+	for (;;) {
+		switch (nextchar(stream)) {
+		case EOF:
+			return EOF;
+		case '\n':
+			return nextchar(stream);
+		}
+	}
+}
+
+static int drop_stream_comment(stream_t *stream)
+{
+	int newline;
+	int next;
+	drop_token(stream);
+	newline = stream->newline;
+
+	next = nextchar(stream);
+	for (;;) {
+		int curr = next;
+		if (curr == EOF) {
+			warning(stream_pos(stream), "End of file in the middle of a comment");
+			return curr;
+		}
+		next = nextchar(stream);
+		if (curr == '*' && next == '/')
+			break;
+	}
+	stream->newline = newline;
+	return nextchar(stream);
+}
+
+unsigned char combinations[][4] = COMBINATION_STRINGS;
+
+#define NR_COMBINATIONS (SPECIAL_ARG_SEPARATOR - SPECIAL_BASE)
+
+/* hash function for two-character punctuators - all give unique values */
+#define special_hash(c0, c1) (((c0*8+c1*2)+((c0*8+c1*2)>>5))&31)
+
+/*
+ * note that we won't get false positives - special_hash(0,0) is 0 and
+ * entry 0 is filled (by +=), so all the missing ones are OK.
+ */
+static unsigned char hash_results[32][2] = {
+#define RES(c0, c1) [special_hash(c0, c1)] = {c0, c1}
+	RES('+', '='), /* 00 */
+	RES('/', '='), /* 01 */
+	RES('^', '='), /* 05 */
+	RES('&', '&'), /* 07 */
+	RES('#', '#'), /* 08 */
+	RES('<', '<'), /* 0a */
+	RES('<', '='), /* 0c */
+	RES('!', '='), /* 0e */
+	RES('%', '='), /* 0f */
+	RES('-', '-'), /* 10 */
+	RES('-', '='), /* 11 */
+	RES('-', '>'), /* 13 */
+	RES('=', '='), /* 15 */
+	RES('&', '='), /* 17 */
+	RES('*', '='), /* 18 */
+	RES('.', '.'), /* 1a */
+	RES('+', '+'), /* 1b */
+	RES('|', '='), /* 1c */
+	RES('>', '='), /* 1d */
+	RES('|', '|'), /* 1e */
+	RES('>', '>')  /* 1f */
+#undef RES
+};
+static int code[32] = {
+#define CODE(c0, c1, value) [special_hash(c0, c1)] = value
+	CODE('+', '=', SPECIAL_ADD_ASSIGN), /* 00 */
+	CODE('/', '=', SPECIAL_DIV_ASSIGN), /* 01 */
+	CODE('^', '=', SPECIAL_XOR_ASSIGN), /* 05 */
+	CODE('&', '&', SPECIAL_LOGICAL_AND), /* 07 */
+	CODE('#', '#', SPECIAL_HASHHASH), /* 08 */
+	CODE('<', '<', SPECIAL_LEFTSHIFT), /* 0a */
+	CODE('<', '=', SPECIAL_LTE), /* 0c */
+	CODE('!', '=', SPECIAL_NOTEQUAL), /* 0e */
+	CODE('%', '=', SPECIAL_MOD_ASSIGN), /* 0f */
+	CODE('-', '-', SPECIAL_DECREMENT), /* 10 */
+	CODE('-', '=', SPECIAL_SUB_ASSIGN), /* 11 */
+	CODE('-', '>', SPECIAL_DEREFERENCE), /* 13 */
+	CODE('=', '=', SPECIAL_EQUAL), /* 15 */
+	CODE('&', '=', SPECIAL_AND_ASSIGN), /* 17 */
+	CODE('*', '=', SPECIAL_MUL_ASSIGN), /* 18 */
+	CODE('.', '.', SPECIAL_DOTDOT), /* 1a */
+	CODE('+', '+', SPECIAL_INCREMENT), /* 1b */
+	CODE('|', '=', SPECIAL_OR_ASSIGN), /* 1c */
+	CODE('>', '=', SPECIAL_GTE), /* 1d */
+	CODE('|', '|', SPECIAL_LOGICAL_OR), /* 1e */
+	CODE('>', '>', SPECIAL_RIGHTSHIFT)  /* 1f */
+#undef CODE
+};
+
+static int get_one_special(int c, stream_t *stream)
+{
+	struct token *token;
+	int next, value, i;
+
+	next = nextchar(stream);
+
+	/*
+	 * Check for numbers, strings, character constants, and comments
+	 */
+	switch (c) {
+	case '.':
+		if (next >= '0' && next <= '9')
+			return get_one_number(c, next, stream);
+		break;
+	case '"':
+		return eat_string(next, stream, TOKEN_STRING);
+	case '\'':
+		return eat_string(next, stream, TOKEN_CHAR);
+	case '/':
+		if (next == '/')
+			return drop_stream_eoln(stream);
+		if (next == '*')
+			return drop_stream_comment(stream);
+	}
+
+	/*
+	 * Check for combinations
+	 */
+	value = c;
+	if (cclass[next + 1] & ValidSecond) {
+		i = special_hash(c, next);
+		if (hash_results[i][0] == c && hash_results[i][1] == next) {
+			value = code[i];
+			next = nextchar(stream);
+			if (value >= SPECIAL_LEFTSHIFT &&
+			    next == "==."[value - SPECIAL_LEFTSHIFT]) {
+				value += 3;
+				next = nextchar(stream);
+			}
+		}
+	}
+
+	/* Pass it on.. */
+	token = stream->token;
+	token_type(token) = TOKEN_SPECIAL;
+	token->special = value;
+	add_token(stream);
+	return next;
+}
+
+#define IDENT_HASH_BITS (13)
+#define IDENT_HASH_SIZE (1<<IDENT_HASH_BITS)
+#define IDENT_HASH_MASK (IDENT_HASH_SIZE-1)
+
+#define ident_hash_init(c)		(c)
+#define ident_hash_add(oldhash,c)	((oldhash)*11 + (c))
+#define ident_hash_end(hash)		((((hash) >> IDENT_HASH_BITS) + (hash)) & IDENT_HASH_MASK)
+
+static struct ident *hash_table[IDENT_HASH_SIZE];
+static int ident_hit, ident_miss, idents;
+
+void show_identifier_stats(void)
+{
+	int i;
+	int distribution[100];
+
+	fprintf(stderr, "identifiers: %d hits, %d misses\n",
+		ident_hit, ident_miss);
+
+	for (i = 0; i < 100; i++)
+		distribution[i] = 0;
+
+	for (i = 0; i < IDENT_HASH_SIZE; i++) {
+		struct ident * ident = hash_table[i];
+		int count = 0;
+
+		while (ident) {
+			count++;
+			ident = ident->next;
+		}
+		if (count > 99)
+			count = 99;
+		distribution[count]++;
+	}
+
+	for (i = 0; i < 100; i++) {
+		if (distribution[i])
+			fprintf(stderr, "%2d: %d buckets\n", i, distribution[i]);
+	}
+}
+
+static struct ident *alloc_ident(const char *name, int len)
+{
+	struct ident *ident = __alloc_ident(len);
+	ident->symbols = NULL;
+	ident->len = len;
+	ident->tainted = 0;
+	memcpy(ident->name, name, len);
+	return ident;
+}
+
+static struct ident * insert_hash(struct ident *ident, unsigned long hash)
+{
+	ident->next = hash_table[hash];
+	hash_table[hash] = ident;
+	ident_miss++;
+	return ident;
+}
+
+static struct ident *create_hashed_ident(const char *name, int len, unsigned long hash)
+{
+	struct ident *ident;
+	struct ident **p;
+
+	p = &hash_table[hash];
+	while ((ident = *p) != NULL) {
+		if (ident->len == (unsigned char) len) {
+			if (strncmp(name, ident->name, len) != 0)
+				goto next;
+
+			ident_hit++;
+			return ident;
+		}
+next:
+		//misses++;
+		p = &ident->next;
+	}
+	ident = alloc_ident(name, len);
+	*p = ident;
+	ident->next = NULL;
+	ident_miss++;
+	idents++;
+	return ident;
+}
+
+static unsigned long hash_name(const char *name, int len)
+{
+	unsigned long hash;
+	const unsigned char *p = (const unsigned char *)name;
+
+	hash = ident_hash_init(*p++);
+	while (--len) {
+		unsigned int i = *p++;
+		hash = ident_hash_add(hash, i);
+	}
+	return ident_hash_end(hash);
+}
+
+struct ident *hash_ident(struct ident *ident)
+{
+	return insert_hash(ident, hash_name(ident->name, ident->len));
+}
+
+struct ident *built_in_ident(const char *name)
+{
+	int len = strlen(name);
+	return create_hashed_ident(name, len, hash_name(name, len));
+}
+
+struct token *built_in_token(int stream, struct ident *ident)
+{
+	struct token *token;
+
+	token = __alloc_token(0);
+	token->pos.stream = stream;
+	token_type(token) = TOKEN_IDENT;
+	token->ident = ident;
+	return token;
+}
+
+static int get_one_identifier(int c, stream_t *stream)
+{
+	struct token *token;
+	struct ident *ident;
+	unsigned long hash;
+	char buf[256];
+	int len = 1;
+	int next;
+
+	hash = ident_hash_init(c);
+	buf[0] = c;
+	for (;;) {
+		next = nextchar(stream);
+		if (!(cclass[next + 1] & (Letter | Digit)))
+			break;
+		if (len >= sizeof(buf))
+			break;
+		hash = ident_hash_add(hash, next);
+		buf[len] = next;
+		len++;
+	};
+	if (cclass[next + 1] & Quote) {
+		if (len == 1 && buf[0] == 'L') {
+			if (next == '\'')
+				return eat_string(nextchar(stream), stream,
+							TOKEN_WIDE_CHAR);
+			else
+				return eat_string(nextchar(stream), stream,
+							TOKEN_WIDE_STRING);
+		}
+	}
+	hash = ident_hash_end(hash);
+	ident = create_hashed_ident(buf, len, hash);
+
+	/* Pass it on.. */
+	token = stream->token;
+	token_type(token) = TOKEN_IDENT;
+	token->ident = ident;
+	add_token(stream);
+	return next;
+}		
+
+static int get_one_token(int c, stream_t *stream)
+{
+	long class = cclass[c + 1];
+	if (class & Digit)
+		return get_one_number(c, nextchar(stream), stream);
+	if (class & Letter)
+		return get_one_identifier(c, stream);
+	return get_one_special(c, stream);
+}
+
+static struct token *setup_stream(stream_t *stream, int idx, int fd,
+	unsigned char *buf, unsigned int buf_size)
+{
+	struct token *begin;
+
+	stream->nr = idx;
+	stream->line = 1;
+	stream->newline = 1;
+	stream->whitespace = 0;
+	stream->pos = 0;
+
+	stream->token = NULL;
+	stream->fd = fd;
+	stream->offset = 0;
+	stream->size = buf_size;
+	stream->buffer = buf;
+
+	begin = alloc_token(stream);
+	token_type(begin) = TOKEN_STREAMBEGIN;
+	stream->tokenlist = &begin->next;
+	return begin;
+}
+
+static struct token *tokenize_stream(stream_t *stream)
+{
+	int c = nextchar(stream);
+	while (c != EOF) {
+		if (!isspace(c)) {
+			struct token *token = alloc_token(stream);
+			stream->token = token;
+			stream->newline = 0;
+			stream->whitespace = 0;
+			c = get_one_token(c, stream);
+			continue;
+		}
+		stream->whitespace = 1;
+		c = nextchar(stream);
+	}
+	return mark_eof(stream);
+}
+
+struct token * tokenize_buffer(void *buffer, unsigned long size, struct token **endtoken)
+{
+	stream_t stream;
+	struct token *begin;
+
+	begin = setup_stream(&stream, 0, -1, buffer, size);
+	*endtoken = tokenize_stream(&stream);
+	return begin;
+}
+
+struct token * tokenize(const char *name, int fd, struct token *endtoken, const char **next_path)
+{
+	struct token *begin, *end;
+	stream_t stream;
+	unsigned char buffer[BUFSIZE];
+	int idx;
+
+	idx = init_stream(name, fd, next_path);
+	if (idx < 0) {
+		// info(endtoken->pos, "File %s is const", name);
+		return endtoken;
+	}
+
+	begin = setup_stream(&stream, idx, fd, buffer, 0);
+	end = tokenize_stream(&stream);
+	if (endtoken)
+		end->next = endtoken;
+	return begin;
+}
diff --git a/usr/src/tools/smatch/src/unssa.c b/usr/src/tools/smatch/src/unssa.c
new file mode 100644
index 0000000000..e7c9154d53
--- /dev/null
+++ b/usr/src/tools/smatch/src/unssa.c
@@ -0,0 +1,147 @@
+/*
+ * UnSSA - translate the SSA back to normal form.
+ *
+ * For now it's done by replacing to set of copies:
+ * 1) For each phi-node, replace all their phisrc by copies to a common
+ *    temporary.
+ * 2) Replace all the phi-nodes by copies of the temporaries to the phi-node target.
+ *    This is node to preserve the semantic of the phi-node (they should all "execute"
+ *    simultaneously on entry in the basic block in which they belong).
+ *
+ * This is similar to the "Sreedhar method I" except that the copies to the
+ * temporaries are not placed at the end of the predecessor basic blocks, but
+ * at the place where the phi-node operands are defined.
+ * This is particulary easy since these copies are essentialy already present
+ * as the corresponding OP_PHISOURCE.
+ *
+ * While very simple this method create a lot more copies that really necessary.
+ * We eliminate some of these copies but most probably most of them are still
+ * useless.
+ * Ideally, "Sreedhar method III" should be used:
+ * "Translating Out of Static Single Assignment Form", V. C. Sreedhar, R. D.-C. Ju,
+ * D. M. Gillies and V. Santhanam.  SAS'99, Vol. 1694 of Lecture Notes in Computer
+ * Science, Springer-Verlag, pp. 194-210, 1999.
+ * But for this we need precise liveness, on each %phi and not only on OP_PHI's
+ * target pseudos.
+ *
+ * Copyright (C) 2005 Luc Van Oostenryck
+ */
+
+#include "lib.h"
+#include "linearize.h"
+#include "allocate.h"
+#include "flow.h"
+#include <assert.h>
+
+
+static inline int nbr_pseudo_users(pseudo_t p)
+{
+	return ptr_list_size((struct ptr_list *)p->users);
+}
+
+static int simplify_phi_node(struct instruction *phi, pseudo_t tmp)
+{
+	pseudo_t target = phi->target;
+	struct pseudo_user *pu;
+	pseudo_t src;
+
+	// verify if this phi can be simplified
+	FOR_EACH_PTR(phi->phi_list, src) {
+		struct instruction *def = src->def;
+
+		if (!def)
+			continue;
+		if (def->bb == phi->bb)
+			return 0;
+	} END_FOR_EACH_PTR(src);
+
+	// no need to make a copy of this one
+	// -> replace the target pseudo by the tmp
+	FOR_EACH_PTR(target->users, pu) {
+		use_pseudo(pu->insn, tmp, pu->userp);
+	} END_FOR_EACH_PTR(pu);
+
+	phi->bb = NULL;
+	return 1;
+}
+
+static void replace_phi_node(struct instruction *phi)
+{
+	pseudo_t tmp;
+	pseudo_t p;
+
+	tmp = alloc_pseudo(NULL);
+	tmp->type = phi->target->type;
+	tmp->ident = phi->target->ident;
+	tmp->def = NULL;		// defined by all the phisrc
+
+	// can we avoid to make of copy?
+	simplify_phi_node(phi, tmp);
+
+	// rewrite all it's phi_src to copy to a new tmp
+	FOR_EACH_PTR(phi->phi_list, p) {
+		struct instruction *def = p->def;
+		pseudo_t src;
+
+		if (p == VOID)
+			continue;
+
+		assert(def->opcode == OP_PHISOURCE);
+
+		def->opcode = OP_COPY;
+		def->target = tmp;
+
+		// can we eliminate the copy?
+		src = def->phi_src;
+		if (src->type != PSEUDO_REG)
+			continue;
+		switch (nbr_pseudo_users(src)) {
+			struct instruction *insn;
+		case 1:
+			insn = src->def;
+			if (!insn)
+				break;
+			insn->target = tmp;
+		case 0:
+			kill_instruction(def);
+			def->bb = NULL;
+		}
+	} END_FOR_EACH_PTR(p);
+
+	if (!phi->bb)
+		return;
+
+	// rewrite the phi node:
+	//	phi	%rt, ...
+	// to:
+	//	copy	%rt, %tmp
+	phi->opcode = OP_COPY;
+	use_pseudo(phi, tmp, &phi->src);
+}
+
+static void rewrite_phi_bb(struct basic_block *bb)
+{
+	struct instruction *insn;
+
+	// Replace all the phi-nodes by copies of a temporary
+	// (which represent the set of all the %phi that feed them).
+	// The target pseudo doesn't change.
+	FOR_EACH_PTR(bb->insns, insn) {
+		if (!insn->bb)
+			continue;
+		if (insn->opcode != OP_PHI)
+			continue;
+		replace_phi_node(insn);
+	} END_FOR_EACH_PTR(insn);
+}
+
+int unssa(struct entrypoint *ep)
+{
+	struct basic_block *bb;
+
+	FOR_EACH_PTR(ep->bbs, bb) {
+		rewrite_phi_bb(bb);
+	} END_FOR_EACH_PTR(bb);
+
+	return 0;
+}
diff --git a/usr/src/tools/smatch/src/validation/.gitignore b/usr/src/tools/smatch/src/validation/.gitignore
new file mode 100644
index 0000000000..77276ba4a0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/.gitignore
@@ -0,0 +1,4 @@
+# test-suite
+*.diff
+*.got
+*.expected
diff --git a/usr/src/tools/smatch/src/validation/Woverride-init-def.c b/usr/src/tools/smatch/src/validation/Woverride-init-def.c
new file mode 100644
index 0000000000..95ecf33be6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/Woverride-init-def.c
@@ -0,0 +1,14 @@
+static int array[] = {
+	[1] = 3,
+	[1] = 1,		/* check-should-warn */
+};
+
+/*
+ * check-name: Woverride-init-def
+ * check-command: sparse $file
+ *
+ * check-error-start
+Woverride-init-def.c:2:10: warning: Initializer entry defined twice
+Woverride-init-def.c:3:10:   also defined here
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/Woverride-init-no.c b/usr/src/tools/smatch/src/validation/Woverride-init-no.c
new file mode 100644
index 0000000000..ba4d82b9f9
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/Woverride-init-no.c
@@ -0,0 +1,12 @@
+static int array[] = {
+	[1] = 3,
+	[1] = 1,		/* check-should-warn */
+};
+
+/*
+ * check-name: Woverride-init-no
+ * check-command: sparse -Wno-override-init $file
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/Woverride-init-yes.c b/usr/src/tools/smatch/src/validation/Woverride-init-yes.c
new file mode 100644
index 0000000000..c04a836be2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/Woverride-init-yes.c
@@ -0,0 +1,14 @@
+static int array[] = {
+	[1] = 3,
+	[1] = 1,		/* check-should-warn */
+};
+
+/*
+ * check-name: Woverride-init-yes
+ * check-command: sparse -Woverride-init $file
+ *
+ * check-error-start
+Woverride-init-yes.c:2:10: warning: Initializer entry defined twice
+Woverride-init-yes.c:3:10:   also defined here
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/Wunknown-attribute-def.c b/usr/src/tools/smatch/src/validation/Wunknown-attribute-def.c
new file mode 100644
index 0000000000..0c0868d6ba
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/Wunknown-attribute-def.c
@@ -0,0 +1,9 @@
+static int foo(void) __attribute__((unknown_attribute));
+
+/*
+ * check-name: warn-unknown-attribute
+ *
+ * check-error-start
+Wunknown-attribute-def.c:1:37: warning: attribute 'unknown_attribute': unknown attribute
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/Wunknown-attribute-no.c b/usr/src/tools/smatch/src/validation/Wunknown-attribute-no.c
new file mode 100644
index 0000000000..87951699a4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/Wunknown-attribute-no.c
@@ -0,0 +1,9 @@
+static int foo(void) __attribute__((unknown_attribute));
+
+/*
+ * check-name: warn-unknown-attribute-no
+ * check-command: sparse -Wno-unknown-attribute $file
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/Wunknown-attribute-yes.c b/usr/src/tools/smatch/src/validation/Wunknown-attribute-yes.c
new file mode 100644
index 0000000000..72538cf5d5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/Wunknown-attribute-yes.c
@@ -0,0 +1,10 @@
+static int foo(void) __attribute__((unknown_attribute));
+
+/*
+ * check-name: warn-unknown-attribute-yes
+ * check-command: sparse -Wunknown-attribute $file
+ *
+ * check-error-start
+Wunknown-attribute-yes.c:1:37: warning: attribute 'unknown_attribute': unknown attribute
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/__func__.c b/usr/src/tools/smatch/src/validation/__func__.c
new file mode 100644
index 0000000000..65ce92825f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/__func__.c
@@ -0,0 +1,15 @@
+static void f(void)
+{
+	char *s1 = __func__;
+	char arr[2 * (sizeof __func__ == 2) - 1];
+	char *s2 = __func__ __func__;
+}
+/*
+ * check-name: __func__
+ * check-command: sparse -Wall $file
+ *
+ * check-error-start
+__func__.c:5:29: error: Expected ; at end of declaration
+__func__.c:5:29: error: got __func__
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/abstract-array-declarator-static.c b/usr/src/tools/smatch/src/validation/abstract-array-declarator-static.c
new file mode 100644
index 0000000000..92f06bdc6d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/abstract-array-declarator-static.c
@@ -0,0 +1,14 @@
+
+extern void f1(int g[static 1]);
+extern void f2(int g[static restrict 1]);
+extern void f3(int g[restrict static 1]);
+extern void f4(int g[static restrict static 1]);	/* duplicate static error */
+extern void f5(int g[restrict static static 1]);	/* duplicate static error */
+
+/*
+ * check-name: abstract array declarator static
+ * check-error-start
+abstract-array-declarator-static.c:5:38: error: duplicate array static declarator
+abstract-array-declarator-static.c:6:38: error: duplicate array static declarator
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/address_space.c b/usr/src/tools/smatch/src/validation/address_space.c
new file mode 100644
index 0000000000..c55b78df0f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/address_space.c
@@ -0,0 +1,17 @@
+#define __user __attribute__((address_space(1)))
+
+extern int poke_memory(void *addr);
+
+static int sys_do_stuff(void __user *user_addr)
+{
+	return poke_memory(user_addr);
+}
+/*
+ * check-name: address_space attribute
+ *
+ * check-error-start
+address_space.c:7:28: warning: incorrect type in argument 1 (different address spaces)
+address_space.c:7:28:    expected void *addr
+address_space.c:7:28:    got void <asn:1>*user_addr
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/alias-distinct.c b/usr/src/tools/smatch/src/validation/alias-distinct.c
new file mode 100644
index 0000000000..42937b24b5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/alias-distinct.c
@@ -0,0 +1,17 @@
+extern int g;
+extern int h;
+
+static int foo(void)
+{
+	g = 1;
+	h = 2;
+	return g == 1;
+}
+
+/*
+ * check-name: alias distinct symbols
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-contains: ret\\..* *\\$1
+ */
diff --git a/usr/src/tools/smatch/src/validation/alias-mixed.c b/usr/src/tools/smatch/src/validation/alias-mixed.c
new file mode 100644
index 0000000000..0cfbe36b8a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/alias-mixed.c
@@ -0,0 +1,30 @@
+extern int g;
+
+
+static int foo(int *p)
+{
+	*p = 1;
+	g = 2;
+	return *p == 1;
+}
+
+static int bar(int *p)
+{
+	g = 1;
+	*p = 2;
+	return g == 1;
+}
+
+static void test(void)
+{
+	foo(&g);
+	bar(&g);
+}
+
+/*
+ * check-name: alias symbol/pointer
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: ret\\..* *\\$1
+ */
diff --git a/usr/src/tools/smatch/src/validation/alias-same.c b/usr/src/tools/smatch/src/validation/alias-same.c
new file mode 100644
index 0000000000..55cf42445f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/alias-same.c
@@ -0,0 +1,17 @@
+extern int g;
+
+
+static int foo(void)
+{
+	g = 1;
+	g = 2;
+	return g != 1;
+}
+
+/*
+ * check-name: alias same symbols
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-contains: ret\\..* *\\$1
+ */
diff --git a/usr/src/tools/smatch/src/validation/alloc-align.c b/usr/src/tools/smatch/src/validation/alloc-align.c
new file mode 100644
index 0000000000..e414257aa5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/alloc-align.c
@@ -0,0 +1,38 @@
+typedef unsigned long int size_t;
+
+/*
+ * The alloc_align attribute is used to tell the compiler that the return
+ * value points to memory, where the returned pointer minimum alignment is given
+ * by one of the functions parameters. GCC uses this information to improve
+ * pointer alignment analysis.
+ *
+ * The function parameter denoting the allocated alignment is specified by one
+ * integer argument, whose number is the argument of the attribute. Argument
+ * numbering starts at one.
+ *
+ * For instance,
+ *
+ *    void* my_memalign(size_t, size_t) __attribute__((alloc_align(1)))
+ *
+ * declares that my_memalign returns memory with minimum alignment given by
+ * parameter 1.
+ */
+
+#define __alloc_align(x)  __attribute__((__alloc_align__(x)))
+
+/*
+ * The aligned_alloc function allocates space for an object whose alignment is
+ * specified by alignment, whose size is specified by size, and whose value is
+ * indeterminate. The value of alignment shall be a valid alignment supported
+ * by the implementation and the value of size shall be an integral multiple
+ * of alignment.
+ *
+ * The aligned_alloc function returns either a null pointer or a pointer to the
+ * allocated space.
+ */
+void *aligned_alloc(size_t alignment, size_t size) __alloc_align(1);
+
+
+/*
+ * check-name: attribute __alloc_align__
+ */
diff --git a/usr/src/tools/smatch/src/validation/alternate-keywords.c b/usr/src/tools/smatch/src/validation/alternate-keywords.c
new file mode 100644
index 0000000000..2e91a354d2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/alternate-keywords.c
@@ -0,0 +1,46 @@
+
+extern float strtof(const char *__restrict__ ptr, char **__restrict__ endptr);
+extern double strtod(const char *__restrict ptr, char **__restrict endptr);
+/* restrict: -std=c99 or -std=gnu99 or -std=c11 */
+extern long double strtold(const char *restrict ptr, char **restrict endptr);
+
+extern int (*funcs[])(void);
+
+/* typeof: no -std or -std=gnu90 or -std=gnu99 or -std=gnu11 */
+extern typeof (funcs[0]) f0;
+extern __typeof (funcs[1]) f1;
+extern __typeof__(funcs[2]) f2;
+
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+static __inline__ uint16_t swap16(uint16_t val)
+{
+	return ((((uint16_t)(val) & (uint16_t)0x00ffU) << 8) |
+		(((uint16_t)(val) & (uint16_t)0xff00U) >> 8));
+}
+
+static __inline uint32_t swap32(uint32_t val)
+{
+	return ((((uint32_t)(val) & (uint32_t)0x000000ffUL) << 24) |
+		(((uint32_t)(val) & (uint32_t)0x0000ff00UL) <<  8) |
+		(((uint32_t)(val) & (uint32_t)0x00ff0000UL) >>  8) |
+		(((uint32_t)(val) & (uint32_t)0xff000000UL) >> 24));
+}
+
+/* inline: no -std or -std=gnu90 or -std=c99 or -std=c11 */
+static inline uint64_t swap64(uint64_t val)
+{
+	return ((((uint64_t)(val) & (uint64_t)0x00000000000000ffULL) << 56) |
+		(((uint64_t)(val) & (uint64_t)0x000000000000ff00ULL) << 40) |
+		(((uint64_t)(val) & (uint64_t)0x0000000000ff0000ULL) << 24) |
+		(((uint64_t)(val) & (uint64_t)0x00000000ff000000ULL) <<  8) |
+		(((uint64_t)(val) & (uint64_t)0x000000ff00000000ULL) >>  8) |
+		(((uint64_t)(val) & (uint64_t)0x0000ff0000000000ULL) >> 24) |
+		(((uint64_t)(val) & (uint64_t)0x00ff000000000000ULL) >> 40) |
+		(((uint64_t)(val) & (uint64_t)0xff00000000000000ULL) >> 56));
+}
+/*
+ * check-name: alternate keywords
+ */
diff --git a/usr/src/tools/smatch/src/validation/anon-union.c b/usr/src/tools/smatch/src/validation/anon-union.c
new file mode 100644
index 0000000000..487f957b8e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/anon-union.c
@@ -0,0 +1,11 @@
+struct s {
+        union {
+                int val;
+        };
+};
+
+static struct s foo = { .val = 5, };
+/*
+ * check-name: test anonymous union initializer
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/asm-empty-clobber.c b/usr/src/tools/smatch/src/validation/asm-empty-clobber.c
new file mode 100644
index 0000000000..eb1e105828
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/asm-empty-clobber.c
@@ -0,0 +1,28 @@
+
+# define __ASM_FORM(x)  " " #x " "
+# define JUMP_LABEL_INITIAL_NOP ".byte 0xe9 \n\t .long 0\n\t"
+# define __ASM_SEL(a,b) __ASM_FORM(b)
+#define _ASM_PTR        __ASM_SEL(.long, .quad)
+
+# define JUMP_LABEL(key, label)                                 \
+       do {                                                    \
+               asm goto("1:"                                   \
+                       JUMP_LABEL_INITIAL_NOP                  \
+                       ".pushsection __jump_table,  \"a\" \n\t"\
+                       _ASM_PTR "1b, %l[" #label "], %c0 \n\t" \
+                       ".popsection \n\t"                      \
+                       : :  "i" (key) :  : label);             \
+       } while (0)
+
+int main(int argc, char *argv[])
+{
+       JUMP_LABEL("1", do_trace );
+       return 1;
+do_trace:
+       return 0;
+}
+
+/*
+ *  check-name: Asm with goto labels.
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/asm-goto-lables.c b/usr/src/tools/smatch/src/validation/asm-goto-lables.c
new file mode 100644
index 0000000000..ac2bf2ad1b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/asm-goto-lables.c
@@ -0,0 +1,22 @@
+static inline int __static_cpu_has(unsigned char bit)
+{
+       asm goto("1: jmp %l[t_no]\n"
+                "2:\n"
+                ".section .altinstructions,\"a\"\n"
+                "\n"
+                "1b\n"
+                "0\n"         /* no replacement */
+                " .byte %P0\n"         /* feature bit */
+                " .byte 2b - 1b\n"     /* source len */
+                " .byte 0\n"           /* replacement len */
+                " .byte 0xff + 0 - (2b-1b)\n"  /* padding */
+                ".previous\n"
+                : : "i" (bit) : : t_no, ble);
+       return 1;
+t_no:
+       return 0;
+}
+/*
+ *  check-name: Asm with goto labels.
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/asm-toplevel.c b/usr/src/tools/smatch/src/validation/asm-toplevel.c
new file mode 100644
index 0000000000..8bdd7fc125
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/asm-toplevel.c
@@ -0,0 +1,7 @@
+__asm__("/* nothing */");
+/*
+ * check-name: asm-toplevel.c
+ * check-command: test-linearize $file
+ * check-output-ignore
+ * check-output-contains: asm *".. nothing .."
+ */
diff --git a/usr/src/tools/smatch/src/validation/attr-inline.c b/usr/src/tools/smatch/src/validation/attr-inline.c
new file mode 100644
index 0000000000..1b88ddb9d6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/attr-inline.c
@@ -0,0 +1,21 @@
+
+static inline __attribute__((__always_inline__)) int gt(int lhs, int rhs)
+{
+	return lhs > rhs;
+}
+
+extern inline __attribute__((__gnu_inline__)) int ge(int lhs, int rhs)
+{
+	return lhs >= rhs;
+}
+
+static __attribute__((__warning__("That's junk!"))) __attribute__((__unused__))
+__attribute__((__noinline__))
+void junk(void)
+{
+	__asm__("");
+}
+
+/*
+ * check-name: inline attributes
+ */
diff --git a/usr/src/tools/smatch/src/validation/attr-no_sanitize_address.c b/usr/src/tools/smatch/src/validation/attr-no_sanitize_address.c
new file mode 100644
index 0000000000..b57ee55a5b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/attr-no_sanitize_address.c
@@ -0,0 +1,9 @@
+#define __no_sanitize_address __attribute__((no_sanitize_address))
+
+static void __no_sanitize_address bar(void)
+{
+}
+
+/*
+ * check-name: attribute no_sanitize_address
+ */
diff --git a/usr/src/tools/smatch/src/validation/attr-noclone.c b/usr/src/tools/smatch/src/validation/attr-noclone.c
new file mode 100644
index 0000000000..0a9cf70a14
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/attr-noclone.c
@@ -0,0 +1,9 @@
+#define noclone		__attribute__((__noclone__))
+
+static void noclone bar(void)
+{
+}
+
+/*
+ * check-name: attribute noclone
+ */
diff --git a/usr/src/tools/smatch/src/validation/attr-optimize.c b/usr/src/tools/smatch/src/validation/attr-optimize.c
new file mode 100644
index 0000000000..c45cbe8994
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/attr-optimize.c
@@ -0,0 +1,16 @@
+
+#define __noclone	__attribute__((__noclone__, __optimize__("no-tracer")))
+
+struct kvm_vcpu;
+
+static void __noclone vmx_vcpu_run(struct kvm_vcpu *vcpu)
+{
+	__asm__("");
+}
+
+extern void *run;
+void *run = vmx_vcpu_run;
+
+/*
+ * check-name: optimize attributes
+ */
diff --git a/usr/src/tools/smatch/src/validation/attr-warning.c b/usr/src/tools/smatch/src/validation/attr-warning.c
new file mode 100644
index 0000000000..1c0976f6ab
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/attr-warning.c
@@ -0,0 +1,8 @@
+# define __warndecl(name, msg) \
+  extern void name (void) __attribute__((__warning__ (msg)))
+
+__warndecl (__warn_func, "warn message");
+
+/*
+ * check-name: attribute warning
+ */
diff --git a/usr/src/tools/smatch/src/validation/attr_aligned.c b/usr/src/tools/smatch/src/validation/attr_aligned.c
new file mode 100644
index 0000000000..dc44e9fdd4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/attr_aligned.c
@@ -0,0 +1,6 @@
+void *foo(void) __attribute__((__assume_aligned__(4096)));
+void *foo(void) __attribute__((assume_aligned(4096)));
+/*
+ * check-name: attribute assume_aligned
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/attr_in_parameter.c b/usr/src/tools/smatch/src/validation/attr_in_parameter.c
new file mode 100644
index 0000000000..1b104ea43e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/attr_in_parameter.c
@@ -0,0 +1,12 @@
+#define A __attribute__((address_space(1)))
+static int (A *p);
+static int A *q;
+static void (*f)(A int *x, A int *y) = (void *)0;
+static void g(int A *x)
+{
+	f(x, x);
+	p = q;
+}
+/*
+ * check-name: attribute after ( in direct-declarator
+ */
diff --git a/usr/src/tools/smatch/src/validation/attr_vector_size.c b/usr/src/tools/smatch/src/validation/attr_vector_size.c
new file mode 100644
index 0000000000..69829228a2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/attr_vector_size.c
@@ -0,0 +1,7 @@
+typedef unsigned int u32;
+typedef u32 __attribute__((vector_size(16))) sse128_t;
+
+/*
+ * check-name: attribute vector_size
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/backend/arithmetic-ops.c b/usr/src/tools/smatch/src/validation/backend/arithmetic-ops.c
new file mode 100644
index 0000000000..55996d9c30
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/arithmetic-ops.c
@@ -0,0 +1,94 @@
+static int add(int x, int y)
+{
+	return x + y;
+}
+
+static unsigned int uadd(unsigned int x, unsigned int y)
+{
+	return x + y;
+}
+
+static float fadd(float x, float y)
+{
+	return x + y;
+}
+
+static double dadd(double x, double y)
+{
+	return x + y;
+}
+
+static int sub(int x, int y)
+{
+	return x - y;
+}
+
+static unsigned int usub(unsigned int x, unsigned int y)
+{
+	return x - y;
+}
+
+static float fsub(float x, float y)
+{
+	return x - y;
+}
+
+static double dsub(double x, double y)
+{
+	return x - y;
+}
+
+static int mul(int x, int y)
+{
+	return x * y;
+}
+
+static unsigned int umul(unsigned int x, unsigned int y)
+{
+	return x * y;
+}
+
+static float fmul(float x, float y)
+{
+	return x * y;
+}
+
+static double dmul(double x, double y)
+{
+	return x * y;
+}
+
+static int div(int x, int y)
+{
+	return x / y;
+}
+
+static unsigned int udiv(unsigned int x, unsigned int y)
+{
+	return x / y;
+}
+
+static float fdiv(float x, float y)
+{
+	return x / y;
+}
+
+static double ddiv(double x, double y)
+{
+	return x / y;
+}
+
+static int mod(int x, int y)
+{
+	return x % y;
+}
+
+static unsigned int umod(unsigned int x, unsigned int y)
+{
+	return x % y;
+}
+
+/*
+ * check-name: Arithmetic operator code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/array.c b/usr/src/tools/smatch/src/validation/backend/array.c
new file mode 100644
index 0000000000..4e87b79eee
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/array.c
@@ -0,0 +1,6 @@
+static char array[128];
+
+/*
+ * check-name: Array code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/bitwise-ops.c b/usr/src/tools/smatch/src/validation/backend/bitwise-ops.c
new file mode 100644
index 0000000000..9f61fca145
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/bitwise-ops.c
@@ -0,0 +1,64 @@
+static int shl(int x, int y)
+{
+	return x << y;
+}
+
+static unsigned int ushl(unsigned int x, unsigned int y)
+{
+	return x << y;
+}
+
+static int shr(int x, int y)
+{
+	return x >> y;
+}
+
+static unsigned int ushr(unsigned int x, unsigned int y)
+{
+	return x >> y;
+}
+
+static int and(int x, int y)
+{
+	return x & y;
+}
+
+static unsigned int uand(unsigned int x, unsigned int y)
+{
+	return x & y;
+}
+
+static int or(int x, int y)
+{
+	return x | y;
+}
+
+static unsigned int uor(unsigned int x, unsigned int y)
+{
+	return x | y;
+}
+
+static int xor(int x, int y)
+{
+	return x ^ y;
+}
+
+static unsigned int uxor(unsigned int x, unsigned int y)
+{
+	return x ^ y;
+}
+
+static int not(int x)
+{
+	return ~x;
+}
+
+static unsigned int unot(unsigned int x)
+{
+	return ~x;
+}
+
+/*
+ * check-name: Bitwise operator code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/bool-test.c b/usr/src/tools/smatch/src/validation/backend/bool-test.c
new file mode 100644
index 0000000000..cd20a4bd9a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/bool-test.c
@@ -0,0 +1,9 @@
+static _Bool return_false(void)
+{
+	return 0;
+}
+
+/*
+ * check-name: Boolean type code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/cast.c b/usr/src/tools/smatch/src/validation/backend/cast.c
new file mode 100644
index 0000000000..4ca531b53a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/cast.c
@@ -0,0 +1,50 @@
+typedef _Bool bool;
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+typedef unsigned long ulong;
+typedef long long longlong;
+typedef unsigned long long ulonglong;
+
+#define DEFINE_CAST(from, to)			\
+	static to from##2##to(from x) {		\
+		return x;			\
+	}
+
+#define DEFINE_CASTS(from)			\
+	DEFINE_CAST(from, bool)			\
+	DEFINE_CAST(from, char)			\
+	DEFINE_CAST(from, uchar)		\
+	DEFINE_CAST(from, short)		\
+	DEFINE_CAST(from, ushort)		\
+	DEFINE_CAST(from, int)			\
+	DEFINE_CAST(from, uint)			\
+	DEFINE_CAST(from, long)			\
+	DEFINE_CAST(from, ulong)		\
+	DEFINE_CAST(from, longlong)		\
+	DEFINE_CAST(from, ulonglong)		\
+/*
+	DEFINE_CAST(from, float)		\
+	DEFINE_CAST(from, double)
+*/
+
+DEFINE_CASTS(bool)
+DEFINE_CASTS(char)
+DEFINE_CASTS(uchar)
+DEFINE_CASTS(short)
+DEFINE_CASTS(ushort)
+DEFINE_CASTS(int)
+DEFINE_CASTS(uint)
+DEFINE_CASTS(long)
+DEFINE_CASTS(ulong)
+DEFINE_CASTS(longlong)
+DEFINE_CASTS(ulonglong)
+/*
+DEFINE_CASTS(float)
+DEFINE_CASTS(double)
+*/
+
+/*
+ * check-name: Cast code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/cmp-ops.c b/usr/src/tools/smatch/src/validation/backend/cmp-ops.c
new file mode 100644
index 0000000000..c7918da1aa
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/cmp-ops.c
@@ -0,0 +1,84 @@
+static int sete(int x, int y)
+{
+	return x == y;
+}
+
+static int setne(int x, int y)
+{
+	return x != y;
+}
+
+static int setl(int x, int y)
+{
+	return x < y;
+}
+
+static int setg(int x, int y)
+{
+	return x > y;
+}
+
+static int setle(int x, int y)
+{
+	return x <= y;
+}
+
+static int setge(int x, int y)
+{
+	return x >= y;
+}
+
+static int setb(unsigned int x, unsigned int y)
+{
+	return x < y;
+}
+
+static int seta(unsigned int x, unsigned int y)
+{
+	return x > y;
+}
+
+static int setbe(unsigned int x, unsigned int y)
+{
+	return x <= y;
+}
+
+static int setae(unsigned int x, unsigned int y)
+{
+	return x >= y;
+}
+
+static int setfe(float x, float y)
+{
+	return x == y;
+}
+
+static int setfne(float x, float y)
+{
+	return x != y;
+}
+
+static int setfl(float x, float y)
+{
+	return x < y;
+}
+
+static int setfg(float x, float y)
+{
+	return x > y;
+}
+
+static int setfle(float x, float y)
+{
+	return x <= y;
+}
+
+static int setfge(float x, float y)
+{
+	return x >= y;
+}
+
+/*
+ * check-name: Comparison operator code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/extern.c b/usr/src/tools/smatch/src/validation/backend/extern.c
new file mode 100644
index 0000000000..b5c14d8426
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/extern.c
@@ -0,0 +1,11 @@
+extern unsigned long foo;
+
+static unsigned long bar(void)
+{
+	return foo;
+}
+
+/*
+ * check-name: Extern symbol code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/function-ptr.c b/usr/src/tools/smatch/src/validation/backend/function-ptr.c
new file mode 100644
index 0000000000..35fb678af0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/function-ptr.c
@@ -0,0 +1,11 @@
+typedef int (*fn_t)(int x, int y);
+
+static int run(fn_t fn, int x, int y)
+{
+	return fn(x, y);
+}
+
+/*
+ * check-name: Function pointer code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/hello.c b/usr/src/tools/smatch/src/validation/backend/hello.c
new file mode 100644
index 0000000000..b0e514be4f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/hello.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+	puts("hello, world");
+
+	return 0;
+}
+
+/*
+ * check-name: 'hello, world' code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/int-cond.c b/usr/src/tools/smatch/src/validation/backend/int-cond.c
new file mode 100644
index 0000000000..2a5a43482f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/int-cond.c
@@ -0,0 +1,30 @@
+static long foo(long a, long b, long c)
+{
+	return a? b:c;
+}
+
+static long foo_bool(_Bool a, long b, long c)
+{
+	return a? b:c;
+}
+
+static long bar(long a, long b, long c)
+{
+	if (a)
+		return b;
+	else
+		return b + c;
+}
+
+static long bar_bool(_Bool a, long b, long c)
+{
+	if (a)
+		return b;
+	else
+		return b + c;
+}
+
+/*
+ * check-name: Non-bool condition values in branch/select
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/load-type.c b/usr/src/tools/smatch/src/validation/backend/load-type.c
new file mode 100644
index 0000000000..8255676947
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/load-type.c
@@ -0,0 +1,12 @@
+extern struct _IO_FILE *stdin;
+
+static void sub(struct _IO_FILE *in) {}
+
+static void test(void) {
+        sub(stdin);
+}
+
+/*
+ * check-name: Type of loaded objects
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/logical-ops.c b/usr/src/tools/smatch/src/validation/backend/logical-ops.c
new file mode 100644
index 0000000000..ec5b7c6dc4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/logical-ops.c
@@ -0,0 +1,24 @@
+static int and_bool(int x, int y)
+{
+	return x && y;
+}
+
+static unsigned int uand_bool(unsigned int x, unsigned int y)
+{
+	return x && y;
+}
+
+static int or_bool(int x, int y)
+{
+	return x || y;
+}
+
+static unsigned int uor_bool(unsigned int x, unsigned int y)
+{
+	return x || y;
+}
+
+/*
+ * check-name: Logical operator code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/loop.c b/usr/src/tools/smatch/src/validation/backend/loop.c
new file mode 100644
index 0000000000..181a006895
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/loop.c
@@ -0,0 +1,21 @@
+ 
+extern int bar (int);
+
+extern int foo (int);
+   
+int foo (int x)
+{
+	int y = 0;
+   
+	while (y < 1000) {
+		y += bar(x);
+	}
+   
+	return y;
+}
+    
+
+/*
+ * check-name: Loops
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/loop2.c b/usr/src/tools/smatch/src/validation/backend/loop2.c
new file mode 100644
index 0000000000..d827b5d327
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/loop2.c
@@ -0,0 +1,14 @@
+extern int op(void);
+
+static void test(void)
+{
+	int i;
+	for (i = 0; ; i++) {
+		op();
+	}
+}
+
+/*
+ * check-name: Loops with unused counter
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/ptrcast.c b/usr/src/tools/smatch/src/validation/backend/ptrcast.c
new file mode 100644
index 0000000000..8e4df0700c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/ptrcast.c
@@ -0,0 +1,9 @@
+static char *ptrcast(unsigned long *x)
+{
+	return (unsigned char *) x;
+}
+
+/*
+ * check-name: Pointer cast code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/store-type.c b/usr/src/tools/smatch/src/validation/backend/store-type.c
new file mode 100644
index 0000000000..2246a3b3bf
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/store-type.c
@@ -0,0 +1,12 @@
+struct foo;
+static struct foo *var;
+
+static void set(struct foo *f)
+{
+       var = f;
+}
+
+/*
+ * check-name: Type of stored objects
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/struct-access.c b/usr/src/tools/smatch/src/validation/backend/struct-access.c
new file mode 100644
index 0000000000..3d193e3315
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/struct-access.c
@@ -0,0 +1,28 @@
+struct st {
+	int i, *d;
+};
+
+static int load_i(struct st *st)
+{
+	return st->i;
+}
+
+static void store_i(struct st *st, int i)
+{
+	st->i = i;
+}
+
+static int *load_d(struct st *st)
+{
+	return st->d;
+}
+
+static void store_d(struct st *st, int *d)
+{
+	st->d = d;
+}
+
+/*
+ * check-name: struct access code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/struct.c b/usr/src/tools/smatch/src/validation/backend/struct.c
new file mode 100644
index 0000000000..083b05c3b8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/struct.c
@@ -0,0 +1,25 @@
+struct ctype {
+	int			type;
+};
+
+struct symbol {
+	void			*p;
+	const char		*name;
+	struct ctype		ctype;
+	struct symbol		*next_id;
+};
+
+struct unnamed {
+	struct { int x, y; };
+};
+
+static struct symbol sym;
+static struct symbol *sym_p;
+static struct symbol *sym_q = &sym;
+
+static struct unnamed un;
+
+/*
+ * check-name: Struct code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/sum.c b/usr/src/tools/smatch/src/validation/backend/sum.c
new file mode 100644
index 0000000000..06042999f4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/sum.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+static int sum(int n)
+{
+	int i, result = 0;
+
+	for (i = 1; i <= n; ++i)
+		result += i;
+	return result;
+}
+
+int main(int argc, char **argv)
+{
+	printf("%d\n", sum(5));
+	printf("%d\n", sum(100));
+	return 0;
+}
+
+/*
+ * check-name: sum from 1 to n
+ * check-command: sparsei $file
+ *
+ * check-output-start
+15
+5050
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/union.c b/usr/src/tools/smatch/src/validation/backend/union.c
new file mode 100644
index 0000000000..7ec35c7a8d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/union.c
@@ -0,0 +1,12 @@
+union foo {
+	unsigned long		x;
+	unsigned char		y;
+	char			buf[128];
+};
+
+static union foo foo;
+
+/*
+ * check-name: Union code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/backend/void-return-type.c b/usr/src/tools/smatch/src/validation/backend/void-return-type.c
new file mode 100644
index 0000000000..e540a9d410
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/backend/void-return-type.c
@@ -0,0 +1,13 @@
+static void foo(void)
+{
+}
+
+static void *bar(void *p)
+{
+	return p;
+}
+
+/*
+ * check-name: void return type code generation
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/bad-array-designated-initializer.c b/usr/src/tools/smatch/src/validation/bad-array-designated-initializer.c
new file mode 100644
index 0000000000..fb7d91f8b3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bad-array-designated-initializer.c
@@ -0,0 +1,13 @@
+static int a[] = {
+	[0] = 0,		// OK
+	[\0] = 1,		// KO
+};
+/*
+ * check-name: Bad array designated initializer
+ *
+ * check-error-start
+bad-array-designated-initializer.c:3:10: error: Expected constant expression
+bad-array-designated-initializer.c:3:10: error: Expected } at end of initializer
+bad-array-designated-initializer.c:3:10: error: got \
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/bad-assignment.c b/usr/src/tools/smatch/src/validation/bad-assignment.c
new file mode 100644
index 0000000000..71938db7c4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bad-assignment.c
@@ -0,0 +1,14 @@
+static int foo(int a)
+{
+	a |=\1;
+
+	return a;
+}
+/*
+ * check-name: bad assignment
+ *
+ * check-error-start
+bad-assignment.c:3:13: error: Expected ; at end of statement
+bad-assignment.c:3:13: error: got \
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/bad-cast.c b/usr/src/tools/smatch/src/validation/bad-cast.c
new file mode 100644
index 0000000000..bf577e0094
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bad-cast.c
@@ -0,0 +1,15 @@
+struct st;
+
+static int foo(int a)
+{
+	return (struct/st *) a;
+}
+/*
+ * check-name: Bad cast syntax
+ *
+ * check-error-start
+bad-cast.c:5:23: error: expected declaration
+bad-cast.c:5:23: error: Expected ) at end of cast operator
+bad-cast.c:5:23: error: got /
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/bad-ternary-cond.c b/usr/src/tools/smatch/src/validation/bad-ternary-cond.c
new file mode 100644
index 0000000000..e3d07b5171
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bad-ternary-cond.c
@@ -0,0 +1,12 @@
+static int foo(int a)
+{
+	return a ?? 1 : 0;
+}
+/*
+ * check-name: Bad ternary syntax
+ * check-description: Once caused Sparse to segfault
+ * check-error-start
+bad-ternary-cond.c:3:19: error: Expected : in conditional expression
+bad-ternary-cond.c:3:19: error: got ?
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/bad-typeof.c b/usr/src/tools/smatch/src/validation/bad-typeof.c
new file mode 100644
index 0000000000..90c3e424c4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bad-typeof.c
@@ -0,0 +1,14 @@
+static int fun(void)
+{
+	typeof() a;
+	int b;
+
+	a = b;
+}
+/*
+ * check-name: Bad typeof syntax segfault
+ *
+ * check-error-start
+bad-typeof.c:3:16: error: expected expression after the '(' token
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/badtype1.c b/usr/src/tools/smatch/src/validation/badtype1.c
new file mode 100644
index 0000000000..b15cb50e8a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/badtype1.c
@@ -0,0 +1,10 @@
+static void foo(enum bar baz);
+
+/*
+ * check-name: enum not in scope
+ * check-known-to-fail
+ *
+ * check-error-start
+badtype1.c:1:22: warning: bad scope for 'enum bar'
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/badtype2.c b/usr/src/tools/smatch/src/validation/badtype2.c
new file mode 100644
index 0000000000..49fec87ce0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/badtype2.c
@@ -0,0 +1,25 @@
+//typedef int undef;
+extern undef bar(void);
+static undef foo(char *c)
+{
+  char p = *c;
+  switch (p) {
+  default:
+    return bar();
+  }
+}
+
+/*
+ * check-name: missing type
+ * check-error-start
+badtype2.c:2:8: warning: 'undef' has implicit type
+badtype2.c:2:14: error: Expected ; at end of declaration
+badtype2.c:2:14: error: got bar
+badtype2.c:3:14: error: Expected ; at end of declaration
+badtype2.c:3:14: error: got foo
+badtype2.c:6:3: error: Trying to use reserved word 'switch' as identifier
+badtype2.c:7:3: error: not in switch scope
+badtype2.c:10:1: error: Expected ; at the end of type declaration
+badtype2.c:10:1: error: got }
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/badtype3.c b/usr/src/tools/smatch/src/validation/badtype3.c
new file mode 100644
index 0000000000..20f346c574
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/badtype3.c
@@ -0,0 +1,27 @@
+int
+foo (int (*func) (undef, void *), void *data)
+{
+  int err = 0;
+  while (cur) {
+    if ((*func) (cur, data))
+      break;
+  }
+  return err;
+}
+
+/*
+ * check-name: missing type in argument list
+ * check-error-start
+badtype3.c:2:18: warning: identifier list not in definition
+badtype3.c:2:24: error: Expected ) in function declarator
+badtype3.c:2:24: error: got ,
+badtype3.c:5:3: error: Trying to use reserved word 'while' as identifier
+badtype3.c:7:7: error: break/continue not in iterator scope
+badtype3.c:9:3: error: Trying to use reserved word 'return' as identifier
+badtype3.c:9:10: error: Expected ; at end of declaration
+badtype3.c:9:10: error: got err
+badtype3.c:10:1: error: Expected ; at the end of type declaration
+badtype3.c:10:1: error: got }
+badtype3.c:6:11: error: undefined identifier 'func'
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/badtype4.c b/usr/src/tools/smatch/src/validation/badtype4.c
new file mode 100644
index 0000000000..7421ba4872
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/badtype4.c
@@ -0,0 +1,15 @@
+void a(void)
+{
+	switch(x) {
+	case 1:
+		break;
+	}
+}
+/*
+ * check-name: switch(bad_type) {...} segfault
+ *
+ * check-error-start
+badtype4.c:3:16: error: undefined identifier 'x'
+badtype4.c:4:14: error: incompatible types for 'case' statement
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/badtype5.c b/usr/src/tools/smatch/src/validation/badtype5.c
new file mode 100644
index 0000000000..c3c34ab230
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/badtype5.c
@@ -0,0 +1,18 @@
+#define	__force		__attribute__((force))
+
+int foo(int *addr);
+int foo(int *addr)
+{
+	return *(*((typeof(addr) __force *) addr));
+}
+
+/*
+ * check-name: badtype5.c
+ * check-description:
+ *	evaluate_dereference() used to miss a call to
+ *	examine_symbol_type(). This, in the present, left
+ *	a SYM_TYPEOF as type for the last dereferencing
+ *	which produced "error: cannot dereference this type".
+ *	The presence of the __force and the typeof is needed
+ *	to create the situation.
+ */
diff --git a/usr/src/tools/smatch/src/validation/binary-constant.c b/usr/src/tools/smatch/src/validation/binary-constant.c
new file mode 100644
index 0000000000..c4ae04546f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/binary-constant.c
@@ -0,0 +1,7 @@
+extern int x;
+
+int x = 0b11;
+
+/*
+ * check-name: binary constant
+ */
diff --git a/usr/src/tools/smatch/src/validation/bitfield-size.c b/usr/src/tools/smatch/src/validation/bitfield-size.c
new file mode 100644
index 0000000000..ce78ecf217
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bitfield-size.c
@@ -0,0 +1,41 @@
+struct bfu {
+	unsigned int a:4;
+	unsigned int  :2;
+	unsigned int b:4;
+};
+unsigned int get__bfu_a(struct bfu bf) { return bf.a; }
+unsigned int get__bfu_b(struct bfu bf) { return bf.b; }
+unsigned int get_pbfu_a(struct bfu *bf) { return bf->a; }
+unsigned int get_pbfu_b(struct bfu *bf) { return bf->b; }
+
+
+struct bfs {
+	signed int a:4;
+	signed int  :2;
+	signed int b:4;
+};
+signed int get__bfs_a(struct bfs bf) { return bf.a; }
+signed int get__bfs_b(struct bfs bf) { return bf.b; }
+signed int get_pbfs_a(struct bfs *bf) { return bf->a; }
+signed int get_pbfs_b(struct bfs *bf) { return bf->b; }
+
+
+struct bfi {
+	int a:4;
+	int  :2;
+	int b:4;
+};
+unsigned int get__bfi_a(struct bfi bf) { return bf.a; }
+unsigned int get__bfi_b(struct bfi bf) { return bf.b; }
+unsigned int get_pbfi_a(struct bfi *bf) { return bf->a; }
+unsigned int get_pbfi_b(struct bfi *bf) { return bf->b; }
+
+/*
+ * check-name: bitfield size
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-pattern-24-times: cast\\.
+ * check-output-pattern-12-times: cast\\.4
+ * check-output-pattern-6-times: lsr\\..*\\$6
+ */
diff --git a/usr/src/tools/smatch/src/validation/bitfields.c b/usr/src/tools/smatch/src/validation/bitfields.c
new file mode 100644
index 0000000000..ea24841fcb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bitfields.c
@@ -0,0 +1,21 @@
+/*
+ * Al Viro points out that we don't
+ * do bitfield -> integer promotions
+ * for array dereferences
+ *
+ * "warning: a.c:16:10: incompatible types for operation"
+ */
+static struct {
+	int x:4;
+} y;
+
+extern int a[];
+
+static int b(void)
+{
+	return a[y.x];
+}
+
+/*
+ * check-name: bitfield to integer promotion
+ */
diff --git a/usr/src/tools/smatch/src/validation/bitwise-cast.c b/usr/src/tools/smatch/src/validation/bitwise-cast.c
new file mode 100644
index 0000000000..baeca29e75
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bitwise-cast.c
@@ -0,0 +1,44 @@
+typedef unsigned int u32;
+typedef u32 __attribute__((bitwise)) __be32;
+
+/* Implicit casts of 0, legal */
+static __be32 foo(void)
+{
+	__be32 x = 0;
+
+	return 0;
+}
+
+/* Explicit cast of 0, legal */
+static __be32 bar(void)
+{
+	return (__be32)0;
+}
+
+/* Implicit casts of nonzero, bad */
+static __be32 baz(void)
+{
+	__be32 x = 0x2a;
+
+	return 99;
+}
+
+/* Explicit cast of nonzero, bad */
+static __be32 quux(void)
+{
+	return (__be32)1729;
+}
+
+/*
+ * check-name: conversions to bitwise types
+ * check-command: sparse -Wbitwise $file
+ * check-error-start
+bitwise-cast.c:21:20: warning: incorrect type in initializer (different base types)
+bitwise-cast.c:21:20:    expected restricted __be32 [usertype] x
+bitwise-cast.c:21:20:    got int
+bitwise-cast.c:23:16: warning: incorrect type in return expression (different base types)
+bitwise-cast.c:23:16:    expected restricted __be32
+bitwise-cast.c:23:16:    got int
+bitwise-cast.c:29:17: warning: cast to restricted __be32
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/bool-array.c b/usr/src/tools/smatch/src/validation/bool-array.c
new file mode 100644
index 0000000000..6c4c872349
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bool-array.c
@@ -0,0 +1,47 @@
+static _Bool boolarray_d1[1];
+static _Bool boolarray_d8[8];
+static _Bool boolarray_i2[2] = {
+	0,
+	1,
+};
+static int nd1 = sizeof(boolarray_d1);
+static int nd8 = sizeof(boolarray_d8);
+static int ni2 = sizeof(boolarray_i2);
+
+
+static long longarray_u2[] = {
+	0,
+	1,
+};
+static int nl2 = sizeof(longarray_u2);
+
+/*
+ * Used to get "warning: excessive elements in array initializer"
+ * for all elements but the first one.
+ * Note: only occurs if nbr of elements is a multiple of 8
+ *       (if not, theer was another problem)
+ */
+static _Bool boolarray_u8[] = {
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+};
+
+/*
+ * Used to get "error: cannot size expression" for the sizeof.
+ */
+static _Bool boolarray_u2[] = {
+	0,
+	1,
+};
+static int nu2 = sizeof(boolarray_u2);
+
+/*
+ * check-name: sizeof(bool array)
+ * check-command: sparse -Wno-sizeof-bool $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/bool-cast-bad.c b/usr/src/tools/smatch/src/validation/bool-cast-bad.c
new file mode 100644
index 0000000000..ae8b960186
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bool-cast-bad.c
@@ -0,0 +1,23 @@
+typedef unsigned short __attribute__((bitwise)) le16;
+struct s {
+	int a:2;
+	int b:2;
+	int c:2;
+};
+
+static _Bool fresi(le16 a)     { return a; }
+static _Bool frese(le16 a)     { return (_Bool)a; }
+static _Bool fstsi(struct s a) { return a; }
+static _Bool fstse(struct s a) { return (_Bool)a; }
+
+/*
+ * check-name: bool-cast-bad.c
+ * check-command: sparse $file
+ *
+ * check-error-start
+bool-cast-bad.c:10:41: warning: incorrect type in return expression (different base types)
+bool-cast-bad.c:10:41:    expected bool
+bool-cast-bad.c:10:41:    got struct s a
+bool-cast-bad.c:11:42: warning: cast from non-scalar
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/bool-cast-explicit.c b/usr/src/tools/smatch/src/validation/bool-cast-explicit.c
new file mode 100644
index 0000000000..dbb67cc420
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bool-cast-explicit.c
@@ -0,0 +1,22 @@
+typedef unsigned int	u32;
+typedef          int	s32;
+typedef void *vdp;
+typedef int  *sip;
+typedef double dbl;
+typedef unsigned short __attribute__((bitwise)) le16;
+
+static _Bool fs32(s32 a) { return (_Bool)a; }
+static _Bool fu32(u32 a) { return (_Bool)a; }
+static _Bool fvdp(vdp a) { return (_Bool)a; }
+static _Bool fsip(sip a) { return (_Bool)a; }
+static _Bool fdbl(dbl a) { return (_Bool)a; }
+static _Bool ffun(void)  { return (_Bool)ffun; }
+
+static _Bool fres(le16 a) { return (_Bool)a; }
+
+/*
+ * check-name: bool-cast-explicit
+ * check-command: test-linearize -m64 $file
+ * check-output-ignore
+ * check-output-excludes: cast\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/bool-cast-implicit.c b/usr/src/tools/smatch/src/validation/bool-cast-implicit.c
new file mode 100644
index 0000000000..9d89443b10
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bool-cast-implicit.c
@@ -0,0 +1,25 @@
+typedef unsigned int	u32;
+typedef          int	s32;
+typedef void *vdp;
+typedef int  *sip;
+typedef double dbl;
+typedef unsigned short __attribute__((bitwise)) le16;
+
+static _Bool fs32(s32 a) { return a; }
+static _Bool fu32(u32 a) { return a; }
+static _Bool fvdp(vdp a) { return a; }
+static _Bool fsip(sip a) { return a; }
+static _Bool fdbl(dbl a) { return a; }
+static _Bool ffun(void)  { return ffun; }
+
+static _Bool fres(le16 a) { return a; }
+
+/*
+ * check-name: bool-cast-implicit
+ * check-command: test-linearize -m64 $file
+ * check-output-ignore
+ * check-output-excludes: cast\\.
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/bool-cast-restricted.c b/usr/src/tools/smatch/src/validation/bool-cast-restricted.c
new file mode 100644
index 0000000000..9985d6e320
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bool-cast-restricted.c
@@ -0,0 +1,43 @@
+typedef unsigned   int __attribute__((bitwise)) large_t;
+#define	LBIT	((__attribute__((force)) large_t) 1)
+
+_Bool lfoo(large_t x) { return x; }
+_Bool qfoo(large_t x) { _Bool r = x; return r; }
+_Bool xfoo(large_t x) { return (_Bool)x; }
+_Bool lbar(large_t x) { return ~x; }
+_Bool qbar(large_t x) { _Bool r = ~x; return r; }
+_Bool xbar(large_t x) { return (_Bool)~x; }
+_Bool lbaz(large_t x) { return !x; }
+_Bool qbaz(large_t x) { _Bool r = !x; return r; }
+_Bool xbaz(large_t x) { return (_Bool)!x; }
+_Bool lqux(large_t x) { return x & LBIT; }
+_Bool qqux(large_t x) { _Bool r = x & LBIT; return r; }
+_Bool xqux(large_t x) { return (_Bool)(x & LBIT); }
+
+
+typedef unsigned short __attribute__((bitwise)) small_t;
+#define	SBIT	((__attribute__((force)) small_t) 1)
+
+_Bool sfoo(small_t x) { return x; }
+_Bool tfoo(small_t x) { _Bool r = x; return r; }
+_Bool zfoo(small_t x) { return (_Bool)x; }
+_Bool sbar(small_t x) { return ~x; }
+_Bool tbar(small_t x) { _Bool r = ~x; return r; }
+_Bool zbar(small_t x) { return (_Bool)~x; }
+_Bool sbaz(small_t x) { return !x; }
+_Bool tbaz(small_t x) { _Bool r = !x; return r; }
+_Bool zbaz(small_t x) { return (_Bool)!x; }
+_Bool squx(small_t x) { return x & SBIT; }
+_Bool tqux(small_t x) { _Bool r = x & SBIT; return r; }
+_Bool zqux(small_t x) { return (_Bool)(x & SBIT); }
+
+/*
+ * check-name: bool-cast-restricted.c
+ * check-command: sparse -Wno-decl $file
+ *
+ * check-error-start
+bool-cast-restricted.c:24:32: warning: restricted small_t degrades to integer
+bool-cast-restricted.c:25:35: warning: restricted small_t degrades to integer
+bool-cast-restricted.c:26:33: warning: restricted small_t degrades to integer
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/bswap-constant-folding.c b/usr/src/tools/smatch/src/validation/bswap-constant-folding.c
new file mode 100644
index 0000000000..c6511fe620
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bswap-constant-folding.c
@@ -0,0 +1,28 @@
+typedef unsigned short __be16;
+typedef unsigned short __u16;
+typedef unsigned short u16;
+#define __force
+
+#define __swab16(x) (__u16)__builtin_bswap16((__u16)(x))
+/* the test behaves as though it's always on a little-endian machine */
+#define __cpu_to_be16(x) ((__force __be16)__swab16((x)))
+#define ___htons(x) __cpu_to_be16(x)
+#define htons(x) ___htons(x)
+
+#define ETH_P_IPV6 0x86DD
+
+static u16 protocol;
+
+static void test(void)
+{
+	switch (protocol) {
+	case htons(ETH_P_IPV6):
+		break;
+	}
+}
+
+/*
+ * check-name: constant folding in bswap builtins
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/bug_inline_switch.c b/usr/src/tools/smatch/src/validation/bug_inline_switch.c
new file mode 100644
index 0000000000..957882405a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/bug_inline_switch.c
@@ -0,0 +1,25 @@
+
+#define __u16 unsigned short
+int foo(__u16 n);
+static inline __u16 f(__u16 val)
+{
+       return val;
+}
+
+static inline unsigned int bar(__u16 n)
+{
+      switch (n) {
+      case (1 ? 1 : f(1)):
+              return 4;
+      }
+}
+
+int foo(__u16 n)
+{
+       bar(n);
+       bar(n);
+       return 0;
+}
+/*
+ * check-name: inlining switch statement
+ */
diff --git a/usr/src/tools/smatch/src/validation/build_smatch_db.sh b/usr/src/tools/smatch/src/validation/build_smatch_db.sh
new file mode 100755
index 0000000000..ce171d8c5b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/build_smatch_db.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+../smatch --info $* > warns.txt
+../smatch_data/db/create_db.sh warns.txt > /dev/null 2>&1
+
diff --git a/usr/src/tools/smatch/src/validation/builtin-args-checking.c b/usr/src/tools/smatch/src/validation/builtin-args-checking.c
new file mode 100644
index 0000000000..55f34d2bcc
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/builtin-args-checking.c
@@ -0,0 +1,45 @@
+static unsigned int bad_nbr_args_cte(int a)
+{
+	int r = 0;
+	r |= __builtin_bswap16();
+	r |= __builtin_bswap16(1, 2);
+	r |= __builtin_bswap32();
+	r |= __builtin_bswap32(1, 2);
+	r |= __builtin_bswap64();
+	r |= __builtin_bswap64(1, 2);
+	return r;
+}
+
+static unsigned int bad_nbr_args_var(int a, int b)
+{
+	int r = 0;
+	r |= __builtin_bswap16();
+	r |= __builtin_bswap16(a, b);
+	r |= __builtin_bswap32();
+	r |= __builtin_bswap32(a, b);
+	r |= __builtin_bswap64();
+	r |= __builtin_bswap64(a, b);
+	return r;
+}
+
+/*
+ * check-name: builtin-args-checking
+ * check-command: sparse $file
+ * check-description: Check that the arguments checking is done
+ *                    for expanded builtins with a prototype.
+ *
+ * check-error-start
+builtin-args-checking.c:4:31: error: not enough arguments for function __builtin_bswap16
+builtin-args-checking.c:5:31: error: too many arguments for function __builtin_bswap16
+builtin-args-checking.c:6:31: error: not enough arguments for function __builtin_bswap32
+builtin-args-checking.c:7:31: error: too many arguments for function __builtin_bswap32
+builtin-args-checking.c:8:31: error: not enough arguments for function __builtin_bswap64
+builtin-args-checking.c:9:31: error: too many arguments for function __builtin_bswap64
+builtin-args-checking.c:16:31: error: not enough arguments for function __builtin_bswap16
+builtin-args-checking.c:17:31: error: too many arguments for function __builtin_bswap16
+builtin-args-checking.c:18:31: error: not enough arguments for function __builtin_bswap32
+builtin-args-checking.c:19:31: error: too many arguments for function __builtin_bswap32
+builtin-args-checking.c:20:31: error: not enough arguments for function __builtin_bswap64
+builtin-args-checking.c:21:31: error: too many arguments for function __builtin_bswap64
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/builtin-bswap-constant.c b/usr/src/tools/smatch/src/validation/builtin-bswap-constant.c
new file mode 100644
index 0000000000..18574d4c55
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/builtin-bswap-constant.c
@@ -0,0 +1,34 @@
+unsigned short bswap16(void);
+unsigned short bswap16(void)
+{
+	return __builtin_bswap16(0x1234);
+}
+
+unsigned int bswap32(void);
+unsigned int bswap32(void)
+{
+	return __builtin_bswap32(0x12345678);
+}
+
+unsigned long long bswap64(void);
+unsigned long long bswap64(void)
+{
+	return __builtin_bswap64(0x123456789abcdef0ULL);
+}
+
+unsigned int half_constant(void);
+unsigned int half_constant(void)
+{
+	int v = 0x12345678;
+	return __builtin_bswap32(v);
+}
+/*
+ * check-name: builtin-bswap-constant
+ * check-command: test-linearize $file
+ *
+ * check-output-ignore
+ * check-output-excludes: __builtin_bswap
+ * check-output-contains:ret.16 *.0x3412
+ * check-output-contains:ret.32 *.0x78563412
+ * check-output-contains:ret.64 *.0xf0debc9a78563412
+ */
diff --git a/usr/src/tools/smatch/src/validation/builtin-bswap-variable.c b/usr/src/tools/smatch/src/validation/builtin-bswap-variable.c
new file mode 100644
index 0000000000..738ba2a450
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/builtin-bswap-variable.c
@@ -0,0 +1,32 @@
+typedef unsigned short	   u16;
+typedef unsigned int	   u32;
+typedef unsigned long long u64;
+
+static u16 swap16v(u16 a)
+{
+	return __builtin_bswap16(a);
+}
+
+static u32 swap32v(u64 a)
+{
+	return __builtin_bswap32(a);
+}
+
+static u64 swap64v(u32 a)
+{
+	return __builtin_bswap64(a);
+}
+
+/*
+ * check-name: builtin-bswap
+ * check-command: test-linearize $file
+ * check-description: Check that the right builtin function is called, and
+ *                    that the args are correctly promoted or truncated.
+ *
+ * check-output-ignore
+ * check-output-contains:call.16 .* __builtin_bswap16
+ * check-output-contains:cast.32 .* (64) %arg1
+ * check-output-contains:call.32 .* __builtin_bswap32
+ * check-output-contains:cast.64 .* (32) %arg1
+ * check-output-contains:call.64 .* __builtin_bswap64
+ */
diff --git a/usr/src/tools/smatch/src/validation/builtin_atomic.c b/usr/src/tools/smatch/src/validation/builtin_atomic.c
new file mode 100644
index 0000000000..e56321a867
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/builtin_atomic.c
@@ -0,0 +1,28 @@
+static void fn(void)
+{
+	static int i, *ptr = (void *)0;
+
+	i = __sync_fetch_and_add(ptr, 0);
+	i = __sync_fetch_and_sub(ptr, 0);
+	i = __sync_fetch_and_or(ptr, 0);
+	i = __sync_fetch_and_and(ptr, 0);
+	i = __sync_fetch_and_xor(ptr, 0);
+	i = __sync_fetch_and_nand(ptr, 0);
+	i = __sync_add_and_fetch(ptr, 0);
+	i = __sync_sub_and_fetch(ptr, 0);
+	i = __sync_or_and_fetch(ptr, 0);
+	i = __sync_and_and_fetch(ptr, 0);
+	i = __sync_xor_and_fetch(ptr, 0);
+	i = __sync_nand_and_fetch(ptr, 0);
+	i = __sync_bool_compare_and_swap(ptr, 0, 1);
+	i = __sync_val_compare_and_swap(ptr, 0, 1);
+	__sync_synchronize();
+	i = __sync_lock_test_and_set(ptr, 0);
+	__sync_lock_release(ptr);
+}
+
+/*
+ * check-name: __builtin_atomic
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/builtin_bswap.c b/usr/src/tools/smatch/src/validation/builtin_bswap.c
new file mode 100644
index 0000000000..6a4a9072e4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/builtin_bswap.c
@@ -0,0 +1,9 @@
+static unsigned short x = __builtin_bswap16(0);
+static unsigned int y = __builtin_bswap32(0);
+static unsigned long long z = __builtin_bswap64(0);
+
+/*
+ * check-name: __builtin_bswap
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/builtin_inf.c b/usr/src/tools/smatch/src/validation/builtin_inf.c
new file mode 100644
index 0000000000..f09f53f41b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/builtin_inf.c
@@ -0,0 +1,16 @@
+static double d = __builtin_huge_val();
+static float f = __builtin_huge_valf();
+static long double l = __builtin_huge_vall();
+static double di = __builtin_inf();
+static float fi = __builtin_inff();
+static long double li = __builtin_infl();
+static double dn = __builtin_nan("");
+static float fn = __builtin_nanf("");
+static long double ln = __builtin_nanl("");
+static int inf = __builtin_isinf_sign(0.0);
+static int fin = __builtin_isfinite(0.0);
+static int nan = __builtin_isnan(0.0);
+
+/*
+ * check-name: __builtin INFINITY / nan()
+ */
diff --git a/usr/src/tools/smatch/src/validation/builtin_safe1.c b/usr/src/tools/smatch/src/validation/builtin_safe1.c
new file mode 100644
index 0000000000..eeddcc82f7
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/builtin_safe1.c
@@ -0,0 +1,38 @@
+#define MY_MACRO(a) do { \
+  __builtin_warning(!__builtin_safe_p(a), "Macro argument with side effects: " #a); \
+    a;	\
+  } while (0)
+
+int g(int);
+int h(int) __attribute__((pure));
+int i(int) __attribute__((const));
+
+static int foo(int x, int y)
+{
+  /* unsafe: */
+  MY_MACRO(x++);
+  MY_MACRO(x+=1);
+  MY_MACRO(x=x+1);
+  MY_MACRO(x%=y);
+  MY_MACRO(x=y);
+  MY_MACRO(g(x));
+  MY_MACRO((y,g(x)));
+  /* safe: */
+  MY_MACRO(x+1);
+  MY_MACRO(h(x));
+  MY_MACRO(i(x));
+  return x;
+}
+
+/*
+ * check-name: __builtin_safe
+ * check-error-start
+builtin_safe1.c:13:3: warning: Macro argument with side effects: x++
+builtin_safe1.c:14:3: warning: Macro argument with side effects: x+=1
+builtin_safe1.c:15:3: warning: Macro argument with side effects: x=x+1
+builtin_safe1.c:16:3: warning: Macro argument with side effects: x%=y
+builtin_safe1.c:17:3: warning: Macro argument with side effects: x=y
+builtin_safe1.c:18:3: warning: Macro argument with side effects: g(x)
+builtin_safe1.c:19:3: warning: Macro argument with side effects: (y,g(x))
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/builtin_unreachable.c b/usr/src/tools/smatch/src/validation/builtin_unreachable.c
new file mode 100644
index 0000000000..29799b507d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/builtin_unreachable.c
@@ -0,0 +1,15 @@
+/* example from gcc documents */
+
+void function_that_never_returns (void);
+
+static int g (int c)
+{
+	if (c)
+		return 1;
+	function_that_never_returns ();
+	__builtin_unreachable ();
+}
+     
+/*
+ * check-name: __builtin_unreachable()
+ */
diff --git a/usr/src/tools/smatch/src/validation/builtin_va_arg_pack.c b/usr/src/tools/smatch/src/validation/builtin_va_arg_pack.c
new file mode 100644
index 0000000000..3426b86bf1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/builtin_va_arg_pack.c
@@ -0,0 +1,20 @@
+extern void v(int a, ...);
+
+extern inline __attribute__((__always_inline__)) void f(int a, ...)
+{
+	__SIZE_TYPE__ b = __builtin_va_arg_pack_len();
+}
+
+extern inline __attribute__((__always_inline__)) void g(int a, ...)
+{
+	v(a, __builtin_va_arg_pack());
+}
+
+static void h(void)
+{
+	f(0, 0);
+	g(0, 0);
+}
+/*
+ * check-name: __builtin_va_arg_pack()
+ */
diff --git a/usr/src/tools/smatch/src/validation/c11-alignas.c b/usr/src/tools/smatch/src/validation/c11-alignas.c
new file mode 100644
index 0000000000..4b264a5dc2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/c11-alignas.c
@@ -0,0 +1,40 @@
+static _Alignas(8)	int v;
+static _Alignas(long)	int t;
+static _Alignas(void *)	int p;
+static _Alignas(int[4])	int a;
+static _Alignas(0)	int z;
+static _Alignas(3)	int bnpow2;
+static _Alignas(-1)	int bneg;
+static _Alignas(-2)	int bnegpow2;
+static _Alignas(v)	int bnc;
+static _Alignas(+)	int bsyn;
+
+static int check(void)
+{
+	if (_Alignof(v) != 8)
+		return -1;
+	if (_Alignof(t) != _Alignof(long))
+		return -1;
+	if (_Alignof(p) != _Alignof(void *))
+		return -1;
+	if (_Alignof(a) != _Alignof(int))
+		return -1;
+
+	return 0;
+}
+
+/*
+ * check-name: c11-alignas
+ * check-command: test-linearize -std=c11 $file
+ *
+ * check-error-start
+c11-alignas.c:6:25: warning: non-power-of-2 alignment
+c11-alignas.c:7:25: warning: non-positive alignment
+c11-alignas.c:8:25: warning: non-positive alignment
+c11-alignas.c:9:17: error: bad constant expression
+c11-alignas.c:10:17: error: Syntax error in unary expression
+ * check-error-end
+ *
+ * check-output-ignore
+ * check-output-contains: ret\\.32 *\$0
+ */
diff --git a/usr/src/tools/smatch/src/validation/c11-alignof.c b/usr/src/tools/smatch/src/validation/c11-alignof.c
new file mode 100644
index 0000000000..238ef9941e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/c11-alignof.c
@@ -0,0 +1,12 @@
+static int foo(void)
+{
+	return _Alignof(short);
+}
+
+/*
+ * check-name: c11-alignof
+ * check-command: test-linearize -std=c11 $file
+ *
+ * check-output-ignore
+ * check-output-contains: ret\\.32 *\$2
+ */
diff --git a/usr/src/tools/smatch/src/validation/c11-noreturn.c b/usr/src/tools/smatch/src/validation/c11-noreturn.c
new file mode 100644
index 0000000000..bc20de82f9
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/c11-noreturn.c
@@ -0,0 +1,9 @@
+static _Noreturn void foo(void) { while (1) ; }
+
+/*
+ * check-name: c11-noreturn
+ * check-command: test-parsing -std=c11 $file
+ *
+ * check-output-ignore
+ * check-output-contains: \[noreturn\]
+ */
diff --git a/usr/src/tools/smatch/src/validation/c11-stdc-version.c b/usr/src/tools/smatch/src/validation/c11-stdc-version.c
new file mode 100644
index 0000000000..3acedd1968
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/c11-stdc-version.c
@@ -0,0 +1,11 @@
+__STDC_VERSION__
+
+/*
+ * check-name: c11-stdc-version
+ * check-command: sparse -E -std=c11 $file
+ *
+ * check-output-start
+
+201112L
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/c11-thread-local.c b/usr/src/tools/smatch/src/validation/c11-thread-local.c
new file mode 100644
index 0000000000..464c3e16a6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/c11-thread-local.c
@@ -0,0 +1,9 @@
+static _Thread_local int foo;
+
+/*
+ * check-name: c11-thread-local
+ * check-command: test-parsing -std=c11 $file
+ *
+ * check-output-ignore
+ * check-output-contains: \[tls\]
+ */
diff --git a/usr/src/tools/smatch/src/validation/c99-for-loop-decl.c b/usr/src/tools/smatch/src/validation/c99-for-loop-decl.c
new file mode 100644
index 0000000000..d382d3c9b3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/c99-for-loop-decl.c
@@ -0,0 +1,40 @@
+static int bad_scope(void)
+{
+	int r = 0;
+
+	for (int i = 0; i < 10; i++) {
+		r = i;
+	}
+
+	return i;			/* check-should-fail */
+}
+
+static int c99(void)
+{
+	int r = 0;
+
+	for (         int i = 0; i < 10; i++)	/* check-should-pass */
+		r = i;
+	for (    auto int j = 0; j < 10; j++)	/* check-should-pass */
+		r = j;
+	for (register int k = 0; k < 10; k++)	/* check-should-pass */
+		r = k;
+	for (  extern int l = 0; l < 10; l++)	/* check-should-fail */
+		r = l;
+	for (  extern int m;     m < 10; m++)	/* check-should-fail */
+		r = m;
+	for (  static int n = 0; n < 10; n++)	/* check-should-fail */
+		r = n;
+	return r;
+}
+
+/*
+ * check-name: C99 for-loop declarations
+ *
+ * check-error-start
+c99-for-loop-decl.c:22:27: error: non-local var 'l' in for-loop initializer
+c99-for-loop-decl.c:24:27: error: non-local var 'm' in for-loop initializer
+c99-for-loop-decl.c:26:27: error: non-local var 'n' in for-loop initializer
+c99-for-loop-decl.c:9:16: error: undefined identifier 'i'
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/c99-for-loop.c b/usr/src/tools/smatch/src/validation/c99-for-loop.c
new file mode 100644
index 0000000000..427fde268a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/c99-for-loop.c
@@ -0,0 +1,21 @@
+int c99(void);
+int c99(void)
+{
+	int r = -1;
+
+	for (int i = 0; i < 10; i++) {
+		r = i;
+	}
+
+	return r;
+}
+
+/*
+ * check-name: C99 for loop variable declaration
+ * check-command: test-linearize $file
+ *
+ * check-output-ignore
+ * check-output-contains: phisrc\\.
+ * check-output-contains: phi\\.
+ * check-output-contains: add\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/calling-convention-attributes.c b/usr/src/tools/smatch/src/validation/calling-convention-attributes.c
new file mode 100644
index 0000000000..1c1c876610
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/calling-convention-attributes.c
@@ -0,0 +1,26 @@
+extern void __attribute__((cdecl)) c1(void);
+typedef void (__attribute__((cdecl)) *c2)(void);
+typedef c2 c2ptr;
+
+extern void __attribute__((__cdecl__)) c_1(void);
+typedef void (__attribute__((__cdecl__)) *c_2)(void);
+typedef c_2 c_2ptr;
+
+extern void __attribute__((stdcall)) s1(void);
+typedef void (__attribute__((stdcall)) *s2)(void);
+typedef s2 s2ptr;
+
+extern void __attribute__((__stdcall__)) s_1(void);
+typedef void (__attribute__((__stdcall__)) *s_2)(void);
+typedef s_2 s_2ptr;
+
+extern void __attribute__((fastcall)) f1(void);
+typedef void (__attribute__((fastcall)) *f2)(void);
+typedef f2 f2ptr;
+
+extern void __attribute__((__fastcall__)) f_1(void);
+typedef void (__attribute__((__fastcall__)) *f_2)(void);
+typedef f_2 f_2ptr;
+/*
+ * check-name: Calling convention attributes
+ */
diff --git a/usr/src/tools/smatch/src/validation/cast-constant-to-float.c b/usr/src/tools/smatch/src/validation/cast-constant-to-float.c
new file mode 100644
index 0000000000..86b7ac0f7e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cast-constant-to-float.c
@@ -0,0 +1,35 @@
+typedef unsigned int uint;
+typedef unsigned long ulong;
+
+double f1(void) { return -1; }
+double f2(void) { return (double)-1; }
+double f3(void) { return -1.0; }
+
+/*
+ * check-name: cast-constant-to-float
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-start
+f1:
+.L0:
+	<entry-point>
+	set.64      %r1 <- -1.000000
+	ret.64      %r1
+
+
+f2:
+.L2:
+	<entry-point>
+	set.64      %r3 <- -1.000000
+	ret.64      %r3
+
+
+f3:
+.L4:
+	<entry-point>
+	set.64      %r5 <- -1.000000
+	ret.64      %r5
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/cast-constants.c b/usr/src/tools/smatch/src/validation/cast-constants.c
new file mode 100644
index 0000000000..f47d6fd346
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cast-constants.c
@@ -0,0 +1,357 @@
+typedef unsigned int uint;
+typedef unsigned long ulong;
+
+static int uint_2_int(void) { return (int)123U; }
+static int long_2_int(void) { return (int)123L; }
+static int ulong_2_int(void) { return (int)123UL; }
+static int vptr_2_int(void) { return (int)((void*)123); }
+static int iptr_2_int(void) { return (int)((int*)128); }
+static int float_2_int(void) { return (int)1.123F; }
+static int double_2_int(void) { return (int)1.123L; }
+static uint int_2_uint(void) { return (uint)123; }
+static uint long_2_uint(void) { return (uint)123L; }
+static uint ulong_2_uint(void) { return (uint)123UL; }
+static uint vptr_2_uint(void) { return (uint)((void*)123); }
+static uint iptr_2_uint(void) { return (uint)((int*)128); }
+static uint float_2_uint(void) { return (uint)1.123F; }
+static uint double_2_uint(void) { return (uint)1.123L; }
+static long int_2_long(void) { return (long)123; }
+static long uint_2_long(void) { return (long)123U; }
+static long ulong_2_long(void) { return (long)123UL; }
+static long vptr_2_long(void) { return (long)((void*)123); }
+static long iptr_2_long(void) { return (long)((int*)128); }
+static long float_2_long(void) { return (long)1.123F; }
+static long double_2_long(void) { return (long)1.123L; }
+static ulong int_2_ulong(void) { return (ulong)123; }
+static ulong uint_2_ulong(void) { return (ulong)123U; }
+static ulong long_2_ulong(void) { return (ulong)123L; }
+static ulong vptr_2_ulong(void) { return (ulong)((void*)123); }
+static ulong iptr_2_ulong(void) { return (ulong)((int*)128); }
+static ulong float_2_ulong(void) { return (ulong)1.123F; }
+static ulong double_2_ulong(void) { return (ulong)1.123L; }
+static void * int_2_vptr(void) { return (void *)123; }
+static void * uint_2_vptr(void) { return (void *)123U; }
+static void * long_2_vptr(void) { return (void *)123L; }
+static void * ulong_2_vptr(void) { return (void *)123UL; }
+static void * iptr_2_vptr(void) { return (void *)((int*)128); }
+static int * int_2_iptr(void) { return (int *)123; }
+static int * uint_2_iptr(void) { return (int *)123U; }
+static int * long_2_iptr(void) { return (int *)123L; }
+static int * ulong_2_iptr(void) { return (int *)123UL; }
+static int * vptr_2_iptr(void) { return (int *)((void*)123); }
+static float int_2_float(void) { return (float)123; }
+static float uint_2_float(void) { return (float)123U; }
+static float long_2_float(void) { return (float)123L; }
+static float ulong_2_float(void) { return (float)123UL; }
+static float double_2_float(void) { return (float)1.123L; }
+static double int_2_double(void) { return (double)123; }
+static double uint_2_double(void) { return (double)123U; }
+static double long_2_double(void) { return (double)123L; }
+static double ulong_2_double(void) { return (double)123UL; }
+static double float_2_double(void) { return (double)1.123F; }
+
+/*
+ * check-name: cast-constants.c
+ * check-command: test-linearize -m64 $file
+ *
+ * check-output-start
+uint_2_int:
+.L0:
+	<entry-point>
+	ret.32      $123
+
+
+long_2_int:
+.L2:
+	<entry-point>
+	ret.32      $123
+
+
+ulong_2_int:
+.L4:
+	<entry-point>
+	ret.32      $123
+
+
+vptr_2_int:
+.L6:
+	<entry-point>
+	ret.32      $123
+
+
+iptr_2_int:
+.L8:
+	<entry-point>
+	ret.32      $128
+
+
+float_2_int:
+.L10:
+	<entry-point>
+	ret.32      $1
+
+
+double_2_int:
+.L12:
+	<entry-point>
+	ret.32      $1
+
+
+int_2_uint:
+.L14:
+	<entry-point>
+	ret.32      $123
+
+
+long_2_uint:
+.L16:
+	<entry-point>
+	ret.32      $123
+
+
+ulong_2_uint:
+.L18:
+	<entry-point>
+	ret.32      $123
+
+
+vptr_2_uint:
+.L20:
+	<entry-point>
+	ret.32      $123
+
+
+iptr_2_uint:
+.L22:
+	<entry-point>
+	ret.32      $128
+
+
+float_2_uint:
+.L24:
+	<entry-point>
+	ret.32      $1
+
+
+double_2_uint:
+.L26:
+	<entry-point>
+	ret.32      $1
+
+
+int_2_long:
+.L28:
+	<entry-point>
+	ret.64      $123
+
+
+uint_2_long:
+.L30:
+	<entry-point>
+	ret.64      $123
+
+
+ulong_2_long:
+.L32:
+	<entry-point>
+	ret.64      $123
+
+
+vptr_2_long:
+.L34:
+	<entry-point>
+	ret.64      $123
+
+
+iptr_2_long:
+.L36:
+	<entry-point>
+	ret.64      $128
+
+
+float_2_long:
+.L38:
+	<entry-point>
+	ret.64      $1
+
+
+double_2_long:
+.L40:
+	<entry-point>
+	ret.64      $1
+
+
+int_2_ulong:
+.L42:
+	<entry-point>
+	ret.64      $123
+
+
+uint_2_ulong:
+.L44:
+	<entry-point>
+	ret.64      $123
+
+
+long_2_ulong:
+.L46:
+	<entry-point>
+	ret.64      $123
+
+
+vptr_2_ulong:
+.L48:
+	<entry-point>
+	ret.64      $123
+
+
+iptr_2_ulong:
+.L50:
+	<entry-point>
+	ret.64      $128
+
+
+float_2_ulong:
+.L52:
+	<entry-point>
+	ret.64      $1
+
+
+double_2_ulong:
+.L54:
+	<entry-point>
+	ret.64      $1
+
+
+int_2_vptr:
+.L56:
+	<entry-point>
+	ret.64      $123
+
+
+uint_2_vptr:
+.L58:
+	<entry-point>
+	ret.64      $123
+
+
+long_2_vptr:
+.L60:
+	<entry-point>
+	ret.64      $123
+
+
+ulong_2_vptr:
+.L62:
+	<entry-point>
+	ret.64      $123
+
+
+iptr_2_vptr:
+.L64:
+	<entry-point>
+	ret.64      $128
+
+
+int_2_iptr:
+.L66:
+	<entry-point>
+	ret.64      $123
+
+
+uint_2_iptr:
+.L68:
+	<entry-point>
+	ret.64      $123
+
+
+long_2_iptr:
+.L70:
+	<entry-point>
+	ret.64      $123
+
+
+ulong_2_iptr:
+.L72:
+	<entry-point>
+	ret.64      $123
+
+
+vptr_2_iptr:
+.L74:
+	<entry-point>
+	ret.64      $123
+
+
+int_2_float:
+.L76:
+	<entry-point>
+	set.32      %r39 <- 123.000000
+	ret.32      %r39
+
+
+uint_2_float:
+.L78:
+	<entry-point>
+	set.32      %r41 <- 123.000000
+	ret.32      %r41
+
+
+long_2_float:
+.L80:
+	<entry-point>
+	set.32      %r43 <- 123.000000
+	ret.32      %r43
+
+
+ulong_2_float:
+.L82:
+	<entry-point>
+	set.32      %r45 <- 123.000000
+	ret.32      %r45
+
+
+double_2_float:
+.L84:
+	<entry-point>
+	set.32      %r47 <- 1.123000
+	ret.32      %r47
+
+
+int_2_double:
+.L86:
+	<entry-point>
+	set.64      %r49 <- 123.000000
+	ret.64      %r49
+
+
+uint_2_double:
+.L88:
+	<entry-point>
+	set.64      %r51 <- 123.000000
+	ret.64      %r51
+
+
+long_2_double:
+.L90:
+	<entry-point>
+	set.64      %r53 <- 123.000000
+	ret.64      %r53
+
+
+ulong_2_double:
+.L92:
+	<entry-point>
+	set.64      %r55 <- 123.000000
+	ret.64      %r55
+
+
+float_2_double:
+.L94:
+	<entry-point>
+	set.64      %r57 <- 1.123000
+	ret.64      %r57
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/cast-kinds.c b/usr/src/tools/smatch/src/validation/cast-kinds.c
new file mode 100644
index 0000000000..697f9735ea
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cast-kinds.c
@@ -0,0 +1,387 @@
+typedef unsigned int uint;
+typedef unsigned long ulong;
+
+static int uint_2_int(uint a) { return (int)a; }
+static int long_2_int(long a) { return (int)a; }
+static int ulong_2_int(ulong a) { return (int)a; }
+static int vptr_2_int(void *a) { return (int)a; }
+static int iptr_2_int(int *a) { return (int)a; }
+static int float_2_int(float a) { return (int)a; }
+static int double_2_int(double a) { return (int)a; }
+static uint int_2_uint(int a) { return (uint)a; }
+static uint long_2_uint(long a) { return (uint)a; }
+static uint ulong_2_uint(ulong a) { return (uint)a; }
+static uint vptr_2_uint(void *a) { return (uint)a; }
+static uint iptr_2_uint(int *a) { return (uint)a; }
+static uint float_2_uint(float a) { return (uint)a; }
+static uint double_2_uint(double a) { return (uint)a; }
+static long int_2_long(int a) { return (long)a; }
+static long uint_2_long(uint a) { return (long)a; }
+static long ulong_2_long(ulong a) { return (long)a; }
+static long vptr_2_long(void *a) { return (long)a; }
+static long iptr_2_long(int *a) { return (long)a; }
+static long float_2_long(float a) { return (long)a; }
+static long double_2_long(double a) { return (long)a; }
+static ulong int_2_ulong(int a) { return (ulong)a; }
+static ulong uint_2_ulong(uint a) { return (ulong)a; }
+static ulong long_2_ulong(long a) { return (ulong)a; }
+static ulong vptr_2_ulong(void *a) { return (ulong)a; }
+static ulong iptr_2_ulong(int *a) { return (ulong)a; }
+static ulong float_2_ulong(float a) { return (ulong)a; }
+static ulong double_2_ulong(double a) { return (ulong)a; }
+static void * int_2_vptr(int a) { return (void *)a; }
+static void * uint_2_vptr(uint a) { return (void *)a; }
+static void * long_2_vptr(long a) { return (void *)a; }
+static void * ulong_2_vptr(ulong a) { return (void *)a; }
+static void * iptr_2_vptr(int *a) { return (void *)a; }
+static int * int_2_iptr(int a) { return (int *)a; }
+static int * uint_2_iptr(uint a) { return (int *)a; }
+static int * long_2_iptr(long a) { return (int *)a; }
+static int * ulong_2_iptr(ulong a) { return (int *)a; }
+static int * vptr_2_iptr(void *a) { return (int *)a; }
+static float int_2_float(int a) { return (float)a; }
+static float uint_2_float(uint a) { return (float)a; }
+static float long_2_float(long a) { return (float)a; }
+static float ulong_2_float(ulong a) { return (float)a; }
+static float double_2_float(double a) { return (float)a; }
+static double int_2_double(int a) { return (double)a; }
+static double uint_2_double(uint a) { return (double)a; }
+static double long_2_double(long a) { return (double)a; }
+static double ulong_2_double(ulong a) { return (double)a; }
+static double float_2_double(float a) { return (double)a; }
+
+/*
+ * check-name: cast-kinds
+ * check-command: test-linearize -m64 $file
+ *
+ * check-output-start
+uint_2_int:
+.L0:
+	<entry-point>
+	ret.32      %arg1
+
+
+long_2_int:
+.L2:
+	<entry-point>
+	scast.32    %r5 <- (64) %arg1
+	ret.32      %r5
+
+
+ulong_2_int:
+.L4:
+	<entry-point>
+	cast.32     %r8 <- (64) %arg1
+	ret.32      %r8
+
+
+vptr_2_int:
+.L6:
+	<entry-point>
+	cast.32     %r11 <- (64) %arg1
+	ret.32      %r11
+
+
+iptr_2_int:
+.L8:
+	<entry-point>
+	cast.32     %r14 <- (64) %arg1
+	ret.32      %r14
+
+
+float_2_int:
+.L10:
+	<entry-point>
+	ret.32      %arg1
+
+
+double_2_int:
+.L12:
+	<entry-point>
+	cast.32     %r20 <- (64) %arg1
+	ret.32      %r20
+
+
+int_2_uint:
+.L14:
+	<entry-point>
+	ret.32      %arg1
+
+
+long_2_uint:
+.L16:
+	<entry-point>
+	scast.32    %r26 <- (64) %arg1
+	ret.32      %r26
+
+
+ulong_2_uint:
+.L18:
+	<entry-point>
+	cast.32     %r29 <- (64) %arg1
+	ret.32      %r29
+
+
+vptr_2_uint:
+.L20:
+	<entry-point>
+	cast.32     %r32 <- (64) %arg1
+	ret.32      %r32
+
+
+iptr_2_uint:
+.L22:
+	<entry-point>
+	cast.32     %r35 <- (64) %arg1
+	ret.32      %r35
+
+
+float_2_uint:
+.L24:
+	<entry-point>
+	ret.32      %arg1
+
+
+double_2_uint:
+.L26:
+	<entry-point>
+	cast.32     %r41 <- (64) %arg1
+	ret.32      %r41
+
+
+int_2_long:
+.L28:
+	<entry-point>
+	scast.64    %r44 <- (32) %arg1
+	ret.64      %r44
+
+
+uint_2_long:
+.L30:
+	<entry-point>
+	cast.64     %r47 <- (32) %arg1
+	ret.64      %r47
+
+
+ulong_2_long:
+.L32:
+	<entry-point>
+	ret.64      %arg1
+
+
+vptr_2_long:
+.L34:
+	<entry-point>
+	cast.64     %r53 <- (64) %arg1
+	ret.64      %r53
+
+
+iptr_2_long:
+.L36:
+	<entry-point>
+	cast.64     %r56 <- (64) %arg1
+	ret.64      %r56
+
+
+float_2_long:
+.L38:
+	<entry-point>
+	cast.64     %r59 <- (32) %arg1
+	ret.64      %r59
+
+
+double_2_long:
+.L40:
+	<entry-point>
+	ret.64      %arg1
+
+
+int_2_ulong:
+.L42:
+	<entry-point>
+	scast.64    %r65 <- (32) %arg1
+	ret.64      %r65
+
+
+uint_2_ulong:
+.L44:
+	<entry-point>
+	cast.64     %r68 <- (32) %arg1
+	ret.64      %r68
+
+
+long_2_ulong:
+.L46:
+	<entry-point>
+	ret.64      %arg1
+
+
+vptr_2_ulong:
+.L48:
+	<entry-point>
+	cast.64     %r74 <- (64) %arg1
+	ret.64      %r74
+
+
+iptr_2_ulong:
+.L50:
+	<entry-point>
+	cast.64     %r77 <- (64) %arg1
+	ret.64      %r77
+
+
+float_2_ulong:
+.L52:
+	<entry-point>
+	cast.64     %r80 <- (32) %arg1
+	ret.64      %r80
+
+
+double_2_ulong:
+.L54:
+	<entry-point>
+	ret.64      %arg1
+
+
+int_2_vptr:
+.L56:
+	<entry-point>
+	scast.64    %r86 <- (32) %arg1
+	ret.64      %r86
+
+
+uint_2_vptr:
+.L58:
+	<entry-point>
+	cast.64     %r89 <- (32) %arg1
+	ret.64      %r89
+
+
+long_2_vptr:
+.L60:
+	<entry-point>
+	scast.64    %r92 <- (64) %arg1
+	ret.64      %r92
+
+
+ulong_2_vptr:
+.L62:
+	<entry-point>
+	cast.64     %r95 <- (64) %arg1
+	ret.64      %r95
+
+
+iptr_2_vptr:
+.L64:
+	<entry-point>
+	cast.64     %r98 <- (64) %arg1
+	ret.64      %r98
+
+
+int_2_iptr:
+.L66:
+	<entry-point>
+	ptrcast.64  %r101 <- (32) %arg1
+	ret.64      %r101
+
+
+uint_2_iptr:
+.L68:
+	<entry-point>
+	ptrcast.64  %r104 <- (32) %arg1
+	ret.64      %r104
+
+
+long_2_iptr:
+.L70:
+	<entry-point>
+	ptrcast.64  %r107 <- (64) %arg1
+	ret.64      %r107
+
+
+ulong_2_iptr:
+.L72:
+	<entry-point>
+	ptrcast.64  %r110 <- (64) %arg1
+	ret.64      %r110
+
+
+vptr_2_iptr:
+.L74:
+	<entry-point>
+	ptrcast.64  %r113 <- (64) %arg1
+	ret.64      %r113
+
+
+int_2_float:
+.L76:
+	<entry-point>
+	fpcast.32   %r116 <- (32) %arg1
+	ret.32      %r116
+
+
+uint_2_float:
+.L78:
+	<entry-point>
+	fpcast.32   %r119 <- (32) %arg1
+	ret.32      %r119
+
+
+long_2_float:
+.L80:
+	<entry-point>
+	fpcast.32   %r122 <- (64) %arg1
+	ret.32      %r122
+
+
+ulong_2_float:
+.L82:
+	<entry-point>
+	fpcast.32   %r125 <- (64) %arg1
+	ret.32      %r125
+
+
+double_2_float:
+.L84:
+	<entry-point>
+	fpcast.32   %r128 <- (64) %arg1
+	ret.32      %r128
+
+
+int_2_double:
+.L86:
+	<entry-point>
+	fpcast.64   %r131 <- (32) %arg1
+	ret.64      %r131
+
+
+uint_2_double:
+.L88:
+	<entry-point>
+	fpcast.64   %r134 <- (32) %arg1
+	ret.64      %r134
+
+
+long_2_double:
+.L90:
+	<entry-point>
+	fpcast.64   %r137 <- (64) %arg1
+	ret.64      %r137
+
+
+ulong_2_double:
+.L92:
+	<entry-point>
+	fpcast.64   %r140 <- (64) %arg1
+	ret.64      %r140
+
+
+float_2_double:
+.L94:
+	<entry-point>
+	fpcast.64   %r143 <- (32) %arg1
+	ret.64      %r143
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/check_byte_count-ice.c b/usr/src/tools/smatch/src/validation/check_byte_count-ice.c
new file mode 100644
index 0000000000..7b85b96319
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/check_byte_count-ice.c
@@ -0,0 +1,19 @@
+extern void *memset (void *s, int c, int n);
+
+static void foo(void *a)
+{
+	memset(foo, + ', 20);
+}
+/*
+ * check-name: Segfault in check_byte_count after syntax error
+ *
+ * check-error-start
+check_byte_count-ice.c:6:0: warning: Newline in string or character constant
+check_byte_count-ice.c:5:23: warning: multi-character character constant
+check_byte_count-ice.c:6:1: error: Expected ) in function call
+check_byte_count-ice.c:6:1: error: got }
+builtin:0:0: error: Expected } at end of function
+builtin:0:0: error: got end-of-input
+check_byte_count-ice.c:5:15: error: not enough arguments for function memset
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/choose_expr.c b/usr/src/tools/smatch/src/validation/choose_expr.c
new file mode 100644
index 0000000000..f6fd84cf2a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/choose_expr.c
@@ -0,0 +1,17 @@
+static int x = __builtin_choose_expr(0,(char *)0,(void)0);
+static int y = __builtin_choose_expr(1,(char *)0,(void)0);
+static char s[42];
+static int z = 1/(sizeof(__builtin_choose_expr(1,s,0)) - 42);
+
+/*
+ * check-name: choose expr builtin
+ * check-error-start
+choose_expr.c:1:51: warning: incorrect type in initializer (different base types)
+choose_expr.c:1:51:    expected int static [signed] [toplevel] x
+choose_expr.c:1:51:    got void <noident>
+choose_expr.c:2:41: warning: incorrect type in initializer (different base types)
+choose_expr.c:2:41:    expected int static [signed] [toplevel] y
+choose_expr.c:2:41:    got char *<noident>
+choose_expr.c:4:17: warning: division by zero
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/comma.c b/usr/src/tools/smatch/src/validation/comma.c
new file mode 100644
index 0000000000..374948efbc
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/comma.c
@@ -0,0 +1,12 @@
+static char a[sizeof(char *) + 1];
+static char b[1/(sizeof(a) - sizeof(0,a))];
+static void f(void)
+{
+        int c[42];
+        typeof((void)0,c) d;
+        d = c;
+}
+/*
+ * check-name: Comma and array decay
+ * check-description: arguments of comma should degenerate
+ */
diff --git a/usr/src/tools/smatch/src/validation/compare-null-to-int.c b/usr/src/tools/smatch/src/validation/compare-null-to-int.c
new file mode 100644
index 0000000000..08e556b32d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/compare-null-to-int.c
@@ -0,0 +1,11 @@
+static unsigned int comparison = (void *)0 == 1;
+/*
+ * check-name: Compare null pointer constant to int
+ * check-description: Sparse used to allow this.
+ *
+ * check-error-start
+compare-null-to-int.c:1:44: error: incompatible types for operation (==)
+compare-null-to-int.c:1:44:    left side has type void *
+compare-null-to-int.c:1:44:    right side has type int
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/compound-assign-type.c b/usr/src/tools/smatch/src/validation/compound-assign-type.c
new file mode 100644
index 0000000000..450fa26d9a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/compound-assign-type.c
@@ -0,0 +1,15 @@
+static unsigned int foo(unsigned int x, long a)
+{
+	x /= a;
+	return x;
+}
+
+/*
+ * check-name: compound-assign-type
+ * check-command: test-linearize -m64 $file
+ * check-output-ignore
+ *
+ * check-output-excludes: divu\\.32
+ * check-output-contains: divs\\.64
+ * check-output-contains: scast\\.32
+ */
diff --git a/usr/src/tools/smatch/src/validation/cond-address-array.c b/usr/src/tools/smatch/src/validation/cond-address-array.c
new file mode 100644
index 0000000000..e1d2f87f87
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cond-address-array.c
@@ -0,0 +1,26 @@
+int foo(void) {
+	extern int a[];
+
+	if (a)
+		return 1;
+	return 0;
+}
+
+int bar(void) {
+	int a[2];
+
+	if (a)
+		return 1;
+	return 0;
+}
+
+/*
+ * check-name: cond-address-array.c
+ * check-command: test-linearize -Wno-decl -Waddress $file
+ * check-output-ignore
+ *
+ * check-error-start
+cond-address-array.c:4:13: warning: the address of an array will always evaluate as true
+cond-address-array.c:12:13: warning: the address of an array will always evaluate as true
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/cond-address-function.c b/usr/src/tools/smatch/src/validation/cond-address-function.c
new file mode 100644
index 0000000000..9a143a0091
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cond-address-function.c
@@ -0,0 +1,18 @@
+extern void func(void);
+
+int global_function(void)
+{
+	if (func)
+		return 1;
+	return 0;
+}
+
+/*
+ * check-name: cond-address-function
+ * check-command: test-linearize -Wno-decl -Waddress $file
+ * check-output-ignore
+ *
+ * check-error-start
+cond-address-function.c:5:13: warning: the address of a function will always evaluate as true
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/cond-address.c b/usr/src/tools/smatch/src/validation/cond-address.c
new file mode 100644
index 0000000000..2a69f4b922
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cond-address.c
@@ -0,0 +1,14 @@
+extern void f(void);
+extern int a[];
+
+int foo(void) { if (f) return 1; return 0; }
+int bar(void) { if (a) return 1; return 0; }
+int qux(void) { if (f && a) return 1; return 0; }
+
+/*
+ * check-name: cond-address.c
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-excludes: VOID
+ */
diff --git a/usr/src/tools/smatch/src/validation/cond-err-expand.c b/usr/src/tools/smatch/src/validation/cond-err-expand.c
new file mode 100644
index 0000000000..93bbac1538
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cond-err-expand.c
@@ -0,0 +1,27 @@
+static inline void f(void)
+{
+	__builtin_constant_p(0);
+}
+
+void foo(void)
+{
+	0 ? 0 : f();
+}
+
+void bar(void)
+{
+	1 ? f() : 0;
+}
+
+/*
+ * check-name: cond-err-expand.c
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-error-start
+cond-err-expand.c:8:11: error: incompatible types in conditional expression (different base types)
+cond-err-expand.c:13:11: error: incompatible types in conditional expression (different base types)
+ * check-error-end
+ *
+ * check-output-ignore
+ * check-excludes: call.* __builtin_constant_p
+ */
diff --git a/usr/src/tools/smatch/src/validation/cond_expr.c b/usr/src/tools/smatch/src/validation/cond_expr.c
new file mode 100644
index 0000000000..e55711ccee
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cond_expr.c
@@ -0,0 +1,19 @@
+/*
+ *  Bug in original tree: (real_v ? : x) had been treated as equivalent of
+ *  (real_v == 0 ? real_v == 0 : x), which gives the wrong type (and no
+ *  warning from the testcase below).
+ */
+static int x;
+static double y;
+int a(void)
+{
+	return ~(y ? : x);	/* should warn */
+}
+/*
+ * check-name: Two-argument conditional expression types
+ *
+ * check-error-start
+cond_expr.c:10:16: error: incompatible types for operation (~)
+cond_expr.c:10:16:    argument has type double
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/cond_expr2.c b/usr/src/tools/smatch/src/validation/cond_expr2.c
new file mode 100644
index 0000000000..5e974cfaff
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cond_expr2.c
@@ -0,0 +1,22 @@
+extern const int *p;
+extern volatile void *q;
+extern volatile int *r;
+static void f(void)
+{
+	q = 1 ? p : q;	// warn: const volatile void * -> const int *
+	r = 1 ? r : q;	// OK: volatile void * -> volatile int *
+	r = 1 ? r : p;	// warn: const volatile int * -> volatile int *
+}
+/*
+ * check-name: type of conditional expression
+ * check-description: Used to miss qualifier mixing and mishandle void *
+ *
+ * check-error-start
+cond_expr2.c:6:11: warning: incorrect type in assignment (different modifiers)
+cond_expr2.c:6:11:    expected void volatile *extern [addressable] [toplevel] q
+cond_expr2.c:6:11:    got void const volatile *
+cond_expr2.c:8:11: warning: incorrect type in assignment (different modifiers)
+cond_expr2.c:8:11:    expected int volatile *extern [addressable] [toplevel] [assigned] r
+cond_expr2.c:8:11:    got int const volatile *
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/cond_expr3.c b/usr/src/tools/smatch/src/validation/cond_expr3.c
new file mode 100644
index 0000000000..748409e607
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/cond_expr3.c
@@ -0,0 +1,17 @@
+static int icmp = 1 / (sizeof(int) - sizeof(1 > 0));
+static int fcmp = 1 / (sizeof(int) - sizeof(1.0 == 2.0 - 1.0));
+static int lnot = 1 / (sizeof(int) - sizeof(!!1.0));
+static int land = 1 / (sizeof(int) - sizeof(2 && 3));
+static int lor  = 1 / (sizeof(int) - sizeof('c' || 1.0f));
+
+/*
+ * check-name: result type of relational and logical operators
+ *
+ * check-error-start
+cond_expr3.c:1:21: warning: division by zero
+cond_expr3.c:2:21: warning: division by zero
+cond_expr3.c:3:21: warning: division by zero
+cond_expr3.c:4:21: warning: division by zero
+cond_expr3.c:5:21: warning: division by zero
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/conditional-type.c b/usr/src/tools/smatch/src/validation/conditional-type.c
new file mode 100644
index 0000000000..a14c05ec1d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/conditional-type.c
@@ -0,0 +1,99 @@
+extern void afun(void);
+extern void vcond(void);
+static int array[3];
+
+struct state {
+	int nr:2;
+};
+
+enum number {
+	zero,
+	one,
+	two,
+	many,
+};
+
+static int bad_if(struct state s)
+{
+	if (vcond()) return 1;
+	if (s) return 1;
+	return 0;
+}
+static void bad_if2(int *a, int *b)
+{
+	if (vcond()) *a = 1;
+	*b = 0;
+}
+static int bad_sel(struct state s)
+{
+	return vcond() ? 1 : 0;
+	return s ? 1 : 0;
+}
+static int bad_loop_void(void)
+{
+	while (vcond())
+		;
+	for (;vcond();)
+		;
+	do
+		;
+	while (vcond());
+	return 0;
+}
+
+
+static int good_if_int(int a, _Bool b, long c, unsigned char d)
+{
+	if (a) return 1;
+	if (b) return 1;
+	if (c) return 1;
+	if (d) return 1;
+	return 0;
+}
+static int good_if_float(float a, double b)
+{
+	if (a) return 1;
+	if (b) return 1;
+	return 0;
+}
+static int good_if_enum(void)
+{
+	if (many) return 1;
+	return 0;
+}
+static int good_if_bitfield(struct state s, struct state *p)
+{
+	if (s.nr) return 1;
+	if (p->nr) return 1;
+	return 0;
+}
+static int good_if_ptr(void *ptr)
+{
+	if (ptr) return 1;
+	if (array) return 1;
+	if (afun) return 1;
+	return 0;
+}
+
+/*
+ * check-name: conditional-type
+ *
+ * check-error-start
+conditional-type.c:18:18: error: incorrect type in conditional
+conditional-type.c:18:18:    got void
+conditional-type.c:19:13: error: incorrect type in conditional
+conditional-type.c:19:13:    got struct state s
+conditional-type.c:24:18: error: incorrect type in conditional
+conditional-type.c:24:18:    got void
+conditional-type.c:29:21: error: incorrect type in conditional
+conditional-type.c:29:21:    got void
+conditional-type.c:30:16: error: incorrect type in conditional
+conditional-type.c:30:16:    got struct state s
+conditional-type.c:34:21: error: incorrect type in conditional
+conditional-type.c:34:21:    got void
+conditional-type.c:36:20: error: incorrect type in conditional
+conditional-type.c:36:20:    got void
+conditional-type.c:40:21: error: incorrect type in conditional
+conditional-type.c:40:21:    got void
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constant-suffix-32.c b/usr/src/tools/smatch/src/validation/constant-suffix-32.c
new file mode 100644
index 0000000000..dc063a079d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constant-suffix-32.c
@@ -0,0 +1,15 @@
+#define BIGU 0xfffff00000000000U
+#define BIGULL 0xfffff00000000000ULL
+
+static unsigned long long a = BIGU;
+static unsigned long long b = BIGULL;
+
+/*
+ * check-name: constant-suffix
+ * check-command: sparse -m32 -Wconstant-suffix $file
+ *
+ * check-error-start
+constant-suffix-32.c:4:31: warning: constant 0xfffff00000000000U is so big it is unsigned long long
+ * check-error-end
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/constant-suffix-64.c b/usr/src/tools/smatch/src/validation/constant-suffix-64.c
new file mode 100644
index 0000000000..e65706b024
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constant-suffix-64.c
@@ -0,0 +1,15 @@
+#define BIGU 0xfffff00000000000U
+#define BIGUL 0xfffff00000000000UL
+
+static unsigned long a = BIGU;
+static unsigned long b = BIGUL;
+
+/*
+ * check-name: constant-suffix
+ * check-command: sparse -m64 -Wconstant-suffix $file
+ *
+ * check-error-start
+constant-suffix-64.c:4:26: warning: constant 0xfffff00000000000U is so big it is unsigned long
+ * check-error-end
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/constexpr-addr-of-static-member.c b/usr/src/tools/smatch/src/validation/constexpr-addr-of-static-member.c
new file mode 100644
index 0000000000..f944f213e9
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-addr-of-static-member.c
@@ -0,0 +1,26 @@
+struct A {
+	int a;
+	int b[2];
+};
+
+struct B {
+	int c;
+	struct A d;
+};
+
+static struct B a= {1, {1, {1, 1}}};
+
+static int *b = &a.d.a;	// OK
+static int *c = &(&a.d)->a;	// OK
+static int *d = a.d.b;		// OK
+static int *e = (&a.d)->b;	// OK
+static int *f = &a.d.b[1];	// OK
+static int *g = &(&a.d)->b[1];	// OK
+
+/*
+ * check-name: address of static object's member constness verification.
+ * check-command: sparse -Wconstexpr-not-const $file
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-addr-of-static.c b/usr/src/tools/smatch/src/validation/constexpr-addr-of-static.c
new file mode 100644
index 0000000000..a3af99ae72
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-addr-of-static.c
@@ -0,0 +1,36 @@
+static int a = 1;
+static int b[2] = {1, 1};
+static void c(void) {}
+
+static int *d = &a;		// OK
+static int *e = d;		// KO
+static int *f = b;		// OK
+
+static void (*g)(void) = c;	// OK
+static void (*h)(void) = &c;	// OK
+
+static int *i = &*&a;		// OK
+static int *j = &*b;		// OK
+static int *k = &*d;		// KO
+
+
+static void l(void) {
+	int a = 1;
+	static int *b = &a;	// KO
+}
+
+static void m(void) {
+	static int a = 1;
+	static int *b = &a;	// OK
+}
+
+/*
+ * check-name: address of static object constness verification.
+ * check-command: sparse -Wconstexpr-not-const $file
+ *
+ * check-error-start
+constexpr-addr-of-static.c:6:17: warning: non-constant initializer for static object
+constexpr-addr-of-static.c:14:19: warning: non-constant initializer for static object
+constexpr-addr-of-static.c:19:26: warning: non-constant initializer for static object
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-binop.c b/usr/src/tools/smatch/src/validation/constexpr-binop.c
new file mode 100644
index 0000000000..85a88e3cd1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-binop.c
@@ -0,0 +1,33 @@
+static int a[] = {
+	[0 + 0] = 0,						// OK
+	[0 + 0.] = 0,						// KO
+	[(void*)0 + 0] = 0,					// KO
+	[0 + __builtin_choose_expr(0, 0, 0)] = 0,		// OK
+	[0 + __builtin_choose_expr(0, 0., 0)] = 0,		// OK
+	[0 + __builtin_choose_expr(0, 0, 0.)] = 0,		// KO
+	[0 < 0] = 0,						// OK
+	[0 < 0.] = 0,						// KO
+	[0 < __builtin_choose_expr(0, 0, 0)] = 0,		// OK
+	[0 < __builtin_choose_expr(0, 0., 0)] = 0,		// OK
+	[0 < __builtin_choose_expr(0, 0, 0.)] = 0,		// KO
+	[0 && 0] = 0,						// OK
+	[0 && 0.] = 0,						// KO
+	[0 && __builtin_choose_expr(0, 0, 0)] = 0,		// OK
+	[0 && __builtin_choose_expr(0, 0., 0)] = 0,		// OK
+	[0 && __builtin_choose_expr(0, 0, 0.)] = 0,		// KO
+	[0 + __builtin_types_compatible_p(int, float)] = 0,	// OK
+};
+
+/*
+ * check-name: Expression constness propagation in binops and alike
+ *
+ * check-error-start
+constexpr-binop.c:3:12: error: bad constant expression
+constexpr-binop.c:4:19: error: bad integer constant expression
+constexpr-binop.c:7:12: error: bad constant expression
+constexpr-binop.c:9:12: error: bad integer constant expression
+constexpr-binop.c:12:12: error: bad integer constant expression
+constexpr-binop.c:14:12: error: bad integer constant expression
+constexpr-binop.c:17:12: error: bad integer constant expression
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-cast.c b/usr/src/tools/smatch/src/validation/constexpr-cast.c
new file mode 100644
index 0000000000..27069614c2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-cast.c
@@ -0,0 +1,25 @@
+static int a[] = {
+	[(int)0] = 0,		// OK
+	[(int)(int)0] = 0,	// OK
+	[(int)0.] = 0,		// OK
+	[(int)(int)0.] = 0,	// OK
+	[(int)__builtin_choose_expr(0, 0, 0)] = 0,	// OK
+	[(int)__builtin_choose_expr(0, 0, 0.)] = 0,	// OK
+
+	[(int)(float)0] = 0,	// KO
+	[(int)(float)0.] = 0,	// KO
+
+	[(int)(void*)0] = 0,	// KO
+	[(int)(void*)0.] = 0,	// KO
+
+};
+/*
+ * check-name: Expression constness propagation in casts
+ *
+ * check-error-start
+constexpr-cast.c:9:11: error: bad integer constant expression
+constexpr-cast.c:10:11: error: bad integer constant expression
+constexpr-cast.c:12:11: error: bad integer constant expression
+constexpr-cast.c:13:11: error: bad integer constant expression
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-compound-literal.c b/usr/src/tools/smatch/src/validation/constexpr-compound-literal.c
new file mode 100644
index 0000000000..d7f21ad7a0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-compound-literal.c
@@ -0,0 +1,19 @@
+static int *a = &(int){ 1 };	// OK
+static int *b = &(int){ *a };	// KO
+
+static void foo(void)
+{
+	int *b = &(int){ 1 };		// OK
+	int *c = &(int){ *a };		// OK
+	static int *d = &(int){ 1 };	// KO
+}
+
+/*
+ * check-name: compound literal address constness verification
+ * check-command: sparse -Wconstexpr-not-const $file
+ *
+ * check-error-start
+constexpr-compound-literal.c:2:25: warning: non-constant initializer for static object
+constexpr-compound-literal.c:8:27: warning: non-constant initializer for static object
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-conditional.c b/usr/src/tools/smatch/src/validation/constexpr-conditional.c
new file mode 100644
index 0000000000..a3331b3ef0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-conditional.c
@@ -0,0 +1,34 @@
+static int a[] = {
+	[0 ? : 0] = 0,						// OK
+	[1 ? : 0] = 0,						// OK
+	[0 ? 0 : 0] = 0,					// OK
+	[1 ? 0 : 0] = 0,					// OK
+	[0 ? 0 : __builtin_choose_expr(0, 0, 0)] = 0,		// OK
+	[1 ? __builtin_choose_expr(0, 0, 0) : 0] = 0,		// OK
+	[0 ? __builtin_choose_expr(0, 0, 0) : 0] = 0,		// OK
+	[1 ? 1 : __builtin_choose_expr(0, 0, 0)] = 0,		// OK
+	[__builtin_choose_expr(0, 0, 0) ? : 0] = 0,		// OK
+	[__builtin_choose_expr(0, 0, 1) ? : 0] = 0,		// OK
+	[0. ? : 0] = 0,					// KO
+	[0 ? 0. : 0] = 0,					// KO
+	[1 ? : 0.] = 0,					// KO
+	[__builtin_choose_expr(0, 0., 0) ? : 0] = 0,		// OK
+	[__builtin_choose_expr(0, 0, 0.) ? : 0] = 0,		// KO
+	[0 ? __builtin_choose_expr(0, 0., 0) : 0] = 0,		// OK
+	[0 ? __builtin_choose_expr(0, 0, 0.) : 0] = 0,		// KO
+	[1 ? 0 : __builtin_choose_expr(0, 0., 0)] = 0,		// OK
+	[1 ? 0 : __builtin_choose_expr(0, 0, 0.)] = 0,		// KO
+};
+
+/*
+ * check-name: Expression constness propagation in conditional expressions
+ *
+ * check-error-start
+constexpr-conditional.c:12:13: error: bad constant expression
+constexpr-conditional.c:13:19: error: bad constant expression
+constexpr-conditional.c:14:12: error: bad constant expression
+constexpr-conditional.c:16:42: error: bad constant expression
+constexpr-conditional.c:18:48: error: bad constant expression
+constexpr-conditional.c:20:14: error: bad constant expression
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-init.c b/usr/src/tools/smatch/src/validation/constexpr-init.c
new file mode 100644
index 0000000000..d7e7a450f5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-init.c
@@ -0,0 +1,60 @@
+static int a = 1;					// OK
+static int b[2] = {1, 1};				// OK
+static void c(void) {}
+
+struct A {
+	int a;
+	int b[2];
+};
+
+struct B {
+	int c;
+	struct A d;
+};
+
+static struct B d= {1, {1, {1, 1}}};				// OK
+static struct B e= {a, {1, {1, 1}}};				// KO
+static struct B f= {1, {a, {1, 1}}};				// KO
+static struct B g= {1, {1, {a, 1}}};				// KO
+static struct B h= {1, {1, {1, a}}};				// KO
+static struct B i= {.c = 1, .d = {.a = 1, .b = {1, 1}}};	// OK
+static struct B j= {.c = a, .d = {.a = 1, .b = {1, 1}}};	// KO
+static struct B k= {.c = 1, .d = {.a = a, .b = {1, 1}}};	// KO
+static struct B l= {.c = 1, .d = {.a = 1, .b = {a, 1}}};	// KO
+static struct B m= {.c = 1, .d = {.a = 1, .b = {1, a}}};	// KO
+
+static int n[] = {a, 1};				// KO
+static int o[] = {1, a};				// KO
+static int p[] = {[0] = a, [1] = 1};			// KO
+static int q[] = {[0] = 1, [1] = a};			// KO
+
+static void r(void) {
+	int a = 0;
+	int b = a;		// OK
+}
+
+static void s(void) {
+	int a = 1;
+	static int b = a;	// KO
+}
+
+/*
+ * check-name: static storage object initializer constness verification.
+ * check-command: sparse -Wconstexpr-not-const $file
+ *
+ * check-error-start
+constexpr-init.c:16:21: warning: non-constant initializer for static object
+constexpr-init.c:17:25: warning: non-constant initializer for static object
+constexpr-init.c:18:29: warning: non-constant initializer for static object
+constexpr-init.c:19:32: warning: non-constant initializer for static object
+constexpr-init.c:21:26: warning: non-constant initializer for static object
+constexpr-init.c:22:40: warning: non-constant initializer for static object
+constexpr-init.c:23:49: warning: non-constant initializer for static object
+constexpr-init.c:24:52: warning: non-constant initializer for static object
+constexpr-init.c:26:19: warning: non-constant initializer for static object
+constexpr-init.c:27:22: warning: non-constant initializer for static object
+constexpr-init.c:28:25: warning: non-constant initializer for static object
+constexpr-init.c:29:34: warning: non-constant initializer for static object
+constexpr-init.c:38:24: warning: non-constant initializer for static object
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-labelref.c b/usr/src/tools/smatch/src/validation/constexpr-labelref.c
new file mode 100644
index 0000000000..15b5293aeb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-labelref.c
@@ -0,0 +1,14 @@
+static void a(void)
+{
+label1:
+	;
+	static void *b = &&label1;
+}
+
+/*
+ * check-name: label reference constness verification.
+ * check-command: sparse -Wconstexpr-not-const $file
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-offsetof.c b/usr/src/tools/smatch/src/validation/constexpr-offsetof.c
new file mode 100644
index 0000000000..d1697b0c5c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-offsetof.c
@@ -0,0 +1,21 @@
+struct A {
+	int a[1];
+	int b;
+};
+
+extern int c;
+
+static int o[] = {
+	[__builtin_offsetof(struct A, b)] = 0,		// OK
+	[__builtin_offsetof(struct A, a[0])] = 0,	// OK
+	[__builtin_offsetof(struct A, a[0*0])] = 0,	// OK
+	[__builtin_offsetof(struct A, a[c])] = 0	// KO
+};
+
+/*
+ * check-name: __builtin_offsetof() constness verification.
+ *
+ * check-error-start
+constexpr-offsetof.c:12:39: error: bad constant expression
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-pointer-arith.c b/usr/src/tools/smatch/src/validation/constexpr-pointer-arith.c
new file mode 100644
index 0000000000..a92202800a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-pointer-arith.c
@@ -0,0 +1,28 @@
+static int a = 1;
+static int b[2] = {1, 1};
+
+static int *c = &b[1];					// OK
+static int *d = (int*)0 + 1;				// OK
+static int *e = &b[1] + 1;				// OK
+static int *f = b + 1;					// OK
+static int *g = d + 1;					// KO
+static int *h = &a + 1;				// OK
+static int *i = &b[1] + 1;				// OK
+static int *j = b + 1;					// OK
+static int *k = d + 1;					// KO
+static int *l = &*&b[1];				// OK
+static int *m = &*(&a + 1);				// OK
+static int *n = &*(&b[1] + 1);				// OK
+static int *o = &*(b + 1);				// OK
+static int *p = &*(d + 1);				// KO
+
+/*
+ * check-name: pointer arithmetic constness verification.
+ * check-command: sparse -Wconstexpr-not-const $file
+ *
+ * check-error-start
+constexpr-pointer-arith.c:8:19: warning: non-constant initializer for static object
+constexpr-pointer-arith.c:12:19: warning: non-constant initializer for static object
+constexpr-pointer-arith.c:17:22: warning: non-constant initializer for static object
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-pointer-cast.c b/usr/src/tools/smatch/src/validation/constexpr-pointer-cast.c
new file mode 100644
index 0000000000..d19c10828d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-pointer-cast.c
@@ -0,0 +1,13 @@
+static int *a = (int*)0;	// OK
+static int b = 0;
+static int *c = (int*)b;	// KO
+
+
+/*
+ * check-name: integer literal cast to pointer type constness verification.
+ * check-command: sparse -Wconstexpr-not-const $file
+ *
+ * check-error-start
+constexpr-pointer-cast.c:3:18: warning: non-constant initializer for static object
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-preop.c b/usr/src/tools/smatch/src/validation/constexpr-preop.c
new file mode 100644
index 0000000000..5d869da4f7
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-preop.c
@@ -0,0 +1,29 @@
+static int a[] = {
+  [+0] = 0,					// OK
+  [+__builtin_choose_expr(0, 0, 0)] = 0,	// OK
+  [+0.] = 0,					// KO
+  [+__builtin_choose_expr(0, 0, 0.)] = 0,	// KO
+  [-0] = 0,					// OK
+  [-__builtin_choose_expr(0, 0, 0)] = 0,	// OK
+  [-0.] = 0,					// KO
+  [-__builtin_choose_expr(0, 0, 0.)] = 0,	// KO
+  [~0] = 0,					// OK
+  [~__builtin_choose_expr(0, 0, 0)] = 0,	// OK
+  [!0] = 0,					// OK
+  [!__builtin_choose_expr(0, 0, 0)] = 0,	// OK
+  [!0.] = 0,					// KO
+  [!__builtin_choose_expr(0, 0, 0.)] = 0,	// KO
+};
+
+/*
+ * check-name: Expression constness propagation in preops
+ *
+ * check-error-start
+constexpr-preop.c:4:5: error: bad constant expression
+constexpr-preop.c:5:33: error: bad constant expression
+constexpr-preop.c:8:4: error: bad constant expression
+constexpr-preop.c:9:4: error: bad constant expression
+constexpr-preop.c:14:4: error: bad integer constant expression
+constexpr-preop.c:15:4: error: bad integer constant expression
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-pure-builtin.c b/usr/src/tools/smatch/src/validation/constexpr-pure-builtin.c
new file mode 100644
index 0000000000..f4cd67edae
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-pure-builtin.c
@@ -0,0 +1,23 @@
+// requires constant integer expressions
+static int bar[] = {
+	[__builtin_bswap16(0x1234)] = 0,		// OK
+	[__builtin_bswap32(0x1234)] = 0,		// OK
+	[__builtin_bswap64(0x1234)] = 0,		// OK
+};
+
+// requires constant integers
+static int foo(unsigned long long a)
+{
+	switch (a) {
+	case __builtin_bswap16(1   <<  8):
+	case __builtin_bswap32(2L  << 24):
+	case __builtin_bswap64(3LL << 56):
+		return 0;
+	default:
+		return 1;
+	}
+}
+
+/*
+ * check-name: constness of pure/const builtins
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-string.c b/usr/src/tools/smatch/src/validation/constexpr-string.c
new file mode 100644
index 0000000000..e641a83eb2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-string.c
@@ -0,0 +1,9 @@
+static char *a = "foobar";	// OK
+
+/*
+ * check-name: string literal constness verification.
+ * check-command: sparse -Wconstexpr-not-const $file
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/constexpr-types-compatible-p.c b/usr/src/tools/smatch/src/validation/constexpr-types-compatible-p.c
new file mode 100644
index 0000000000..1969bf3bd2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/constexpr-types-compatible-p.c
@@ -0,0 +1,8 @@
+static int a[] = {[__builtin_types_compatible_p(int, int)] = 0};
+
+/*
+ * check-name: __builtin_types_compatible_p() constness verification.
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/context.c b/usr/src/tools/smatch/src/validation/context.c
new file mode 100644
index 0000000000..b9500dc750
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/context.c
@@ -0,0 +1,336 @@
+#define __cond_lock(c) ((c) ? ({ __context__(1); 1; }) : 0)
+
+static void a(void) __attribute__((context(0,1)))
+{
+	__context__(1);
+}
+
+static void r(void) __attribute__((context(1,0)))
+{
+	__context__(-1);
+}
+
+extern int _ca(int fail);
+#define ca(fail) __cond_lock(_ca(fail))
+
+static void good_paired1(void)
+{
+	a();
+	r();
+}
+
+static void good_paired2(void)
+{
+	a();
+	r();
+	a();
+	r();
+}
+
+static void good_paired3(void)
+{
+	a();
+	a();
+	r();
+	r();
+}
+
+static void good_lock1(void) __attribute__((context(0,1)))
+{
+	a();
+}
+
+static void good_lock2(void) __attribute__((context(0,1)))
+{
+	a();
+	r();
+	a();
+}
+
+static void good_lock3(void) __attribute__((context(0,1)))
+{
+	a();
+	a();
+	r();
+}
+
+static void good_unlock1(void) __attribute__((context(1,0)))
+{
+	r();
+}
+
+static void good_unlock2(void) __attribute__((context(1,0)))
+{
+	a();
+	r();
+	r();
+}
+
+static void warn_lock1(void)
+{
+	a();
+}
+
+static void warn_lock2(void)
+{
+	a();
+	r();
+	a();
+}
+
+static void warn_lock3(void)
+{
+	a();
+	a();
+	r();
+}
+
+static void warn_unlock1(void)
+{
+	r();
+}
+
+static void warn_unlock2(void)
+{
+	a();
+	r();
+	r();
+}
+
+extern int condition, condition2;
+
+static int good_if1(void)
+{
+	a();
+	if(condition) {
+		r();
+		return -1;
+	}
+	r();
+	return 0;
+}
+
+static void good_if2(void)
+{
+	if(condition) {
+		a();
+		r();
+	}
+}
+
+static void good_if3(void)
+{
+	a();
+	if(condition) {
+		a();
+		r();
+	}
+	r();
+}
+
+static int warn_if1(void)
+{
+	a();
+	if(condition)
+		return -1;
+	r();
+	return 0;
+}
+
+static int warn_if2(void)
+{
+	a();
+	if(condition) {
+		r();
+		return -1;
+	}
+	return 0;
+}
+
+static void good_while1(void)
+{
+	a();
+	while(condition)
+		;
+	r();
+}
+
+static void good_while2(void)
+{
+	while(condition) {
+		a();
+		r();
+	}
+}
+
+static void good_while3(void)
+{
+	while(condition) {
+		a();
+		r();
+		if(condition2)
+			break;
+		a();
+		r();
+	}
+}
+
+static void good_while4(void)
+{
+	a();
+	while(1) {
+		if(condition2) {
+			r();
+			break;
+		}
+	}
+}
+
+static void good_while5(void)
+{
+	a();
+	while(1) {
+		r();
+		if(condition2)
+			break;
+		a();
+	}
+}
+
+static void warn_while1(void)
+{
+	while(condition) {
+		a();
+	}
+}
+
+static void warn_while2(void)
+{
+	while(condition) {
+		r();
+	}
+}
+
+static void warn_while3(void)
+{
+	while(condition) {
+		a();
+		if(condition2)
+			break;
+		r();
+	}
+}
+
+static void good_goto1(void)
+{
+    a();
+    goto label;
+label:
+    r();
+}
+
+static void good_goto2(void)
+{
+    a();
+    goto label;
+    a();
+    r();
+label:
+    r();
+}
+
+static void good_goto3(void)
+{
+    a();
+    if(condition)
+        goto label;
+    a();
+    r();
+label:
+    r();
+}
+
+static void good_goto4(void)
+{
+    if(condition)
+        goto label;
+    a();
+    r();
+label:
+    ;
+}
+
+static void good_goto5(void)
+{
+    a();
+    if(condition)
+        goto label;
+    r();
+    return;
+label:
+    r();
+}
+
+static void warn_goto1(void)
+{
+    a();
+    goto label;
+    r();
+label:
+    ;
+}
+
+static void warn_goto2(void)
+{
+    a();
+    goto label;
+    r();
+label:
+    a();
+    r();
+}
+
+static void warn_goto3(void)
+{
+    a();
+    if(condition)
+        goto label;
+    r();
+label:
+    r();
+}
+
+static void good_cond_lock1(void)
+{
+    if(ca(condition)) {
+        condition2 = 1; /* do stuff */
+        r();
+    }
+}
+
+static void warn_cond_lock1(void)
+{
+    if(ca(condition))
+        condition2 = 1; /* do stuff */
+    r();
+}
+/*
+ * check-name: Check -Wcontext
+ *
+ * check-error-start
+context.c:69:13: warning: context imbalance in 'warn_lock1' - wrong count at exit
+context.c:74:13: warning: context imbalance in 'warn_lock2' - wrong count at exit
+context.c:81:13: warning: context imbalance in 'warn_lock3' - wrong count at exit
+context.c:88:13: warning: context imbalance in 'warn_unlock1' - unexpected unlock
+context.c:93:13: warning: context imbalance in 'warn_unlock2' - unexpected unlock
+context.c:131:12: warning: context imbalance in 'warn_if1' - wrong count at exit
+context.c:140:12: warning: context imbalance in 'warn_if2' - different lock contexts for basic block
+context.c:202:9: warning: context imbalance in 'warn_while1' - different lock contexts for basic block
+context.c:210:17: warning: context imbalance in 'warn_while2' - unexpected unlock
+context.c:216:9: warning: context imbalance in 'warn_while3' - wrong count at exit
+context.c:274:13: warning: context imbalance in 'warn_goto1' - wrong count at exit
+context.c:283:13: warning: context imbalance in 'warn_goto2' - wrong count at exit
+context.c:300:5: warning: context imbalance in 'warn_goto3' - different lock contexts for basic block
+context.c:315:5: warning: context imbalance in 'warn_cond_lock1' - different lock contexts for basic block
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/crash-add-doms.c b/usr/src/tools/smatch/src/validation/crash-add-doms.c
new file mode 100644
index 0000000000..54ad93e842
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/crash-add-doms.c
@@ -0,0 +1,22 @@
+char a;
+int b;
+void c(void)
+{
+	if (0) {
+		char *d;
+		for (;;)
+			for (;;)
+e:
+				*d *= (a && 0) ^ b && *d;
+	}
+	goto e;
+}
+
+
+/*
+ * check-name: crash add-doms
+ * check-command: test-linearize $file
+ *
+ * check-error-ignore
+ * check-output-ignore
+ */
diff --git a/usr/src/tools/smatch/src/validation/crash-bb_target.c b/usr/src/tools/smatch/src/validation/crash-bb_target.c
new file mode 100644
index 0000000000..bc5a3d3543
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/crash-bb_target.c
@@ -0,0 +1,10 @@
+a() {
+  &&b
+
+/*
+ * check-name: crash bb_target
+ * check-command: test-linearize $file
+ *
+ * check-error-ignore
+ * check-output-ignore
+ */
diff --git a/usr/src/tools/smatch/src/validation/crash-ep-active.c b/usr/src/tools/smatch/src/validation/crash-ep-active.c
new file mode 100644
index 0000000000..6945f320b9
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/crash-ep-active.c
@@ -0,0 +1,12 @@
+int a(int b)
+{
+        return 0( && b;
+}
+
+/*
+ * check-name: crash ep->active
+ * check-command: test-linearize $file
+ *
+ * check-error-ignore
+ * check-output-ignore
+ */
diff --git a/usr/src/tools/smatch/src/validation/crash-ptrlist.c b/usr/src/tools/smatch/src/validation/crash-ptrlist.c
new file mode 100644
index 0000000000..8e9b5cb5fa
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/crash-ptrlist.c
@@ -0,0 +1,23 @@
+a;
+char b;
+c() {
+  while () {
+    int *d;
+    while () {
+      char *e = &b;
+      if (a ?: (*d = f || *0) || g) {
+        if
+          ;
+      } else {
+        int h = 0;
+        if (j) {
+          char **i = &e;
+          if (0 ? 0 : 0 ?: (**i = 1 || 0 && 0))             h ?: (*e = i && &h
+
+/*
+ * check-name: crash ptrlist
+ * check-command: test-linearize $file
+ *
+ * check-error-ignore
+ * check-output-ignore
+ */
diff --git a/usr/src/tools/smatch/src/validation/crash-rewrite-branch.c b/usr/src/tools/smatch/src/validation/crash-rewrite-branch.c
new file mode 100644
index 0000000000..eb310df1cd
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/crash-rewrite-branch.c
@@ -0,0 +1,24 @@
+void a(int c, int e)
+{
+	for(;                   b; c ;
+
+	if (()) {
+		unsigned short d = e;
+		if (())
+			while ()
+				;
+		&d;
+	}
+
+	if (()) {
+		int f = &f;
+	}
+}
+
+/*
+ * check-name: crash rewrite_branch
+ * check-command: test-linearize $file
+ *
+ * check-error-ignore
+ * check-output-ignore
+ */
diff --git a/usr/src/tools/smatch/src/validation/crazy02-not-so.c b/usr/src/tools/smatch/src/validation/crazy02-not-so.c
new file mode 100644
index 0000000000..19ee25299f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/crazy02-not-so.c
@@ -0,0 +1,40 @@
+int foo(int *ptr, int i)
+{
+	int *p;
+
+	switch (i - i) {		// will be optimized to 0
+	case 0:
+		return 0;
+	case 1:				// will be optimized away
+		p = ptr;
+		do {			// will be an unreachable loop
+			*p++ = 123;
+		} while (--i);
+		break;
+	}
+
+	return 1;
+}
+
+int bar(int *ptr, int i)
+{
+	int *p;
+
+	switch (i - i) {		// will be optimized to 0
+	case 0:
+		return 0;
+	case 1:				// will be optimized away
+					// p is uninitialized
+		do {			// will be an unreachable loop
+			*p++ = 123;
+		} while (--i);
+		break;
+	}
+
+	return 1;
+}
+
+/*
+ * check-name: crazy02-not-so.c
+ * check-command: sparse -Wno-decl $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/crazy03.c b/usr/src/tools/smatch/src/validation/crazy03.c
new file mode 100644
index 0000000000..042033790a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/crazy03.c
@@ -0,0 +1,33 @@
+extern char a;
+extern int b;
+extern char *c, *d;
+extern void e(void);
+extern void f(char *);
+
+int g(int h);
+int g(int h)
+{
+	if (h > 1)
+		e();
+	if (h > 1)
+		return 0;
+	for (;;) {
+		if (a) {
+			while (c) ;
+			b = 0;
+		} else {
+			c = (void*)0;
+			b = 1;
+		}
+		if (b) {
+			f(c);
+			continue;
+		}
+		d = c;
+		while (*c++) ;
+	}
+}
+
+/*
+ * check-name: crazy03.c
+ */
diff --git a/usr/src/tools/smatch/src/validation/declaration-after-statement-ansi.c b/usr/src/tools/smatch/src/validation/declaration-after-statement-ansi.c
new file mode 100644
index 0000000000..22635cfafd
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/declaration-after-statement-ansi.c
@@ -0,0 +1,12 @@
+static void func (int i)
+{
+	i;
+	int j = i;
+}
+/*
+ * check-name: declaration after statement (ANSI)
+ * check-command: sparse -ansi $file
+ * check-error-start
+declaration-after-statement-ansi.c:4:9: warning: mixing declarations and code
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/declaration-after-statement-c89.c b/usr/src/tools/smatch/src/validation/declaration-after-statement-c89.c
new file mode 100644
index 0000000000..886f9713f9
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/declaration-after-statement-c89.c
@@ -0,0 +1,12 @@
+static void func (int i)
+{
+	i;
+	int j = i;
+}
+/*
+ * check-name: declaration after statement (C89)
+ * check-command: sparse -std=c89 $file
+ * check-error-start
+declaration-after-statement-c89.c:4:9: warning: mixing declarations and code
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/declaration-after-statement-c99.c b/usr/src/tools/smatch/src/validation/declaration-after-statement-c99.c
new file mode 100644
index 0000000000..dd36e6efe3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/declaration-after-statement-c99.c
@@ -0,0 +1,9 @@
+static void func (int i)
+{
+	i;
+	int j = i;
+}
+/*
+ * check-name: declaration after statement (C99)
+ * check-command: sparse -std=c99 $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/declaration-after-statement-default.c b/usr/src/tools/smatch/src/validation/declaration-after-statement-default.c
new file mode 100644
index 0000000000..c3fe2cd211
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/declaration-after-statement-default.c
@@ -0,0 +1,9 @@
+static void func (int i)
+{
+	i;
+	int j = i;
+}
+/*
+ * check-name: declaration after statement (default)
+ * check-command: sparse $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/definitions.c b/usr/src/tools/smatch/src/validation/definitions.c
new file mode 100644
index 0000000000..fce7393eff
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/definitions.c
@@ -0,0 +1,12 @@
+static inline int f(void);
+static int g(void)
+{
+        return f();
+}
+static inline int f(void)
+{
+	return 0;
+}
+/*
+ * check-name: finding definitions
+ */
diff --git a/usr/src/tools/smatch/src/validation/designated-init.c b/usr/src/tools/smatch/src/validation/designated-init.c
new file mode 100644
index 0000000000..23423e9618
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/designated-init.c
@@ -0,0 +1,195 @@
+struct s1 {
+	int x;
+	int y;
+};
+
+struct s2 {
+	int x;
+	int y;
+} __attribute__((designated_init));
+
+struct nest1 {
+	struct s1 s1;
+	struct s2 s2;
+};
+
+struct nest2 {
+	struct s1 s1;
+	struct s2 s2;
+} __attribute__((designated_init));
+
+static struct s1 s1_positional = { 5, 10 };
+static struct s1 s1_designated = { .x = 5, .y = 10 };
+static struct s2 s2_positional = { 5, 10 };
+static struct s2 s2_designated = { .x = 5, .y = 10 };
+static struct nest1 nest1_positional = {
+	{ 5, 10 },
+	{ 5, 10 },
+};
+static struct nest1 nest1_designated_outer = {
+	.s1 = { 5, 10 },
+	.s2 = { 5, 10 },
+};
+static struct nest1 nest1_designated_inner = {
+	{ .x = 5, .y = 10 },
+	{ .x = 5, .y = 10 },
+};
+static struct nest1 nest1_designated_both = {
+	.s1 = { .x = 5, .y = 10 },
+	.s2 = { .x = 5, .y = 10 },
+};
+static struct nest2 nest2_positional = {
+	{ 5, 10 },
+	{ 5, 10 },
+};
+static struct nest2 nest2_designated_outer = {
+	.s1 = { 5, 10 },
+	.s2 = { 5, 10 },
+};
+static struct nest2 nest2_designated_inner = {
+	{ .x = 5, .y = 10 },
+	{ .x = 5, .y = 10 },
+};
+static struct nest2 nest2_designated_both = {
+	.s1 = { .x = 5, .y = 10 },
+	.s2 = { .x = 5, .y = 10 },
+};
+
+static struct {
+	int x;
+	int y;
+} __attribute__((designated_init))
+	anon_positional = { 5, 10 },
+	anon_designated = { .x = 5, .y = 10};
+
+static struct s1 s1_array[] = {
+	{ 5, 10 },
+	{ .x = 5, .y = 10 },
+};
+
+static struct s2 s2_array[] = {
+	{ 5, 10 },
+	{ .x = 5, .y = 10 },
+};
+
+static struct s1 ret_s1_positional(void)
+{
+	return ((struct s1){ 5, 10 });
+}
+
+static struct s1 ret_s1_designated(void)
+{
+	return ((struct s1){ .x = 5, .y = 10 });
+}
+
+static struct s2 ret_s2_positional(void)
+{
+	return ((struct s2){ 5, 10 });
+}
+
+static struct s2 ret_s2_designated(void)
+{
+	return ((struct s2){ .x = 5, .y = 10 });
+}
+
+static struct nest1 ret_nest1_positional(void)
+{
+	return ((struct nest1){
+			{ 5, 10 },
+			{ 5, 10 },
+		});
+}
+
+static struct nest1 ret_nest1_designated_outer(void)
+{
+	return ((struct nest1){
+			.s1 = { 5, 10 },
+			.s2 = { 5, 10 },
+		});
+}
+
+static struct nest1 ret_nest1_designated_inner(void)
+{
+	return ((struct nest1){
+			{ .x = 5, .y = 10 },
+			{ .x = 5, .y = 10 },
+		});
+}
+
+static struct nest1 ret_nest1_designated_both(void)
+{
+	return ((struct nest1){
+			.s1 = { .x = 5, .y = 10 },
+			.s2 = { .x = 5, .y = 10 },
+		});
+}
+
+static struct nest2 ret_nest2_positional(void)
+{
+	return ((struct nest2){
+			{ 5, 10 },
+			{ 5, 10 },
+		});
+}
+
+static struct nest2 ret_nest2_designated_outer(void)
+{
+	return ((struct nest2){
+			.s1 = { 5, 10 },
+			.s2 = { 5, 10 },
+		});
+}
+
+static struct nest2 ret_nest2_designated_inner(void)
+{
+	return ((struct nest2){
+			{ .x = 5, .y = 10 },
+			{ .x = 5, .y = 10 },
+		});
+}
+
+static struct nest2 ret_nest2_designated_both(void)
+{
+	return ((struct nest2){
+			.s1 = { .x = 5, .y = 10 },
+			.s2 = { .x = 5, .y = 10 },
+		});
+}
+/*
+ * check-name: designated_init attribute
+ *
+ * check-error-start
+designated-init.c:23:36: warning: in initializer for s2_positional: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:23:39: warning: in initializer for s2_positional: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:27:11: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:27:14: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:31:17: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:31:20: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:42:9: warning: in initializer for nest2_positional: positional init of field in struct nest2, declared with attribute designated_init
+designated-init.c:43:9: warning: in initializer for nest2_positional: positional init of field in struct nest2, declared with attribute designated_init
+designated-init.c:43:11: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:43:14: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:47:17: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:47:20: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:50:9: warning: in initializer for nest2_designated_inner: positional init of field in struct nest2, declared with attribute designated_init
+designated-init.c:51:9: warning: in initializer for nest2_designated_inner: positional init of field in struct nest2, declared with attribute designated_init
+designated-init.c:62:29: warning: in initializer for anon_positional: positional init of field in struct <noident>, declared with attribute designated_init
+designated-init.c:62:32: warning: in initializer for anon_positional: positional init of field in struct <noident>, declared with attribute designated_init
+designated-init.c:71:11: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:71:14: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:87:30: warning: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:87:33: warning: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:99:27: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:99:30: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:107:33: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:107:36: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:130:25: warning: positional init of field in struct nest2, declared with attribute designated_init
+designated-init.c:131:25: warning: positional init of field in struct nest2, declared with attribute designated_init
+designated-init.c:131:27: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:131:30: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:139:33: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:139:36: warning: in initializer for s2: positional init of field in struct s2, declared with attribute designated_init
+designated-init.c:146:25: warning: positional init of field in struct nest2, declared with attribute designated_init
+designated-init.c:147:25: warning: positional init of field in struct nest2, declared with attribute designated_init
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/discarded-label-statement.c b/usr/src/tools/smatch/src/validation/discarded-label-statement.c
new file mode 100644
index 0000000000..b4e58ac64e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/discarded-label-statement.c
@@ -0,0 +1,24 @@
+/*
+ * Verify that the statement following an unused label
+ * is not discarded with the label.
+ */
+
+static int bad(int a, int b)
+{
+	int r = 0;
+
+start:
+	r += a;
+	r += b;
+
+	return r;
+}
+
+/*
+ * check-name: discarded-label-statement
+ * check-command: test-linearize $file
+ *
+ * check-output-ignore
+ * check-output-contains: add
+ * check-output-contains: %arg1
+ */
diff --git a/usr/src/tools/smatch/src/validation/div.c b/usr/src/tools/smatch/src/validation/div.c
new file mode 100644
index 0000000000..3e6fb69889
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/div.c
@@ -0,0 +1,31 @@
+#define	INT_MIN		(-__INT_MAX__ - 1)
+#define	LONG_MIN	(-__LONG_MAX__ - 1)
+#define	LLONG_MIN	(-__LONG_LONG_MAX__ - 1)
+
+static int xd = 1 / 0;
+static int xl = 1L / 0;
+static int xll = 1LL / 0;
+
+static int yd = INT_MIN / -1;
+static long yl = LONG_MIN / -1;
+static long long yll = LLONG_MIN / -1;
+
+static int zd = INT_MIN % -1;
+static long zl = LONG_MIN % -1;
+static long long zll = LLONG_MIN % -1;
+
+/*
+ * check-name: division constants
+ *
+ * check-error-start
+div.c:5:19: warning: division by zero
+div.c:6:20: warning: division by zero
+div.c:7:22: warning: division by zero
+div.c:9:25: warning: constant integer operation overflow
+div.c:10:27: warning: constant integer operation overflow
+div.c:11:34: warning: constant integer operation overflow
+div.c:13:25: warning: constant integer operation overflow
+div.c:14:27: warning: constant integer operation overflow
+div.c:15:34: warning: constant integer operation overflow
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/double-semicolon.c b/usr/src/tools/smatch/src/validation/double-semicolon.c
new file mode 100644
index 0000000000..a1b8e6361c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/double-semicolon.c
@@ -0,0 +1,9 @@
+extern void *memset (void *s, int c, int n);
+static void test(void)
+{
+	struct { int foo;; } val;
+	memset(&val, 0, sizeof(val));
+}
+/*
+ * check-name: Double semicolon in struct
+ */
diff --git a/usr/src/tools/smatch/src/validation/dubious-bitwise-with-not.c b/usr/src/tools/smatch/src/validation/dubious-bitwise-with-not.c
new file mode 100644
index 0000000000..c48bcaee79
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/dubious-bitwise-with-not.c
@@ -0,0 +1,24 @@
+static unsigned int ok1  = !1 &&  2;
+static unsigned int bad1 = !1 &   2;
+static unsigned int ok2  = !1 ||  2;
+static unsigned int bad2 = !1 |   2;
+static unsigned int ok3  =  1 && !2;
+static unsigned int bad3 =  1 &  !2;
+static unsigned int ok4  =  1 || !2;
+static unsigned int bad4 =  1 |  !2;
+static unsigned int ok5  = !1 && !2;
+static unsigned int bad5 = !1 &  !2;
+static unsigned int ok6  = !1 || !2;
+static unsigned int bad6 = !1 |  !2;
+/*
+ * check-name: Dubious bitwise operation on !x
+ *
+ * check-error-start
+dubious-bitwise-with-not.c:2:31: warning: dubious: !x & y
+dubious-bitwise-with-not.c:4:31: warning: dubious: !x | y
+dubious-bitwise-with-not.c:6:31: warning: dubious: x & !y
+dubious-bitwise-with-not.c:8:31: warning: dubious: x | !y
+dubious-bitwise-with-not.c:10:31: warning: dubious: !x & !y
+dubious-bitwise-with-not.c:12:31: warning: dubious: !x | !y
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/empty-file b/usr/src/tools/smatch/src/validation/empty-file
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/empty-file
diff --git a/usr/src/tools/smatch/src/validation/endian-big.c b/usr/src/tools/smatch/src/validation/endian-big.c
new file mode 100644
index 0000000000..ebf95df702
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/endian-big.c
@@ -0,0 +1,14 @@
+#if defined(__LITTLE_ENDIAN__)
+#error "__LITTLE_ENDIAN__ defined!"
+#endif
+#if (__BIG_ENDIAN__ != 1)
+#error "__BIG_ENDIAN__ not correctly defined!"
+#endif
+#if (__BYTE_ORDER__ != __ORDER_BIG_ENDIAN__)
+#error "__BYTE_ORDER__ not correctly defined!"
+#endif
+
+/*
+ * check-name: endian-big.c
+ * check-command: sparse -mbig-endian $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/endian-little.c b/usr/src/tools/smatch/src/validation/endian-little.c
new file mode 100644
index 0000000000..57ef69866e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/endian-little.c
@@ -0,0 +1,14 @@
+#if defined(__BIG_ENDIAN__)
+#error "__BIG_ENDIAN__ defined!"
+#endif
+#if (__LITTLE_ENDIAN__ != 1)
+#error "__LITTLE_ENDIAN__ not correctly defined!"
+#endif
+#if (__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__)
+#error "__BYTE_ORDER__ not correctly defined!"
+#endif
+
+/*
+ * check-name: endian-little.c
+ * check-command: sparse -mlittle-endian $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/enum-common.c b/usr/src/tools/smatch/src/validation/enum-common.c
new file mode 100644
index 0000000000..f940fefacc
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/enum-common.c
@@ -0,0 +1,112 @@
+static enum ENUM_TYPE_A { VALUE_A } var_a;
+static enum ENUM_TYPE_B { VALUE_B } var_b;
+static enum /* anon. */ { VALUE_C } anon_enum_var;
+static int i;
+
+static void take_enum_of_type_a(enum ENUM_TYPE_A arg_enum)
+{
+	(void) arg_enum;
+}
+
+static void take_int(int arg_int)
+{
+	(void) arg_int;
+}
+
+static void always_ok(void)
+{
+	var_a ++;
+	var_a = VALUE_A;
+	var_a = (enum ENUM_TYPE_A) VALUE_B;
+	var_b = (enum ENUM_TYPE_B) i;
+	i = (int) VALUE_A;
+	anon_enum_var = VALUE_C;
+	i = VALUE_C;
+	i = anon_enum_var;
+	i = 7;
+	var_a = (enum ENUM_TYPE_A) 0;
+	anon_enum_var = (__typeof__(anon_enum_var)) 0;
+	anon_enum_var = (__typeof__(anon_enum_var)) VALUE_A;
+
+	switch (var_a) {
+		case VALUE_A:
+		default:
+			take_enum_of_type_a(var_a);
+			take_enum_of_type_a(VALUE_A);
+	}
+
+	switch (anon_enum_var) {
+		case VALUE_C:
+		default:
+			take_int(anon_enum_var);
+	}
+
+	switch (i) {
+		case VALUE_C:
+		default:
+			take_int(VALUE_C);
+	}
+}
+
+static void trigger_enum_mismatch(void)
+{
+	switch (var_a) {
+		case VALUE_B:
+		case VALUE_C:
+		default:
+			take_enum_of_type_a(var_b);
+			take_enum_of_type_a(VALUE_B);
+	}
+
+	switch (anon_enum_var) {
+		case VALUE_A:
+		default:
+			take_enum_of_type_a(anon_enum_var);
+			take_enum_of_type_a(VALUE_C);
+	}
+
+	// this has been already working in sparse 0.4.1
+	var_a = var_b;
+	var_b = anon_enum_var;
+	anon_enum_var = var_a;
+
+	// implemented after sparse 0.4.1
+	var_a = VALUE_B;
+	var_b = VALUE_C;
+	anon_enum_var = VALUE_A;
+}
+
+static void trigger_int_to_enum_conversion(void)
+{
+	switch (var_a) {
+		case 0:
+		default:
+			take_enum_of_type_a(i);
+			take_enum_of_type_a(7);
+	}
+	var_a = 0;
+	var_b = i;
+	anon_enum_var = 0;
+	anon_enum_var = i;
+	var_a = (int) VALUE_A;
+	var_a = (int) VALUE_B;
+}
+
+static void trigger_enum_to_int_conversion(void)
+{
+	i = var_a;
+	i = VALUE_B;
+	switch (i) {
+		case VALUE_A:
+		case VALUE_B:
+		default:
+			take_int(var_a);
+			take_int(VALUE_B);
+	}
+}
+
+/*
+ * check-name: enum-common
+ * check-description: common part of the test for -Wenum-mismatch, -Wenum-to-int and -Wint-to-enum
+ * check-command: sparse -Wno-enum-mismatch -Wno-int-to-enum $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/enum-from-int.c b/usr/src/tools/smatch/src/validation/enum-from-int.c
new file mode 100644
index 0000000000..15b1e4df1c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/enum-from-int.c
@@ -0,0 +1,36 @@
+#include "enum-common.c"
+
+/*
+ * check-name: -Wint-to-enum
+ * check-command: sparse -Wno-enum-mismatch $file
+ *
+ * check-error-start
+enum-common.c:84:45: warning: conversion of
+enum-common.c:84:45:     int to
+enum-common.c:84:45:     int enum ENUM_TYPE_A 
+enum-common.c:85:45: warning: conversion of
+enum-common.c:85:45:     int to
+enum-common.c:85:45:     int enum ENUM_TYPE_A 
+enum-common.c:82:22: warning: conversion of
+enum-common.c:82:22:     int to
+enum-common.c:82:22:     int enum ENUM_TYPE_A 
+enum-common.c:87:17: warning: conversion of
+enum-common.c:87:17:     int to
+enum-common.c:87:17:     int enum ENUM_TYPE_A 
+enum-common.c:88:17: warning: conversion of
+enum-common.c:88:17:     int to
+enum-common.c:88:17:     int enum ENUM_TYPE_B 
+enum-common.c:89:25: warning: conversion of
+enum-common.c:89:25:     int to
+enum-common.c:89:25:     int enum <noident> 
+enum-common.c:90:25: warning: conversion of
+enum-common.c:90:25:     int to
+enum-common.c:90:25:     int enum <noident> 
+enum-common.c:91:18: warning: conversion of
+enum-common.c:91:18:     int to
+enum-common.c:91:18:     int enum ENUM_TYPE_A 
+enum-common.c:92:18: warning: conversion of
+enum-common.c:92:18:     int to
+enum-common.c:92:18:     int enum ENUM_TYPE_A 
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/enum-mismatch.c b/usr/src/tools/smatch/src/validation/enum-mismatch.c
new file mode 100644
index 0000000000..9a929d24ca
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/enum-mismatch.c
@@ -0,0 +1,19 @@
+enum ea { A = 0, };
+enum eb { B = 1, };
+
+
+static enum eb foo(enum ea a)
+{
+	return a;
+}
+
+/*
+ * check-name: enum-mismatch
+ * check-command: sparse -Wenum-mismatch $file
+ *
+ * check-error-start
+enum-mismatch.c:7:16: warning: mixing different enum types
+enum-mismatch.c:7:16:     int enum ea  versus
+enum-mismatch.c:7:16:     int enum eb 
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/enum-to-int.c b/usr/src/tools/smatch/src/validation/enum-to-int.c
new file mode 100644
index 0000000000..a981ce5d65
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/enum-to-int.c
@@ -0,0 +1,27 @@
+#include "enum-common.c"
+
+/*
+ * check-name: -Wenum-to-int
+ * check-command: sparse -Wenum-to-int -Wno-enum-mismatch -Wno-int-to-enum $file
+ *
+ * check-error-start
+enum-common.c:97:13: warning: conversion of
+enum-common.c:97:13:     int enum ENUM_TYPE_A  to
+enum-common.c:97:13:     int
+enum-common.c:98:13: warning: conversion of
+enum-common.c:98:13:     int enum ENUM_TYPE_B  to
+enum-common.c:98:13:     int
+enum-common.c:103:34: warning: conversion of
+enum-common.c:103:34:     int enum ENUM_TYPE_A  to
+enum-common.c:103:34:     int
+enum-common.c:104:34: warning: conversion of
+enum-common.c:104:34:     int enum ENUM_TYPE_B  to
+enum-common.c:104:34:     int
+enum-common.c:100:22: warning: conversion of
+enum-common.c:100:22:     int enum ENUM_TYPE_A  to
+enum-common.c:100:22:     int
+enum-common.c:101:22: warning: conversion of
+enum-common.c:101:22:     int enum ENUM_TYPE_B  to
+enum-common.c:101:22:     int
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/enum_scope.c b/usr/src/tools/smatch/src/validation/enum_scope.c
new file mode 100644
index 0000000000..92ffc8ef59
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/enum_scope.c
@@ -0,0 +1,11 @@
+enum {A = 12};
+
+static void f(void)
+{
+	enum {A = A + 1, B};
+	char s[1 - 2 * (B != 14)];
+}
+
+/*
+ * check-name: enumeration constants' scope [6.2.1p7]
+ */
diff --git a/usr/src/tools/smatch/src/validation/escapes.c b/usr/src/tools/smatch/src/validation/escapes.c
new file mode 100644
index 0000000000..604a37d339
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/escapes.c
@@ -0,0 +1,32 @@
+static int e[] = { '\'', '\"', '\?', '\\',
+                   '\a', '\b', '\f', '\n', '\r', '\t', '\v',
+		   '\0', '\012', '\x7890', '\xabcd' };
+static char *s = "\'\"\?\\ \a\b\f\n\r\t\v \377\xcafe";
+
+static int bad_e[] = { '\c', '\0123', '\789', '\xdefg' };
+
+static char a_hex[3] = "\x61\x62\x63";
+static char b_hex[3] = "\x61\x62\x63\x64";
+static char c_hex[3] = "\x61\x62";
+static char d_hex[3] = "\x61";
+
+static char a_oct[3] = "\141\142\143";
+static char b_oct[3] = "\141\142\143\144";
+static char c_oct[3] = "\141\142";
+static char d_oct[3] = "\141";
+/*
+ * check-name: Character escape sequences
+ *
+ * check-error-start
+escapes.c:3:34: warning: hex escape sequence out of range
+escapes.c:3:44: warning: hex escape sequence out of range
+escapes.c:4:18: warning: hex escape sequence out of range
+escapes.c:6:24: warning: unknown escape sequence: '\c'
+escapes.c:6:30: warning: multi-character character constant
+escapes.c:6:39: warning: multi-character character constant
+escapes.c:6:47: warning: hex escape sequence out of range
+escapes.c:6:47: warning: multi-character character constant
+escapes.c:9:24: warning: too long initializer-string for array of char
+escapes.c:14:24: warning: too long initializer-string for array of char
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/extern-array.c b/usr/src/tools/smatch/src/validation/extern-array.c
new file mode 100644
index 0000000000..58bc7ae686
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/extern-array.c
@@ -0,0 +1,14 @@
+extern const char *v4l2_type_names[];
+const char *v4l2_type_names[] = {
+        "test"
+};
+extern const char *v4l2_type_names[];
+
+static void test(void)
+{
+        unsigned sz = sizeof(v4l2_type_names);
+}
+/*
+ * check-name: duplicate extern array
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/extern-inline.c b/usr/src/tools/smatch/src/validation/extern-inline.c
new file mode 100644
index 0000000000..4f12ac06f4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/extern-inline.c
@@ -0,0 +1,23 @@
+extern __inline__ int f(int);
+
+extern __inline__ int
+f(int x)
+{
+        return x;
+}
+
+extern int g(int);
+
+extern __inline__ int
+g(int x)
+{
+        return x;
+}
+
+
+/*
+ * check-name: extern inline function
+ * check-command: sparse $file $file
+ * check-description: Extern inline function never emits stand alone copy
+ * of the function. It allows multiple such definitions in different file.
+ */
diff --git a/usr/src/tools/smatch/src/validation/external-function-has-definition.c b/usr/src/tools/smatch/src/validation/external-function-has-definition.c
new file mode 100644
index 0000000000..cd96df4ad1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/external-function-has-definition.c
@@ -0,0 +1,15 @@
+
+extern void myfunction(void);
+
+extern void
+myfunction(void)
+{
+	return;
+}
+
+/*
+ * check-name: -Wno-external-function-has-definition works
+ * check-command: sparse -Wno-external-function-has-definition
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/field-overlap.c b/usr/src/tools/smatch/src/validation/field-overlap.c
new file mode 100644
index 0000000000..a6abab254a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/field-overlap.c
@@ -0,0 +1,16 @@
+static struct {
+	int x;
+	struct {
+		int z;
+		int w;
+	} y;
+} a = { .y.z = 1, .y.w = 2, };
+
+static struct {int x, y, z;} w[2] = {
+	{.x = 1, .y = 2, .z = 3},
+	{.x = 1, .y = 2, .z = 3}
+};
+
+/*
+ * check-name: field overlap
+ */
diff --git a/usr/src/tools/smatch/src/validation/field-override.c b/usr/src/tools/smatch/src/validation/field-override.c
new file mode 100644
index 0000000000..ec6987df7c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/field-override.c
@@ -0,0 +1,101 @@
+static int ref[] = {
+	[1] = 3,
+	[2] = 3,
+	[3] = 3,
+	[2] = 2,		/* check-should-warn */
+	[1] = 1,		/* check-should-warn */
+};
+
+static int foo[] = {
+	[1 ... 3] = 3,
+};
+
+static int foz[4] = {
+	[0 ... 3] = 3,
+	[0] = 0,
+	[1] = 0,
+	[2 ... 3] = 1,
+	[2] = 3,		/* check-should-warn */
+	[3] = 3,		/* check-should-warn */
+};
+
+static int bar[] = {
+	[1 ... 3] = 3,
+	[1]       = 1,		/* check-should-warn */
+	[2]       = 2,		/* check-should-warn */
+	[2 ... 4] = 2,		/* check-should-warn */
+	[2 ... 3] = 2,		/* check-should-warn */
+	[4] = 4,		/* check-should-warn */
+	[0] = 0,
+	[5] = 5,
+};
+
+static int baz[3][3] = {
+	[0 ... 2][0 ... 2] = 0,
+	[0] = { 0, 0, 0, },	/* check-should-warn */
+	[0][0] = 1,		/* check-should-warn */
+	[1] = { 0, 0, 0, },	/* check-should-warn */
+	[1][0] = 1,		/* check-should-warn */
+	[1][1] = 1,		/* check-should-warn */
+	[1 ... 2][1 ... 2] = 2,
+};
+
+
+struct s {
+	int i;
+	int a[2];
+};
+
+static struct s s = {
+	.a[0] = 0,
+	.a[1] = 1,
+};
+
+static struct s a[2] = {
+	[0].i = 0,
+	[1].i = 1,
+	[0].a[0] = 2,
+	[0].a[1] = 3,
+};
+
+static struct s b[2] = {
+	[0 ... 1] = { 0, { 1, 2 }, },
+	[0].i = 0,
+	[1].i = 1,
+	[0].a[0] = 2,
+	[0].a[1] = 3,
+};
+
+/*
+ * check-name: field-override
+ * check-command: sparse -Woverride-init -Woverride-init-all $file
+ *
+ * check-error-start
+field-override.c:2:10: warning: Initializer entry defined twice
+field-override.c:6:10:   also defined here
+field-override.c:3:10: warning: Initializer entry defined twice
+field-override.c:5:10:   also defined here
+field-override.c:17:10: warning: Initializer entry defined twice
+field-override.c:18:10:   also defined here
+field-override.c:17:10: warning: Initializer entry defined twice
+field-override.c:19:10:   also defined here
+field-override.c:23:10: warning: Initializer entry defined twice
+field-override.c:24:10:   also defined here
+field-override.c:23:10: warning: Initializer entry defined twice
+field-override.c:25:10:   also defined here
+field-override.c:23:10: warning: Initializer entry defined twice
+field-override.c:26:10:   also defined here
+field-override.c:26:10: warning: Initializer entry defined twice
+field-override.c:27:10:   also defined here
+field-override.c:26:10: warning: Initializer entry defined twice
+field-override.c:28:10:   also defined here
+field-override.c:35:10: warning: Initializer entry defined twice
+field-override.c:36:10:   also defined here
+field-override.c:37:10: warning: Initializer entry defined twice
+field-override.c:38:10:   also defined here
+field-override.c:37:10: warning: Initializer entry defined twice
+field-override.c:39:10:   also defined here
+field-override.c:37:10: warning: Initializer entry defined twice
+field-override.c:40:10:   also defined here
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/fored_arg.c b/usr/src/tools/smatch/src/validation/fored_arg.c
new file mode 100644
index 0000000000..4ab71419a0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/fored_arg.c
@@ -0,0 +1,18 @@
+/*
+ * check-name: Forced function argument type.
+ */
+
+#define __iomem	__attribute__((noderef, address_space(2)))
+#define __force __attribute__((force))
+
+static void foo(__force void * addr)
+{
+}
+
+
+static void bar(void)
+{
+	void __iomem  *a;
+	foo(a);
+}
+
diff --git a/usr/src/tools/smatch/src/validation/foul-bitwise.c b/usr/src/tools/smatch/src/validation/foul-bitwise.c
new file mode 100644
index 0000000000..4b542cf940
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/foul-bitwise.c
@@ -0,0 +1,32 @@
+typedef unsigned short __attribute__((bitwise))__le16;
+static __le16 foo(__le16 a)
+{
+	return a |= ~a;
+}
+
+static int baz(__le16 a)
+{
+	return ~a == ~a;
+}
+
+static int barf(__le16 a)
+{
+	return a == (a & ~a);
+}
+
+static __le16 bar(__le16 a)
+{
+	return -a;
+}
+
+/*
+ * check-name: foul bitwise
+ * check-error-start
+foul-bitwise.c:9:16: warning: restricted __le16 degrades to integer
+foul-bitwise.c:9:22: warning: restricted __le16 degrades to integer
+foul-bitwise.c:19:16: warning: restricted __le16 degrades to integer
+foul-bitwise.c:19:16: warning: incorrect type in return expression (different base types)
+foul-bitwise.c:19:16:    expected restricted __le16
+foul-bitwise.c:19:16:    got int
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/fp-vs-ptrcast.c b/usr/src/tools/smatch/src/validation/fp-vs-ptrcast.c
new file mode 100644
index 0000000000..817aee5c90
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/fp-vs-ptrcast.c
@@ -0,0 +1,13 @@
+float *f01(void* p)
+{
+	return p;
+}
+
+/*
+ * check-name: fp-vs-ptrcast
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-excludes: fpcast
+ * check-output-contains: ptrcast
+ */
diff --git a/usr/src/tools/smatch/src/validation/function-pointer-inheritance.c b/usr/src/tools/smatch/src/validation/function-pointer-inheritance.c
new file mode 100644
index 0000000000..0b24e45882
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/function-pointer-inheritance.c
@@ -0,0 +1,9 @@
+extern int foo(int f(int, void *));
+
+int foo(int (*f)(int, void *))
+{
+    return 0;
+}
+/*
+ * check-name: Function pointer inheritance
+ */
diff --git a/usr/src/tools/smatch/src/validation/function-redecl.c b/usr/src/tools/smatch/src/validation/function-redecl.c
new file mode 100644
index 0000000000..475f18e798
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/function-redecl.c
@@ -0,0 +1,62 @@
+#define __user	__attribute__((address_space(1)))
+#define NULL	((void*)0)
+
+int ret_type(void);
+void ret_type(void) { }				/* check-should-fail */
+
+
+int ret_const(void);
+int const ret_const(void) { return 0; }		/* check-should-fail */
+
+
+void *ret_as(void);
+void __user *ret_as(void) { return NULL; }	/* check-should-fail */
+
+
+void *ret_mod(void);
+void const *ret_mod(void) { return NULL; }	/* check-should-fail */
+
+
+void arg_type(int a);
+void arg_type(void *a) { }			/* check-should-fail */
+
+
+void arg_const(int a);
+void arg_const(const int a) { }			/* OK */
+
+
+void arg_as(void *a);
+void arg_as(void __user *a) { }			/* check-should-fail */
+
+
+void arg_mod(void *);
+void arg_mod(void const *a) { }			/* check-should-fail */
+
+
+void arg_more_arg(int a);
+void arg_more_arg(int a, int b) { }		/* check-should-fail */
+
+
+void arg_less_arg(int a, int b);
+void arg_less_arg(int a) { }			/* check-should-fail */
+
+
+void arg_vararg(int a);
+void arg_vararg(int a, ...) { }			/* check-should-fail */
+
+/*
+ * check-name: function-redecl
+ *
+ * check-error-start
+function-redecl.c:5:6: error: symbol 'ret_type' redeclared with different type (originally declared at function-redecl.c:4) - different base types
+function-redecl.c:9:11: error: symbol 'ret_const' redeclared with different type (originally declared at function-redecl.c:8) - different modifiers
+function-redecl.c:13:13: error: symbol 'ret_as' redeclared with different type (originally declared at function-redecl.c:12) - different address spaces
+function-redecl.c:17:12: error: symbol 'ret_mod' redeclared with different type (originally declared at function-redecl.c:16) - different modifiers
+function-redecl.c:21:6: error: symbol 'arg_type' redeclared with different type (originally declared at function-redecl.c:20) - incompatible argument 1 (different base types)
+function-redecl.c:29:6: error: symbol 'arg_as' redeclared with different type (originally declared at function-redecl.c:28) - incompatible argument 1 (different address spaces)
+function-redecl.c:33:6: error: symbol 'arg_mod' redeclared with different type (originally declared at function-redecl.c:32) - incompatible argument 1 (different modifiers)
+function-redecl.c:37:6: error: symbol 'arg_more_arg' redeclared with different type (originally declared at function-redecl.c:36) - different argument counts
+function-redecl.c:41:6: error: symbol 'arg_less_arg' redeclared with different type (originally declared at function-redecl.c:40) - different argument counts
+function-redecl.c:45:6: error: symbol 'arg_vararg' redeclared with different type (originally declared at function-redecl.c:44) - incompatible variadic arguments
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/goto-label.c b/usr/src/tools/smatch/src/validation/goto-label.c
new file mode 100644
index 0000000000..1196fdef9b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/goto-label.c
@@ -0,0 +1,29 @@
+void foo(void)
+{
+	goto a;
+a:
+a:
+	return;
+}
+
+void g(void)
+{
+	goto a;
+a:
+	return;
+}
+
+void bar(void)
+{
+	goto neverland;
+}
+
+/*
+ * check-name: goto labels
+ *
+ * check-error-start
+goto-label.c:5:1: error: label 'a' redefined
+goto-label.c:18:9: error: label 'neverland' was not declared
+ * check-error-end
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/identifier_list.c b/usr/src/tools/smatch/src/validation/identifier_list.c
new file mode 100644
index 0000000000..4691989c2b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/identifier_list.c
@@ -0,0 +1,18 @@
+typedef int T;
+void f(...);
+void g(*);
+void h(x,int);
+void i_OK(T);
+void j(x,T);
+/*
+ * check-name: identifier-list parsing
+ * check-error-start
+identifier_list.c:2:8: warning: variadic functions must have one named argument
+identifier_list.c:3:8: error: Expected ) in function declarator
+identifier_list.c:3:8: error: got *
+identifier_list.c:4:9: error: Expected ) in function declarator
+identifier_list.c:4:9: error: got ,
+identifier_list.c:6:9: error: Expected ) in function declarator
+identifier_list.c:6:9: error: got ,
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/implicit-KR-arg-type0.c b/usr/src/tools/smatch/src/validation/implicit-KR-arg-type0.c
new file mode 100644
index 0000000000..f73d36ffec
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/implicit-KR-arg-type0.c
@@ -0,0 +1,15 @@
+int foo(a, b)
+	int a;
+{
+	if (b)
+		return a;
+}
+
+/*
+ * check-name: implicit-KR-arg-type
+ * check-command: sparse -Wno-decl -Wold-style-definition -Wno-implicit-int $file
+ *
+ * check-error-start
+implicit-KR-arg-type0.c:2:9: warning: non-ANSI definition of function 'foo'
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/implicit-ret-type.c b/usr/src/tools/smatch/src/validation/implicit-ret-type.c
new file mode 100644
index 0000000000..784a285310
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/implicit-ret-type.c
@@ -0,0 +1,15 @@
+fun(void);
+
+foo(void) { return 1; }
+static bar(void) { return 1; }
+
+/*
+ * check-name: implicit-ret-type.c
+ * check-command: sparse -Wno-decl $file
+ *
+ * check-error-start
+implicit-ret-type.c:1:1: warning: 'fun()' has implicit return type
+implicit-ret-type.c:3:1: warning: 'foo()' has implicit return type
+implicit-ret-type.c:4:8: warning: 'bar()' has implicit return type
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/implicit-type.c b/usr/src/tools/smatch/src/validation/implicit-type.c
new file mode 100644
index 0000000000..724bab71ee
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/implicit-type.c
@@ -0,0 +1,14 @@
+extern a;
+static b;
+c;
+
+/*
+ * check-name: implicit-type.c
+ * check-command: sparse -Wno-decl $file
+ *
+ * check-error-start
+implicit-type.c:1:8: warning: 'a' has implicit type
+implicit-type.c:2:8: warning: 'b' has implicit type
+implicit-type.c:3:1: warning: 'c' has implicit type
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/include-eval.c b/usr/src/tools/smatch/src/validation/include-eval.c
new file mode 100644
index 0000000000..1a91dab845
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/include-eval.c
@@ -0,0 +1,6 @@
+/* nothing */
+
+/*
+ * check-name: include-eval.c
+ * check-command: sparse -include ./include-eval.inc $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/include-eval.inc b/usr/src/tools/smatch/src/validation/include-eval.inc
new file mode 100644
index 0000000000..e2561ca41f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/include-eval.inc
@@ -0,0 +1,12 @@
+typedef unsigned long long_t;
+
+inline
+static unsigned int ok(void)
+{
+	return sizeof(long_t);
+}
+
+static unsigned int ko(void)
+{
+	return sizeof(long_t);
+}
diff --git a/usr/src/tools/smatch/src/validation/infinite-loop0.c b/usr/src/tools/smatch/src/validation/infinite-loop0.c
new file mode 100644
index 0000000000..0e3e3805c2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/infinite-loop0.c
@@ -0,0 +1,11 @@
+void foo(void)
+{
+        int a = a || 0;
+        if (a) ;
+}
+
+/*
+ * check-name: internal infinite loop (0)
+ * check-command: sparse -Wno-decl $file
+ * check-timeout:
+ */
diff --git a/usr/src/tools/smatch/src/validation/infinite-loop02.c b/usr/src/tools/smatch/src/validation/infinite-loop02.c
new file mode 100644
index 0000000000..7d0761d87a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/infinite-loop02.c
@@ -0,0 +1,11 @@
+void foo(void)
+{
+	int a = 1;
+	while ((a = !a))
+		;
+}
+
+/*
+ * check-name: infinite loop 02
+ * check-command: sparse -Wno-decl $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/infinite-loop03.c b/usr/src/tools/smatch/src/validation/infinite-loop03.c
new file mode 100644
index 0000000000..ac8a9519d0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/infinite-loop03.c
@@ -0,0 +1,16 @@
+static void foo(int *buf)
+{
+	int a = 1;
+	int *b;
+	do {
+		if (a)
+			b = buf;
+		if (a)
+			*buf = 0;
+	} while (!(a = !a));
+}
+
+/*
+ * check-name: infinite loop 03
+ * check-command: sparse -Wno-decl $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/init-char-array.c b/usr/src/tools/smatch/src/validation/init-char-array.c
new file mode 100644
index 0000000000..5ede9bdcdd
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/init-char-array.c
@@ -0,0 +1,18 @@
+/*
+ * for array of char {<string>} gets special treatment in initializer.
+ */
+static char *s[] = {"aaaaaaaaa"};
+static char t[][10] = {"aaaaaaaaa"};
+static char u[] = {"aaaaaaaaa"};
+static char v[] = "aaaaaaaaa";
+static void f(void)
+{
+	char x[1/(sizeof(s) == sizeof(char *))];
+	char y[1/(sizeof(u) == 10)];
+	char z[1/(sizeof(v) == 10)];
+	char w[1/(sizeof(t) == 10)];
+}
+
+/*
+ * check-name: char array initializers
+ */
diff --git a/usr/src/tools/smatch/src/validation/init-char-array1.c b/usr/src/tools/smatch/src/validation/init-char-array1.c
new file mode 100644
index 0000000000..24fd8d82d7
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/init-char-array1.c
@@ -0,0 +1,27 @@
+/*
+ * for array of char, ("...") as the initializer is an gcc language
+ * extension. check that a parenthesized string initializer is handled
+ * correctly and that -Wparen-string warns about it's use.
+ */
+static const char u[] = ("hello");
+static const char v[] = {"hello"};
+static const char v1[] = {("hello")};
+static const char w[] = "hello";
+static const char x[5] = "hello";
+
+static void f(void)
+{
+	char a[1/(sizeof(u) == 6)];
+	char b[1/(sizeof(v) == 6)];
+	char c[1/(sizeof(w) == 6)];
+	char d[1/(sizeof(x) == 5)];
+}
+/*
+ * check-name: parenthesized string initializer
+ * check-command: sparse -Wparen-string $file
+ *
+ * check-error-start
+init-char-array1.c:6:26: warning: array initialized from parenthesized string constant
+init-char-array1.c:8:28: warning: array initialized from parenthesized string constant
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/init_cstring.c b/usr/src/tools/smatch/src/validation/init_cstring.c
new file mode 100644
index 0000000000..00eca20aa5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/init_cstring.c
@@ -0,0 +1,11 @@
+static struct alpha {
+  char a[2];
+} x = { .a = "ab" };
+/*
+ * check-name: -Winit-cstring option
+ *
+ * check-command: sparse -Winit-cstring $file
+ * check-error-start
+init_cstring.c:3:14: warning: too long initializer-string for array of char(no space for nul char)
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/initializer-entry-defined-twice.c b/usr/src/tools/smatch/src/validation/initializer-entry-defined-twice.c
new file mode 100644
index 0000000000..8a5bd3a956
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/initializer-entry-defined-twice.c
@@ -0,0 +1,63 @@
+/* Tests for the "Initializer entry defined twice" warning. */
+
+/* Initializing a struct field twice should trigger the warning. */
+struct normal {
+	int field1;
+	int field2;
+};
+
+static struct normal struct_error = {
+	.field1 = 0,
+	.field1 = 0
+};
+
+/* Initializing two different fields of a union should trigger the warning. */
+struct has_union {
+	int x;
+	union {
+		int a;
+		int b;
+	} y;
+	int z;
+};
+
+static struct has_union union_error = {
+	.y = {
+		.a = 0,
+		.b = 0
+	}
+};
+
+/* Empty structures can make two fields have the same offset in a struct.
+ * Initializing both should not trigger the warning. */
+struct empty { };
+
+struct same_offset {
+	struct empty field1;
+	int field2;
+};
+
+static struct same_offset not_an_error = {
+	.field1 = { },
+	.field2 = 0
+};
+
+/*
+ * _Bools generally take a whole byte, so ensure that we can initialize
+ * them without spewing a warning.
+ */
+static _Bool boolarray[3] = {
+	[0] = 1,
+	[1] = 1,
+};
+
+/*
+ * check-name: Initializer entry defined twice
+ *
+ * check-error-start
+initializer-entry-defined-twice.c:10:10: warning: Initializer entry defined twice
+initializer-entry-defined-twice.c:11:10:   also defined here
+initializer-entry-defined-twice.c:26:18: warning: Initializer entry defined twice
+initializer-entry-defined-twice.c:27:18:   also defined here
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/inline_compound_literals.c b/usr/src/tools/smatch/src/validation/inline_compound_literals.c
new file mode 100644
index 0000000000..fc223ff53c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/inline_compound_literals.c
@@ -0,0 +1,22 @@
+struct foo {
+	int x;
+};
+
+static inline void baz(void)
+{
+	(struct foo) { .x = 0 };
+}
+
+static void barf(void)
+{
+	baz();
+}
+
+static void foo(void)
+{
+	baz();
+}
+
+/*
+ * check-name: inline compound literals
+ */
diff --git a/usr/src/tools/smatch/src/validation/int128.c b/usr/src/tools/smatch/src/validation/int128.c
new file mode 100644
index 0000000000..53d678e2ca
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/int128.c
@@ -0,0 +1,58 @@
+typedef		 __int128	 int128_t;
+typedef   signed __int128	sint128_t;
+typedef unsigned __int128	uint128_t;
+
+typedef	__int128 int	badxi;
+typedef int __int128	badix;
+typedef unsigned unsigned __int128 baduu;
+typedef double __int128 baddx;
+typedef __int128 double badxd;
+
+int sizeof_int128(void)
+{
+	return sizeof(__int128);
+}
+
+typedef unsigned long long u64;
+typedef unsigned long      u32;
+
+u64 foo(u64 a, u64 b, u64 c, u32 s)
+{
+       unsigned __int128 tmp;
+
+       tmp = (((uint128_t)a) * b) + c;
+       return (u64) (tmp >> s);
+}
+
+/*
+ * check-name: int128
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-contains: ret\\..*\\$16
+ * check-output-contains: mulu\\.128
+ * check-output-contains: add\\.128
+ *
+ * check-error-start
+int128.c:5:18: error: two or more data types in declaration specifiers
+int128.c:5:18: error: Trying to use reserved word 'int' as identifier
+int128.c:5:25: error: Expected ; at end of declaration
+int128.c:5:25: error: got badxi
+int128.c:6:13: error: two or more data types in declaration specifiers
+int128.c:6:13: error: Trying to use reserved word '__int128' as identifier
+int128.c:6:25: error: Expected ; at end of declaration
+int128.c:6:25: error: got badix
+int128.c:7:18: error: impossible combination of type specifiers: unsigned unsigned
+int128.c:7:18: error: Trying to use reserved word 'unsigned' as identifier
+int128.c:7:27: error: Expected ; at end of declaration
+int128.c:7:27: error: got __int128
+int128.c:8:16: error: two or more data types in declaration specifiers
+int128.c:8:16: error: Trying to use reserved word '__int128' as identifier
+int128.c:8:25: error: Expected ; at end of declaration
+int128.c:8:25: error: got baddx
+int128.c:9:18: error: two or more data types in declaration specifiers
+int128.c:9:18: error: Trying to use reserved word 'double' as identifier
+int128.c:9:25: error: Expected ; at end of declaration
+int128.c:9:25: error: got badxd
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/integer-promotions.c b/usr/src/tools/smatch/src/validation/integer-promotions.c
new file mode 100644
index 0000000000..4245fe235e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/integer-promotions.c
@@ -0,0 +1,7 @@
+static int add_char(void)
+{
+	return (char) 127 + (char) 127 + (char) 2;
+}
+/*
+ * check-name: Integer promotions
+ */
diff --git a/usr/src/tools/smatch/src/validation/ioc-typecheck.c b/usr/src/tools/smatch/src/validation/ioc-typecheck.c
new file mode 100644
index 0000000000..34b37d3105
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/ioc-typecheck.c
@@ -0,0 +1,11 @@
+extern unsigned int __invalid_size_argument_for_IOC;
+static unsigned iocnrs[] = {
+	[ 1 ?  0 : __invalid_size_argument_for_IOC ] = 1,
+};
+/*
+ * check-name: integer constant & conditional expression
+ * check-known-to-fail
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-casts.c b/usr/src/tools/smatch/src/validation/kill-casts.c
new file mode 100644
index 0000000000..cf52f2460e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-casts.c
@@ -0,0 +1,22 @@
+extern void __abort(void);
+
+struct s {
+	int elem:3;
+};
+
+void foo(struct s *x);
+void foo(struct s *x)
+{
+	if (x->elem == 0) {
+		if (x->elem != 0 && x->elem != 1)
+			__abort();
+	}
+}
+
+/*
+ * check-name: kill-casts
+ * check-command: test-linearize $file
+ *
+ * check-output-ignore
+ * check-output-excludes: cast\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-computedgoto.c b/usr/src/tools/smatch/src/validation/kill-computedgoto.c
new file mode 100644
index 0000000000..3b3ed8ff26
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-computedgoto.c
@@ -0,0 +1,17 @@
+void foo(int a);
+void foo(int a)
+{
+	void *l = &&end + 3;
+
+end:
+	if (a * 0)
+		goto *l;
+}
+
+/*
+ * check-name: kill-computedgoto
+ * check-command: test-linearize $file
+ *
+ * check-output-ignore
+ * check-output-excludes: add\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-cse.c b/usr/src/tools/smatch/src/validation/kill-cse.c
new file mode 100644
index 0000000000..2e2b102462
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-cse.c
@@ -0,0 +1,21 @@
+int foo(int a)
+{
+	return ((a == 0) + 1) != ((a == 0) + 1);
+}
+
+/*
+ * check-name: kill-cse
+ * check-description:
+ *	Verify that instructions removed at CSE are
+ *	properly adjust the usage of their operands.
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-start
+foo:
+.L0:
+	<entry-point>
+	ret.32      $0
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-insert-branch.c b/usr/src/tools/smatch/src/validation/kill-insert-branch.c
new file mode 100644
index 0000000000..e59b5bbcda
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-insert-branch.c
@@ -0,0 +1,22 @@
+void foo(int a)
+{
+	int b = 1;
+	if (a)
+		b++;
+	if (b)
+		;
+}
+
+void bar(int a)
+{
+	if (a ? 1 : 2)
+		;
+}
+
+/*
+ * check-name: kill insert-branch
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-ignore
+ * check-output-excludes: select\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-load.c b/usr/src/tools/smatch/src/validation/kill-load.c
new file mode 100644
index 0000000000..45fb83e4ba
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-load.c
@@ -0,0 +1,17 @@
+int keep(volatile int *p)	{ return *p && 0; }
+int kill(int *p, int i)		{ return *p && 0; }
+void ind(volatile int *p,int i)	{ int v = i++; if (i && 0) p[v]; }
+
+
+/*
+ * check-name: kill-load
+ * check-command: test-linearize -Wno-decl $file
+ * check-description:
+ *	Check that loads are optimized away but only
+ *	when needed:
+ *	- non-volatile
+ *	- bb unreachable.
+ *
+ * check-output-ignore
+ * check-output-pattern-1-times: load\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-phi-node.c b/usr/src/tools/smatch/src/validation/kill-phi-node.c
new file mode 100644
index 0000000000..cff62b6493
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-phi-node.c
@@ -0,0 +1,27 @@
+void foo(int a, int *b, unsigned int g);
+void foo(int a, int *b, unsigned int g)
+{
+	int d = 0;
+
+	if ((!a || *b) && g)
+		d = 16;
+	else
+		d = 8;
+}
+
+int bar(void);
+int bar(void)
+{
+	int i;
+	for (i = 0; i; i--)
+		;
+	return 0;
+}
+
+/*
+ * check-name: kill-phi-node
+ * check-command: test-linearize $file
+ *
+ * check-output-ignore
+ * check-output-excludes: phisrc\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-phi-ttsbb.c b/usr/src/tools/smatch/src/validation/kill-phi-ttsbb.c
new file mode 100644
index 0000000000..178a65d197
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-phi-ttsbb.c
@@ -0,0 +1,28 @@
+int def(void);
+void use(int);
+
+static int foo(int a, int b)
+{
+	int c;
+
+	if (a)
+		c = 1;
+	else
+		c = def();
+
+	if (c)
+		use(1);
+	else
+		use(0);
+}
+
+/*
+ * check-name: kill-phi-ttsbb
+ * check-description:
+ *	Verify if OP_PHI usage is adjusted after successful try_to_simplify_bb()
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: phi\\.
+ * check-output-excludes: phisrc\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-phi-ttsbb2.c b/usr/src/tools/smatch/src/validation/kill-phi-ttsbb2.c
new file mode 100644
index 0000000000..c7d89aa0e8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-phi-ttsbb2.c
@@ -0,0 +1,40 @@
+extern int error(int);
+
+int foo(int perr);
+int foo(int perr)
+{
+	int err = 0;
+	int rc = 0;
+	int j = 0;
+	int i = 1;
+
+	i && j++;
+
+	i-- && j;
+
+	i && j--;
+
+	if (j != 1) {
+		err = 1;
+		if (perr)
+			error(1);
+	}
+
+	if (err != 0)
+		rc = 1;
+
+	return rc;
+}
+
+/*
+ * check-name: kill-phi-ttsbb2
+ * check-description:
+ *	Verify if OP_PHI usage is adjusted after successful try_to_simplify_bb()
+ * check-warning: this test is sensitive to details of code generation
+ *                with proper bb packing (taking care of phi-nodes) it
+ *		  will be optimized away and test nothing. You have been warned.
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: VOID
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-phisrc.c b/usr/src/tools/smatch/src/validation/kill-phisrc.c
new file mode 100644
index 0000000000..f00dbed243
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-phisrc.c
@@ -0,0 +1,21 @@
+int foo(int a, int b)
+{
+	int r = a + b;
+
+	if (a && 0) {
+		int s = r;
+		if (b)
+			s = 0;
+		(void) s;
+	}
+
+	return 0;
+}
+
+/*
+ * check-name: kill-phisrc
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-ignore
+ * check-output-excludes: add\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-pure-call.c b/usr/src/tools/smatch/src/validation/kill-pure-call.c
new file mode 100644
index 0000000000..d3f78c026d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-pure-call.c
@@ -0,0 +1,17 @@
+int side(int a);
+int pure(int a) __attribute__((pure));
+
+int keep(int a) { return side(a) && 0; }
+int kill(int a) { return pure(a) && 0; }
+
+/*
+ * check-name: kill-pure-call
+ * check-command: test-linearize -Wno-decl $file
+ * check-description:
+ *	See that the call is optimized away but only
+ *	when the function is "pure".
+ *
+ * check-output-ignore
+ * check-output-contains: call\\..* side
+ * check-output-excludes: call\\..* pure
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-replaced-insn.c b/usr/src/tools/smatch/src/validation/kill-replaced-insn.c
new file mode 100644
index 0000000000..920218778b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-replaced-insn.c
@@ -0,0 +1,61 @@
+// See if the replaced operation is effectively killed or not
+
+static int kill_add(int a, int b)
+{
+	return (a + b) && 0;
+}
+
+static int kill_scast(short a)
+{
+	return ((int) a) && 0;
+}
+
+static int kill_ucast(unsigned char a)
+{
+	return ((int) a) && 0;
+}
+
+static int kill_pcast(int *a)
+{
+	return ((void*) a) && 0;
+}
+
+static int kill_fcast(double a)
+{
+	return ((int) a) && 0;
+}
+
+static int kill_select(int a)
+{
+	return (a ? 1 : 0) && 0;
+}
+
+static int kill_setval(int a)
+{
+l:
+	return &&l && 0;
+}
+
+static int kill_load(int *a)
+{
+	return *a && 0;
+}
+
+static int kill_store(int *a)
+{
+	return (*a = 1) && 0;
+}
+
+/*
+ * check-name: kill-replaced-insn
+ * check-command: test-linearize $file
+ *
+ * check-output-ignore
+ * check-output-excludes: add\\.
+ * check-output-excludes: scast\\.
+ * check-output-excludes: \\<cast\\.
+ * check-output-excludes: ptrcast\\.
+ * check-output-excludes: fpcast\\.
+ * check-output-excludes: sel\\.
+ * check-output-excludes: set\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-rewritten-load.c b/usr/src/tools/smatch/src/validation/kill-rewritten-load.c
new file mode 100644
index 0000000000..31b895e53a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-rewritten-load.c
@@ -0,0 +1,16 @@
+int foo(int i)
+{
+	i++;
+	if (i && 0)
+		i;
+	return 0;
+}
+
+
+/*
+ * check-name: kill-rewritten-load
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-excludes: add\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-select.c b/usr/src/tools/smatch/src/validation/kill-select.c
new file mode 100644
index 0000000000..445472be8d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-select.c
@@ -0,0 +1,16 @@
+void foo(int x);
+void foo(int x)
+{
+	unsigned int ui;
+
+	ui = x + 1;
+	ui = ui ? 0 : 1;
+}
+
+/*
+ * check-name: kill-select
+ * check-command: test-linearize $file
+ *
+ * check-output-ignore
+ * check-output-excludes: add\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-slice.c b/usr/src/tools/smatch/src/validation/kill-slice.c
new file mode 100644
index 0000000000..00db0e0f75
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-slice.c
@@ -0,0 +1,19 @@
+struct bar {
+	int x;
+	int y[2];
+};
+struct bar bar(void);
+
+int foo(void)
+{
+	int x = bar().x;
+	return x & 0;
+}
+
+/*
+ * check-name: kill-slice
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-excludes: slice\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-store.c b/usr/src/tools/smatch/src/validation/kill-store.c
new file mode 100644
index 0000000000..8f72532266
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-store.c
@@ -0,0 +1,16 @@
+void keep(int *p)	 { *p = 0; }
+void kill(int *p, int i) { if (i && 0) *p = 0; }
+void dead(int *p, int i) { int v = i++; if (i && 0) p[v] = 0; }
+
+
+/*
+ * check-name: kill-store
+ * check-command: test-linearize -Wno-decl $file
+ * check-description:
+ *	Check that stores are optimized away but only
+ *	when needed:
+ *	- bb unreachable.
+ *
+ * check-output-ignore
+ * check-output-pattern-1-times: store\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/kill-unreachable-phi.c b/usr/src/tools/smatch/src/validation/kill-unreachable-phi.c
new file mode 100644
index 0000000000..4c7e249028
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/kill-unreachable-phi.c
@@ -0,0 +1,27 @@
+extern char *strcpy (char *__dest, const char *__src);
+
+static void test_menu_iteminfo( void )
+{
+		int ansi = 1;
+		void *init, *string;
+		char initA[]="XYZ";
+		char stringA[0x80];
+		do {
+			if(ansi) {
+				string=stringA;
+				init = initA;
+			}
+			if(ansi)
+				strcpy( string, init );
+		} while( !(ansi = !ansi) );
+}
+/*
+ * check-name: kill-unreachable-phi
+ * check-description:
+ * 	In wine source tests/menu.c
+ * 	Improper killing a phi instruction inside not reachable BB cause
+ * 	dead loop on sparse.
+ *
+ * check-output-ignore
+ *
+ */
diff --git a/usr/src/tools/smatch/src/validation/label-asm.c b/usr/src/tools/smatch/src/validation/label-asm.c
new file mode 100644
index 0000000000..411020ac36
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/label-asm.c
@@ -0,0 +1,12 @@
+#define barrier() __asm__ __volatile__("": : :"memory")
+
+static void f(void)
+{
+	barrier();
+l:
+	barrier();
+}
+/*
+ * check-name: Label followed by __asm__
+ * check-description: Sparse used to parse the __asm__ as modifying the label.
+ */
diff --git a/usr/src/tools/smatch/src/validation/label-attr.c b/usr/src/tools/smatch/src/validation/label-attr.c
new file mode 100644
index 0000000000..a82d7bc98b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/label-attr.c
@@ -0,0 +1,9 @@
+static int foo(void)
+{
+       return 0;
+rtattr_failure: __attribute__ ((unused))
+       return -1;
+}
+/*
+ * check-name: Label attribute
+ */
diff --git a/usr/src/tools/smatch/src/validation/label-expr.c b/usr/src/tools/smatch/src/validation/label-expr.c
new file mode 100644
index 0000000000..e578ed0042
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/label-expr.c
@@ -0,0 +1,17 @@
+int foo(void);
+int foo(void)
+{
+	int r;
+
+	r = ({ label: 1; });
+	return r;
+}
+
+/*
+ * check-name: label-expr
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: ret\\.32\$
+ * check-output-contains: ret\\.32 *\\$1
+ */
diff --git a/usr/src/tools/smatch/src/validation/label-scope.c b/usr/src/tools/smatch/src/validation/label-scope.c
new file mode 100644
index 0000000000..7af3d916c3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/label-scope.c
@@ -0,0 +1,12 @@
+static int f(int n)
+{
+	__label__ n;
+n:	return n;
+}
+static int g(int n)
+{
+n:	return n;
+}
+/*
+ * check-name: __label__ scope
+ */
diff --git a/usr/src/tools/smatch/src/validation/linear/bitfield-init-mask.c b/usr/src/tools/smatch/src/validation/linear/bitfield-init-mask.c
new file mode 100644
index 0000000000..94afa400c8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/linear/bitfield-init-mask.c
@@ -0,0 +1,27 @@
+struct bfu {
+	unsigned int a:11;
+	unsigned int f:9;
+	unsigned int z:3;
+};
+
+struct bfu bfu_init_00_11(int a)
+{
+	struct bfu bfu = { .a = a, };
+	return bfu;
+}
+
+struct bfu bfu_init_20_23(int a)
+{
+	struct bfu bfu = { .z = a, };
+	return bfu;
+}
+
+/*
+ * check-name: bitfield initializer mask
+ * check-command: test-linearize -fdump-linearize=only -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-contains: and\\..*fffff800\$
+ * check-output-contains: shl\\..* \\$20
+ * check-output-contains: and\\..*ff8fffff\$
+ */
diff --git a/usr/src/tools/smatch/src/validation/linear/bitfield-init-zero.c b/usr/src/tools/smatch/src/validation/linear/bitfield-init-zero.c
new file mode 100644
index 0000000000..39a64345ed
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/linear/bitfield-init-zero.c
@@ -0,0 +1,102 @@
+struct bfu {
+	unsigned int a:11;
+	unsigned int f:9;
+	unsigned int  :2;
+	unsigned int z:3;
+};
+
+struct bfu bfuu_init(unsigned int a)
+{
+	struct bfu bf = { .f = a, };
+	return bf;
+}
+
+struct bfu bfus_init(int a)
+{
+	struct bfu bf = { .f = a, };
+	return bf;
+}
+
+unsigned int bfu_get0(void)
+{
+	struct bfu bf = { };
+	return bf.f;
+}
+
+
+struct bfs {
+	signed int a:11;
+	signed int f:9;
+	signed int  :2;
+	signed int z:3;
+};
+
+struct bfs bfsu_init(unsigned int a)
+{
+	struct bfs bf = { .f = a, };
+	return bf;
+}
+
+struct bfs bfss_init(int a)
+{
+	struct bfs bf = { .f = a, };
+	return bf;
+}
+
+int bfs_get0(void)
+{
+	struct bfs bf = { };
+	return bf.f;
+}
+
+/*
+ * check-name: bitfield implicit init zero
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-start
+bfuu_init:
+.L0:
+	<entry-point>
+	cast.9      %r2 <- (32) %arg1
+	shl.32      %r4 <- %r2, $11
+	ret.32      %r4
+
+
+bfus_init:
+.L2:
+	<entry-point>
+	scast.9     %r10 <- (32) %arg1
+	shl.32      %r12 <- %r10, $11
+	ret.32      %r12
+
+
+bfu_get0:
+.L4:
+	<entry-point>
+	ret.32      $0
+
+
+bfsu_init:
+.L6:
+	<entry-point>
+	cast.9      %r23 <- (32) %arg1
+	shl.32      %r25 <- %r23, $11
+	ret.32      %r25
+
+
+bfss_init:
+.L8:
+	<entry-point>
+	scast.9     %r31 <- (32) %arg1
+	shl.32      %r33 <- %r31, $11
+	ret.32      %r33
+
+
+bfs_get0:
+.L10:
+	<entry-point>
+	ret.32      $0
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/linear/missing-insn-size.c b/usr/src/tools/smatch/src/validation/linear/missing-insn-size.c
new file mode 100644
index 0000000000..fe588634cd
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/linear/missing-insn-size.c
@@ -0,0 +1,19 @@
+int foo(int **a);
+int foo(int **a)
+{
+	return **a;
+}
+
+/*
+ * check-name: missing instruction's size
+ * check-description:
+ *	sparse used to have a problem with *all*
+ *	double dereferencing due to missing a
+ *	call to examine_symbol_type(). The symptom
+ *	here is that the inner deref had no type.
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: load\\s
+ * check-output-contains: load\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/linear/struct-init-full.c b/usr/src/tools/smatch/src/validation/linear/struct-init-full.c
new file mode 100644
index 0000000000..f1b03db71e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/linear/struct-init-full.c
@@ -0,0 +1,28 @@
+struct s {
+	int a, b, c;
+};
+
+struct s s_init_all(int a)
+{
+	struct s s = { .a = a, .b = 42, .c = 123, };
+	return s;
+}
+
+/*
+ * check-name: struct implicit init zero not needed
+ * check-command: test-linearize -Wno-decl $file
+ * check-known-to-fail
+ *
+ * check-output-start
+s_init_all:
+.L4:
+	<entry-point>
+	store.32    %arg1 -> 0[s]
+	store.32    $42 -> 4[s]
+	store.32    $123 -> 8[s]
+	load.96     %r8 <- 0[s]
+	ret.96      %r8
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/linear/struct-init-partial.c b/usr/src/tools/smatch/src/validation/linear/struct-init-partial.c
new file mode 100644
index 0000000000..1f5078bfad
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/linear/struct-init-partial.c
@@ -0,0 +1,41 @@
+struct s {
+	int a, b, c;
+};
+
+struct s s_init_first(int a)
+{
+	struct s s = { .a = a, };
+	return s;
+}
+
+struct s s_init_third(int a)
+{
+	struct s s = { .c = a, };
+	return s;
+}
+
+/*
+ * check-name: struct implicit init zero needed
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-start
+s_init_first:
+.L0:
+	<entry-point>
+	store.96    $0 -> 0[s]
+	store.32    %arg1 -> 0[s]
+	load.96     %r2 <- 0[s]
+	ret.96      %r2
+
+
+s_init_third:
+.L2:
+	<entry-point>
+	store.96    $0 -> 0[s]
+	store.32    %arg1 -> 8[s]
+	load.96     %r5 <- 0[s]
+	ret.96      %r5
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/local-label.c b/usr/src/tools/smatch/src/validation/local-label.c
new file mode 100644
index 0000000000..951b085618
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/local-label.c
@@ -0,0 +1,11 @@
+void f(unsigned long ip);
+static void g(void)
+{
+       if (1) {
+	     f(({ __label__ x; x: (unsigned long)&&x; }));
+       }
+       f(({ __label__ x; x: (unsigned long)&&x; }));
+}
+/*
+ * check-name: Local label
+ */
diff --git a/usr/src/tools/smatch/src/validation/logical.c b/usr/src/tools/smatch/src/validation/logical.c
new file mode 100644
index 0000000000..3f97522712
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/logical.c
@@ -0,0 +1,17 @@
+extern int a(void);
+extern int b(void);
+extern int c(void);
+
+static int or(void)
+{
+	return a() || b() || c();
+}
+
+static int and(void)
+{
+	return a() && b() && c();
+}
+/*
+ * check-name: Logical and/or
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/loop-linearization.c b/usr/src/tools/smatch/src/validation/loop-linearization.c
new file mode 100644
index 0000000000..25c6dfb870
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/loop-linearization.c
@@ -0,0 +1,136 @@
+extern int p(int);
+
+static int ffor(void)
+{
+	int i;
+	for (int i = 0; i < 10; i++) {
+		if (!p(i))
+			return 0;
+	}
+	return 1;
+}
+
+static int fwhile(void)
+{
+	int i = 0;
+	while (i < 10) {
+		if (!p(i))
+			return 0;
+		i++;
+	}
+	return 1;
+}
+
+static int fdo(void)
+{
+	int i = 0;
+	do {
+		if (!p(i))
+			return 0;
+	} while (i++ < 10);
+	return 1;
+}
+
+/*
+ * check-name: loop-linearization
+ * check-command: test-linearize $file
+ *
+ * check-output-start
+ffor:
+.L0:
+	<entry-point>
+	phisrc.32   %phi5(i) <- $0
+	br          .L4
+
+.L4:
+	phi.32      %r1(i) <- %phi5(i), %phi6(i)
+	setlt.32    %r2 <- %r1(i), $10
+	cbr         %r2, .L1, .L3
+
+.L1:
+	call.32     %r4 <- p, %r1(i)
+	cbr         %r4, .L2, .L5
+
+.L5:
+	phisrc.32   %phi1(return) <- $0
+	br          .L7
+
+.L2:
+	add.32      %r7 <- %r1(i), $1
+	phisrc.32   %phi6(i) <- %r7
+	br          .L4
+
+.L3:
+	phisrc.32   %phi2(return) <- $1
+	br          .L7
+
+.L7:
+	phi.32      %r5 <- %phi1(return), %phi2(return)
+	ret.32      %r5
+
+
+fwhile:
+.L8:
+	<entry-point>
+	phisrc.32   %phi11(i) <- $0
+	br          .L12
+
+.L12:
+	phi.32      %r8(i) <- %phi11(i), %phi12(i)
+	setlt.32    %r9 <- %r8(i), $10
+	cbr         %r9, .L9, .L11
+
+.L9:
+	call.32     %r11 <- p, %r8(i)
+	cbr         %r11, .L14, .L13
+
+.L13:
+	phisrc.32   %phi7(return) <- $0
+	br          .L15
+
+.L14:
+	add.32      %r14 <- %r8(i), $1
+	phisrc.32   %phi12(i) <- %r14
+	br          .L12
+
+.L11:
+	phisrc.32   %phi8(return) <- $1
+	br          .L15
+
+.L15:
+	phi.32      %r12 <- %phi7(return), %phi8(return)
+	ret.32      %r12
+
+
+fdo:
+.L16:
+	<entry-point>
+	phisrc.32   %phi16(i) <- $0
+	br          .L17
+
+.L17:
+	phi.32      %r15(i) <- %phi16(i), %phi17(i)
+	call.32     %r16 <- p, %r15(i)
+	cbr         %r16, .L18, .L20
+
+.L20:
+	phisrc.32   %phi13(return) <- $0
+	br          .L22
+
+.L18:
+	add.32      %r19 <- %r15(i), $1
+	setlt.32    %r20 <- %r15(i), $10
+	phisrc.32   %phi17(i) <- %r19
+	cbr         %r20, .L17, .L19
+
+.L19:
+	phisrc.32   %phi14(return) <- $1
+	br          .L22
+
+.L22:
+	phi.32      %r17 <- %phi13(return), %phi14(return)
+	ret.32      %r17
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/member_of_typeof.c b/usr/src/tools/smatch/src/validation/member_of_typeof.c
new file mode 100644
index 0000000000..db863b084b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/member_of_typeof.c
@@ -0,0 +1,10 @@
+static struct foo {int x;} v;
+static typeof(v) *p;
+static void bar(void)
+{
+	p->x = 0;
+}
+/*
+ * check-name: Expansion of typeof when dealing with member of struct
+ * check-description: Used to expand SYM_TYPEOF too late
+ */
diff --git a/usr/src/tools/smatch/src/validation/memops-volatile.c b/usr/src/tools/smatch/src/validation/memops-volatile.c
new file mode 100644
index 0000000000..0f3e12ad24
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/memops-volatile.c
@@ -0,0 +1,21 @@
+static int foo(volatile int *a, int v)
+{
+	*a = v;
+	return *a;
+}
+
+/*
+ * check-name: memops-volatile
+ * check-command: test-linearize $file
+ *
+ * check-output-start
+foo:
+.L0:
+	<entry-point>
+	store.32    %arg2 -> 0[%arg1]
+	load.32     %r5 <- 0[%arg1]
+	ret.32      %r5
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/missing-ident.c b/usr/src/tools/smatch/src/validation/missing-ident.c
new file mode 100644
index 0000000000..ce73983dee
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/missing-ident.c
@@ -0,0 +1,18 @@
+int [2];
+int *;
+int (*);
+int ();
+int;
+struct foo;
+union bar {int x; int y;};
+struct baz {int x, :3, y:2;};
+/*
+ * check-name: handling of identifier-less declarations
+ *
+ * check-error-start
+missing-ident.c:1:8: warning: missing identifier in declaration
+missing-ident.c:2:6: warning: missing identifier in declaration
+missing-ident.c:3:8: warning: missing identifier in declaration
+missing-ident.c:4:7: warning: missing identifier in declaration
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/multi_typedef.c b/usr/src/tools/smatch/src/validation/multi_typedef.c
new file mode 100644
index 0000000000..d9ffd0f717
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/multi_typedef.c
@@ -0,0 +1,15 @@
+typedef int T, *P;
+static void f(void)
+{
+	unsigned P = 0;
+	unsigned x = P;
+}
+static void g(void)
+{
+	int P = 0;
+	int x = P;
+}
+/*
+ * check-name: typedefs with many declarators
+ * check-description: we didn't recognize P above as a typedef
+ */
diff --git a/usr/src/tools/smatch/src/validation/nested-declarator.c b/usr/src/tools/smatch/src/validation/nested-declarator.c
new file mode 100644
index 0000000000..1efe20ce45
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/nested-declarator.c
@@ -0,0 +1,29 @@
+typedef int T;
+extern void f(int);
+static void g(int x)
+{
+	int (T);
+	T = x;
+	f(T);
+}
+static void h(void)
+{
+	static int [2](T)[3];
+}
+static int [2](*p)[3];
+int i(void (void)(*f));
+int j(int [2](*));
+/*
+ * check-name: nested declarator vs. parameters
+ * check-error-start:
+nested-declarator.c:11:23: warning: missing identifier in declaration
+nested-declarator.c:11:23: error: Expected ; at the end of type declaration
+nested-declarator.c:11:23: error: got (
+nested-declarator.c:13:15: error: Expected ; at the end of type declaration
+nested-declarator.c:13:15: error: got (
+nested-declarator.c:14:18: error: Expected ) in function declarator
+nested-declarator.c:14:18: error: got (
+nested-declarator.c:15:14: error: Expected ) in function declarator
+nested-declarator.c:15:14: error: got (
+ * check-error-end:
+ */
diff --git a/usr/src/tools/smatch/src/validation/nested-declarator2.c b/usr/src/tools/smatch/src/validation/nested-declarator2.c
new file mode 100644
index 0000000000..345a04b069
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/nested-declarator2.c
@@ -0,0 +1,41 @@
+typedef int T;
+extern void f1(int);
+extern void f2(T);
+static void (*f3)(int) = f2;
+static void (*f4)(T) = f1;
+extern void f5(void (int));
+extern void f6(void (T));
+static void z(int x)
+{
+	int (T) = x;
+	f5(f2);
+	f6(f3);
+}
+static void f8();
+static int (x) = 1;
+static void w1(y)
+int y;
+{
+	x = y;
+}
+static void w2(int ());
+static void w3(...);
+static void f9(__attribute__((mode(DI))) T);
+static void w4(int f(x,y));
+static void bad1(__attribute__((mode(DI))) x);
+static int (-bad2);
+static void [2](*bad3);
+/*
+ * check-name: more on handling of ( in direct-declarator
+ * check-error-start:
+nested-declarator2.c:17:1: warning: non-ANSI definition of function 'w1'
+nested-declarator2.c:21:21: warning: non-ANSI function declaration of function '<noident>'
+nested-declarator2.c:22:16: warning: variadic functions must have one named argument
+nested-declarator2.c:24:21: warning: identifier list not in definition
+nested-declarator2.c:25:45: error: don't know how to apply mode to incomplete type
+nested-declarator2.c:26:13: error: Expected ) in nested declarator
+nested-declarator2.c:26:13: error: got -
+nested-declarator2.c:27:16: error: Expected ; at the end of type declaration
+nested-declarator2.c:27:16: error: got (
+ * check-error-end:
+ */
diff --git a/usr/src/tools/smatch/src/validation/nocast.c b/usr/src/tools/smatch/src/validation/nocast.c
new file mode 100644
index 0000000000..cc0ab6b7c0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/nocast.c
@@ -0,0 +1,197 @@
+#define	__nocast	__attribute__((nocast))
+typedef unsigned long __nocast ulong_nc_t;
+
+extern void use_val(ulong_nc_t);
+extern void use_ptr(ulong_nc_t *);
+
+/* use address */
+static void good_use_address(void)
+{
+	ulong_nc_t t;
+
+	use_ptr(&t);
+}
+
+static ulong_nc_t *good_ret_address(void)
+{
+	static ulong_nc_t t;
+
+	return &t;
+}
+
+static ulong_nc_t good_deref(ulong_nc_t *t)
+{
+	return *t;
+}
+
+/* assign value */
+static ulong_nc_t t;
+static ulong_nc_t good_assign_self = t;
+static unsigned long good_assign_sametype = t;
+
+/* assign pointer */
+static ulong_nc_t *good_ptr = &t;
+static ulong_nc_t *bad_ptr_to = 1UL;
+static unsigned long *bad_ptr_from = &t;
+
+/* arithmetic operation */
+static ulong_nc_t good_arith(ulong_nc_t t, unsigned int n)
+{
+	return t + n;
+}
+
+/* implicit cast to other types */
+static unsigned long good_ret_samecast(ulong_nc_t t)
+{
+	return t;
+}
+static unsigned long long bad_ret_biggercast(ulong_nc_t t)
+{
+	return t;
+}
+static long bad_ret_signcast(ulong_nc_t t)
+{
+	return t;
+}
+static short bad_ret_smallercast(ulong_nc_t t)
+{
+	return t;
+}
+
+static void assign_val(ulong_nc_t t)
+{
+	ulong_nc_t good_c = t;
+	unsigned long good_ul = t;
+	unsigned long long bad_ull = t;
+	long bad_l = t;
+	short bad_i = t;
+}
+
+static void assign_via_ptr(ulong_nc_t *t)
+{
+	ulong_nc_t good_c = *t;
+	unsigned long good_ul = *t;
+	unsigned long long bad_ull = *t;
+	long bad_l = *t;
+	short bad_i = *t;
+}
+
+static void assign_ptr(ulong_nc_t *t)
+{
+	ulong_nc_t *good_same_type = t;
+	unsigned long *bad_mod = t;
+	unsigned long long __nocast *bad_size = t;
+	short __nocast *bad_i = t;
+	long __nocast *bad_l = t;
+}
+
+/* implicit cast to nocast */
+static void implicit_assign_to(void)
+{
+	ulong_nc_t t;
+	unsigned long ul = 1;
+	unsigned short us = 1;
+	unsigned long long ull = 1;
+	long l = 1;
+
+	t = ul;		/* implicit to nocast from same type: OK? */
+	t = us;
+	t = ull;
+	t = l;
+}
+
+static void bad_implicit_arg_to(void)
+{
+	unsigned long ul = 1;
+	unsigned short us = 1;
+	unsigned long long ull = 1;
+	long l = 1;
+
+	use_val(ul);	/* implicit to nocast from same type: OK? */
+	use_val(us);
+	use_val(ull);
+	use_val(l);
+}
+
+/* implicit cast from nocast */
+static unsigned long good_implicit_ret_ul(ulong_nc_t t)
+{
+	return t;	/* implicit to nocast from same type: OK? */
+}
+
+static unsigned short bad_implicit_ret_us(ulong_nc_t t)
+{
+	return t;
+}
+
+static unsigned long long bad_implicit_ret_ull(ulong_nc_t t)
+{
+	return t;
+}
+
+static long bad_implicit_ret_l(ulong_nc_t t)
+{
+	return t;
+}
+
+/* FIXME: explicit cast: should we complain? */
+static ulong_nc_t good_samecast(ulong_nc_t v)
+{
+	return (ulong_nc_t) v;
+}
+
+static ulong_nc_t bad_tocast(unsigned long v)
+{
+	return (ulong_nc_t) v;
+}
+
+static unsigned long bad_fromcast(ulong_nc_t v)
+{
+	return (unsigned long) v;
+}
+
+/*
+ * check-name: nocast.c
+ *
+ * check-error-start
+nocast.c:34:33: warning: incorrect type in initializer (different base types)
+nocast.c:34:33:    expected unsigned long [nocast] [usertype] *static [toplevel] bad_ptr_to
+nocast.c:34:33:    got unsigned long
+nocast.c:34:33: warning: implicit cast to nocast type
+nocast.c:35:39: warning: incorrect type in initializer (different modifiers)
+nocast.c:35:39:    expected unsigned long *static [toplevel] bad_ptr_from
+nocast.c:35:39:    got unsigned long [nocast] *<noident>
+nocast.c:35:39: warning: implicit cast from nocast type
+nocast.c:50:16: warning: implicit cast from nocast type
+nocast.c:54:16: warning: implicit cast from nocast type
+nocast.c:58:16: warning: implicit cast from nocast type
+nocast.c:65:38: warning: implicit cast from nocast type
+nocast.c:66:22: warning: implicit cast from nocast type
+nocast.c:67:23: warning: implicit cast from nocast type
+nocast.c:74:38: warning: implicit cast from nocast type
+nocast.c:75:22: warning: implicit cast from nocast type
+nocast.c:76:23: warning: implicit cast from nocast type
+nocast.c:82:34: warning: incorrect type in initializer (different modifiers)
+nocast.c:82:34:    expected unsigned long *bad_mod
+nocast.c:82:34:    got unsigned long [nocast] [usertype] *t
+nocast.c:82:34: warning: implicit cast from nocast type
+nocast.c:83:49: warning: incorrect type in initializer (different type sizes)
+nocast.c:83:49:    expected unsigned long long [nocast] *bad_size
+nocast.c:83:49:    got unsigned long [nocast] [usertype] *t
+nocast.c:83:49: warning: implicit cast to/from nocast type
+nocast.c:84:33: warning: incorrect type in initializer (different type sizes)
+nocast.c:84:33:    expected short [nocast] *bad_i
+nocast.c:84:33:    got unsigned long [nocast] [usertype] *t
+nocast.c:84:33: warning: implicit cast to/from nocast type
+nocast.c:85:32: warning: implicit cast to/from nocast type
+nocast.c:98:13: warning: implicit cast to nocast type
+nocast.c:99:13: warning: implicit cast to nocast type
+nocast.c:100:13: warning: implicit cast to nocast type
+nocast.c:111:17: warning: implicit cast to nocast type
+nocast.c:112:17: warning: implicit cast to nocast type
+nocast.c:113:17: warning: implicit cast to nocast type
+nocast.c:124:16: warning: implicit cast from nocast type
+nocast.c:129:16: warning: implicit cast from nocast type
+nocast.c:134:16: warning: implicit cast from nocast type
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/noderef.c b/usr/src/tools/smatch/src/validation/noderef.c
new file mode 100644
index 0000000000..8c89f6092b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/noderef.c
@@ -0,0 +1,51 @@
+# define __A	__attribute__((noderef))
+
+struct x {
+	int a;
+	int b;
+};
+
+struct y {
+	int a[2];
+};
+
+static void h(void)
+{
+	char __A *p;
+	char __A * * q1;
+	char * __A * q2;
+	struct x __A *xp;
+	struct x __A x;
+	int __A *q;
+	int __A *r;
+	struct y __A *py;
+	
+	q1 = &p;
+	q2 = &p;	/* This should complain */
+
+	r = &*q;
+	r = q;
+	r = &*(q+1);	/* This should NOT complain */
+	r = q+1;
+
+	r = &xp->a;	/* This should NOT complain */
+	r = &xp->b;
+	r = &(*xp).a;
+	r = &(*xp).b;
+
+	r = &x.a;
+	r = &x.b;
+
+	r = py->a;
+	r = py->a+1;
+	r = &py->a[0];
+}
+/*
+ * check-name: noderef attribute
+ *
+ * check-error-start
+noderef.c:24:12: warning: incorrect type in assignment (different modifiers)
+noderef.c:24:12:    expected char *[noderef] *q2
+noderef.c:24:12:    got char [noderef] **<noident>
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/non-pointer-null.c b/usr/src/tools/smatch/src/validation/non-pointer-null.c
new file mode 100644
index 0000000000..10b8b47416
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/non-pointer-null.c
@@ -0,0 +1,8 @@
+static void *p = 0;
+/*
+ * check-name: Using plain integer as NULL pointer
+ *
+ * check-error-start
+non-pointer-null.c:1:18: warning: Using plain integer as NULL pointer
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/old-initializer-nowarn.c b/usr/src/tools/smatch/src/validation/old-initializer-nowarn.c
new file mode 100644
index 0000000000..4efe00d76f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/old-initializer-nowarn.c
@@ -0,0 +1,9 @@
+struct s {
+	int i;
+};
+
+static struct s the_s = { i: 1 };
+/*
+ * check-name: Old initializer with -Wno-old-initializer
+ * check-command: sparse -Wno-old-initializer
+ */
diff --git a/usr/src/tools/smatch/src/validation/old-initializer.c b/usr/src/tools/smatch/src/validation/old-initializer.c
new file mode 100644
index 0000000000..48aeeaabd0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/old-initializer.c
@@ -0,0 +1,12 @@
+struct s {
+	int i;
+};
+
+static struct s the_s = { i: 1 };
+/*
+ * check-name: Old initializer
+ *
+ * check-error-start
+old-initializer.c:5:27: warning: obsolete struct initializer, use C99 syntax
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/old-style-definition0.c b/usr/src/tools/smatch/src/validation/old-style-definition0.c
new file mode 100644
index 0000000000..eb522aa6f7
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/old-style-definition0.c
@@ -0,0 +1,14 @@
+extern int foo(int a, void *b);
+
+int foo(a, b)
+	int a;
+	void *b;
+{
+	if (b)
+		return a;
+}
+
+/*
+ * check-name: old-stype-definition disabled
+ * check-command: sparse -Wno-old-style-definition $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/old-style-definition1.c b/usr/src/tools/smatch/src/validation/old-style-definition1.c
new file mode 100644
index 0000000000..f65d7dfe31
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/old-style-definition1.c
@@ -0,0 +1,18 @@
+extern int foo(int a, void *b);
+
+int foo(a, b)
+	int a;
+	void *b;
+{
+	if (b)
+		return a;
+}
+
+/*
+ * check-name: old-stype-definition enabled
+ * check-command: sparse -Wold-style-definition $file
+ *
+ * check-error-start
+old-style-definition1.c:4:9: warning: non-ANSI definition of function 'foo'
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/binops-same-args.c b/usr/src/tools/smatch/src/validation/optim/binops-same-args.c
new file mode 100644
index 0000000000..9285655d31
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/binops-same-args.c
@@ -0,0 +1,49 @@
+typedef unsigned int u32;
+
+int ssub(int a) { return a - a; }
+u32 usub(u32 a) { return a - a; }
+
+int sdiv(int a) { return a / a; }
+u32 udiv(u32 a) { return a / a; }
+int smod(int a) { return a % a; }
+u32 umod(u32 a) { return a % a; }
+
+int seq(int a) { return a == a; }
+int sne(int a) { return a != a; }
+int slt(int a) { return a < a; }
+int sgt(int a) { return a > a; }
+int sle(int a) { return a <= a; }
+int sge(int a) { return a >= a; }
+
+u32 ueq(u32 a) { return a == a; }
+u32 une(u32 a) { return a != a; }
+u32 ult(u32 a) { return a < a; }
+u32 ugt(u32 a) { return a > a; }
+u32 ule(u32 a) { return a <= a; }
+u32 uge(u32 a) { return a >= a; }
+
+u32 xor(u32 a) { return a ^ a; }
+
+u32 ior(u32 a) { return a | a; }
+u32 and(u32 a) { return a & a; }
+
+/*
+ * check-name: double-unop
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-excludes: sub\\.
+ * check-output-contains: divs\\.
+ * check-output-contains: divu\\.
+ * check-output-contains: mods\\.
+ * check-output-contains: modu\\.
+ * check-output-excludes: seteq\\.
+ * check-output-excludes: setne\\.
+ * check-output-excludes: set[gl]t\\.
+ * check-output-excludes: set[gl]e\\.
+ * check-output-excludes: set[ab]\\.
+ * check-output-excludes: set[ab]e\\.
+ * check-output-excludes: xor\\.
+ * check-output-excludes: or\\.
+ * check-output-excludes: and\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/bool-context.c b/usr/src/tools/smatch/src/validation/optim/bool-context.c
new file mode 100644
index 0000000000..11326d391f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/bool-context.c
@@ -0,0 +1,12 @@
+#define bool _Bool
+
+bool bool_ior(int a, int b) { return a || b; }
+bool bool_and(int a, int b) { return a && b; }
+
+/*
+ * check-name: bool-context
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-pattern-4-times: setne\\..* %arg[12]
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/bool-same-args.c b/usr/src/tools/smatch/src/validation/optim/bool-same-args.c
new file mode 100644
index 0000000000..0ae4684ea3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/bool-same-args.c
@@ -0,0 +1,12 @@
+static int ior(int a) { return a || a; }
+static int and(int a) { return a && a; }
+
+/*
+ * check-name: bool-same-args
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: or-bool\\.
+ * check-output-excludes: and-bool\\.
+ * check-output-contains: setne\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/bool-simplify.c b/usr/src/tools/smatch/src/validation/optim/bool-simplify.c
new file mode 100644
index 0000000000..05be114978
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/bool-simplify.c
@@ -0,0 +1,55 @@
+int and_0(int a)
+{
+	return a && 0;
+}
+
+int and_1(int a)
+{
+	return a && 1;
+}
+
+int or_0(int a)
+{
+	return a || 0;
+}
+
+int or_1(int a)
+{
+	return a || 1;
+}
+
+/*
+ * check-name: bool-simplify
+ * check-command: test-linearize -Wno-decl $file
+ *
+ * check-output-start
+and_0:
+.L0:
+	<entry-point>
+	ret.32      $0
+
+
+and_1:
+.L2:
+	<entry-point>
+	setne.1     %r8 <- %arg1, $0
+	cast.32     %r11 <- (1) %r8
+	ret.32      %r11
+
+
+or_0:
+.L4:
+	<entry-point>
+	setne.1     %r14 <- %arg1, $0
+	cast.32     %r17 <- (1) %r14
+	ret.32      %r17
+
+
+or_1:
+.L6:
+	<entry-point>
+	ret.32      $1
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/cse-commutativity.c b/usr/src/tools/smatch/src/validation/optim/cse-commutativity.c
new file mode 100644
index 0000000000..826034781c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/cse-commutativity.c
@@ -0,0 +1,22 @@
+static int add(int a, int b) { return (a + b) == (b + a); }
+static int mul(int a, int b) { return (a * b) == (b * a); }
+static int and(int a, int b) { return (a & b) == (b & a); }
+static int ior(int a, int b) { return (a | b) == (b | a); }
+static int xor(int a, int b) { return (a ^ b) == (b ^ a); }
+static int  eq(int a, int b) { return (a == b) == (b == a); }
+static int  ne(int a, int b) { return (a != b) == (b != a); }
+
+
+/*
+ * check-name: cse-commutativity
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: add\\.
+ * check-output-excludes: muls\\.
+ * check-output-excludes: and\\.
+ * check-output-excludes: or\\.
+ * check-output-excludes: xor\\.
+ * check-output-excludes: seteq\\.
+ * check-output-excludes: setne\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/cse-dual-compare.c b/usr/src/tools/smatch/src/validation/optim/cse-dual-compare.c
new file mode 100644
index 0000000000..b43cf78992
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/cse-dual-compare.c
@@ -0,0 +1,34 @@
+static int eqeq(int a, int b) { return (a == b) == (b == a); }
+static int nene(int a, int b) { return (a != b) == (b != a); }
+
+static int ltgt(int a, int b) { return (a <  b) == (b >  a); }
+static int lege(int a, int b) { return (a <= b) == (b >= a); }
+static int gele(int a, int b) { return (a >= b) == (b <= a); }
+static int gtlt(int a, int b) { return (a >  b) == (b <  a); }
+
+static int eneqne(int a, int b) { return (a == b) == !(b != a); }
+static int enneeq(int a, int b) { return (a != b) == !(b == a); }
+
+static int enltle(int a, int b) { return (a <  b) == !(b <= a); }
+static int enlelt(int a, int b) { return (a <= b) == !(b <  a); }
+static int engegt(int a, int b) { return (a >= b) == !(b >  a); }
+static int engtge(int a, int b) { return (a >  b) == !(b >= a); }
+
+static int neeqne(int a, int b) { return (a == b) != (b != a); }
+static int neneeq(int a, int b) { return (a != b) != (b == a); }
+
+static int neltle(int a, int b) { return (a <  b) != (b <= a); }
+static int nelelt(int a, int b) { return (a <= b) != (b <  a); }
+static int negegt(int a, int b) { return (a >= b) != (b >  a); }
+static int negtge(int a, int b) { return (a >  b) != (b >= a); }
+
+/*
+ * check-name: cse-dual-compare
+ * check-command: test-linearize $file
+ * check-output-ignore
+ * check-known-to-fail
+ *
+ * check-output-excludes: set[gl][et]\\.
+ * check-output-excludes: seteq\\.
+ * check-output-excludes: setne\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/double-unop.c b/usr/src/tools/smatch/src/validation/optim/double-unop.c
new file mode 100644
index 0000000000..f0e6d94f4c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/double-unop.c
@@ -0,0 +1,15 @@
+typedef unsigned int u32;
+
+u32 unotnot(u32 a) { return ~(~a); }
+int snotnot(int a) { return ~(~a); }
+u32 unegneg(int a) { return -(-a); }
+int snegneg(int a) { return -(-a); }
+
+/*
+ * check-name: double-unop
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-excludes: not\\.
+ * check-output-excludes: neg\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/fpcast-nop.c b/usr/src/tools/smatch/src/validation/optim/fpcast-nop.c
new file mode 100644
index 0000000000..c2e7ba87fa
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/fpcast-nop.c
@@ -0,0 +1,15 @@
+static  float foof( float a) { return ( float) a; }
+static double food(double a) { return (double) a; }
+static long double fool(long double a) { return (long double) a; }
+
+/*
+ * check-name: fpcast-nop
+ * check-description:
+ *	Verify that unneeded casts between same-type
+ *	floats are also optimized away.
+ *
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: fpcast\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/muldiv-by-one.c b/usr/src/tools/smatch/src/validation/optim/muldiv-by-one.c
new file mode 100644
index 0000000000..5d9b458e07
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/muldiv-by-one.c
@@ -0,0 +1,19 @@
+typedef	unsigned int ui;
+typedef	         int si;
+
+si smul1(si a) {  return a * 1; }
+ui umul1(ui a) {  return a * 1; }
+si sdiv1(si a) {  return a / 1; }
+ui udiv1(ui a) {  return a / 1; }
+si smod1(si a) {  return a % 1; }
+ui umod1(ui a) {  return a % 1; }
+
+/*
+ * check-name: muldiv-by-one
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-excludes: mul[us]\\.
+ * check-output-excludes: div[us]\\.
+ * check-output-excludes: mod[us]\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/muldiv-by-zero.c b/usr/src/tools/smatch/src/validation/optim/muldiv-by-zero.c
new file mode 100644
index 0000000000..07b7b1a79b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/muldiv-by-zero.c
@@ -0,0 +1,13 @@
+typedef	unsigned int ui;
+typedef	         int si;
+
+si smul0(si a) {  return a * 0; }
+ui umul0(ui a) {  return a * 0; }
+
+/*
+ * check-name: muldiv-by-zero
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-excludes: mul[us]\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/muldiv-minus-one.c b/usr/src/tools/smatch/src/validation/optim/muldiv-minus-one.c
new file mode 100644
index 0000000000..42b086afd8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/muldiv-minus-one.c
@@ -0,0 +1,18 @@
+typedef	unsigned int u32;
+
+int smulm1(int a) { return a * -1; }
+u32 umulm1(u32 a) { return a * (u32) -1; }
+int sdivm1(int a) { return a / -1; }
+u32 udivm1(u32 a) { return a / (u32) -1; }
+
+/*
+ * check-name: muldiv-minus-one
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-excludes: mul[us]\\.
+ * check-output-excludes: divs\\.
+ * check-output-contains: neg\\.
+ * check-output-contains: divu\\.
+ * check-output-pattern-3-times: neg\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/setcc-setcc.c b/usr/src/tools/smatch/src/validation/optim/setcc-setcc.c
new file mode 100644
index 0000000000..fac7520e2e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/setcc-setcc.c
@@ -0,0 +1,19 @@
+static _Bool blt(int a, int b)	{ return  (a <  b); }
+static _Bool bnge(int a, int b)	{ return !(a >= b); }
+static _Bool bgt(int a, int b)	{ return  (a >  b); }
+static _Bool bnle(int a, int b)	{ return !(a <= b); }
+static _Bool ble(int a, int b)	{ return  (a <= b); }
+static _Bool bngt(int a, int b)	{ return !(a >  b); }
+static _Bool bge(int a, int b)	{ return  (a >= b); }
+static _Bool bnlt(int a, int b)	{ return !(a <  b); }
+
+/*
+ * check-name: optim/setcc-setcc
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: set..\\.32
+ * check-output-excludes: setne\\.1
+ * check-output-excludes: seteq\\.1
+ * check-output-contains: set[gt][te]\\.1
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/setcc-seteq.c b/usr/src/tools/smatch/src/validation/optim/setcc-seteq.c
new file mode 100644
index 0000000000..d8765fe103
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/setcc-seteq.c
@@ -0,0 +1,13 @@
+static _Bool beq0(int a)	{ return  (a == 0); }
+static _Bool bnotneq0(int a)	{ return !(a != 0); }
+static _Bool bnot(int a)	{ return !a; }
+
+/*
+ * check-name: optim/setcc-seteq
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: set..\\.32
+ * check-output-excludes: setne\\.1
+ * check-output-contains: seteq\\.1
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/setcc-setne.c b/usr/src/tools/smatch/src/validation/optim/setcc-setne.c
new file mode 100644
index 0000000000..f982eb34cb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/setcc-setne.c
@@ -0,0 +1,13 @@
+static _Bool bnoteq0(int a)	{ return !(a == 0); }
+static _Bool bne0(int a)	{ return  (a != 0); }
+static _Bool bnotnot(int a)	{ return !!a; }
+
+/*
+ * check-name: optim/setcc-setne
+ * check-command: test-linearize $file
+ * check-output-ignore
+ *
+ * check-output-excludes: set..\\.32
+ * check-output-excludes: seteq\\.1
+ * check-output-contains: setne\\.1
+ */
diff --git a/usr/src/tools/smatch/src/validation/optim/void-if-convert.c b/usr/src/tools/smatch/src/validation/optim/void-if-convert.c
new file mode 100644
index 0000000000..66513c4dc2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/optim/void-if-convert.c
@@ -0,0 +1,19 @@
+int foo(int a)
+{
+	if (a)
+		return 0;
+	else
+		return 1;
+	return 2;
+}
+
+/*
+ * check-name: Ignore VOID in if-convert
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-excludes: phisrc\\.
+ * check-output-excludes: phi\\.
+ * check-output-excludes: VOID
+ * check-output-contains: seteq\\.
+ */
diff --git a/usr/src/tools/smatch/src/validation/outer-scope.c b/usr/src/tools/smatch/src/validation/outer-scope.c
new file mode 100644
index 0000000000..f86ffc74d4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/outer-scope.c
@@ -0,0 +1,16 @@
+#ifndef FOO
+struct st { int len; };
+#define FOO
+#else
+struct st;
+static int test(struct st *s);
+static int test(struct st *s)
+{
+	return s->len;
+}
+#endif
+/*
+ * check-name: There is no scope boundary between global and file scope
+ * check-description: Used to mess scopes with -include
+ * check-command: sparse -include $file $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/phase2/backslash b/usr/src/tools/smatch/src/validation/phase2/backslash
new file mode 100644
index 0000000000..29c85b4d0f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/phase2/backslash
@@ -0,0 +1,62 @@
+/*
+ *	'\\' has a special meaning on phase 2 if and only if it is immediately
+ * followed by '\n'.  In any other position it's left alone as any other
+ * character.
+ *
+ * [5.1.1.2(1.2)]:
+ *   Each instance of a backslash character (\) immediately followed by
+ *   a new-line character is deleted, splicing physical source lines to
+ *   form logical source lines.  Only the last backslash on any physical
+ *   source line shall be eligible for being part of such a splice.
+ *   A source file that is not empty shall end in a new-line character,
+ *   which shall not be immediately preceded by a backslash character
+ *   before any such splicing takes place.
+ *
+ * Note that this happens on the phase 2, before we even think of any
+ * tokens.  In other words, splicing is ignorant of and transparent for
+ * the rest of tokenizer.
+ */
+
+#define A(x) #x
+#define B(x) A(x)
+/* This should result in "\a" */
+/* XXX: currently sparse produces "a" */
+/* Partially fixed: now it gives "\\a", which is a separate problem */
+B(\a)
+
+#define C\
+ 1
+/* This should give 1 */
+C
+
+#define D\
+1
+/* And this should give D, since '\n' is removed and we get no whitespace */
+/* XXX: currently sparse produces 1 */
+/* Fixed */
+D
+
+#define E '\\
+a'
+/* This should give '\a' - with no warnings issued */
+/* XXX: currently sparse complains a lot and ends up producing a */
+/* Fixed */
+E
+
+/* This should give nothing */
+/* XXX: currently sparse produces more junk */
+/* Fixed */
+// junk \
+more junk
+
+/* This should also give nothing */
+/* XXX: currently sparse produces / * comment * / */
+/* Fixed */
+/\
+* comment *\
+/
+
+/* And this should complain since final newline should not be eaten by '\\' */
+/* XXX: currently sparse does not notice */
+/* Fixed */
+\
diff --git a/usr/src/tools/smatch/src/validation/phase3/comments b/usr/src/tools/smatch/src/validation/phase3/comments
new file mode 100644
index 0000000000..8f51a307b0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/phase3/comments
@@ -0,0 +1,9 @@
+/*
+ *  Each comment should be treated as if it had been a single space.
+ */
+
+/* This should give nothing */
+/* XXX: currently sparse produces Y */
+/* Fixed */
+#define X /*
+ */ Y
diff --git a/usr/src/tools/smatch/src/validation/pragma-once.c b/usr/src/tools/smatch/src/validation/pragma-once.c
new file mode 100644
index 0000000000..5e8b82542d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/pragma-once.c
@@ -0,0 +1,5 @@
+#pragma once
+#include "pragma-once.c"
+/*
+ * check-name: #pragma once
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/counter1.c b/usr/src/tools/smatch/src/validation/preprocessor/counter1.c
new file mode 100644
index 0000000000..98187ee64a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/counter1.c
@@ -0,0 +1,12 @@
+__COUNTER__
+__COUNTER__
+/*
+ * check-name: __COUNTER__ #1
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+0
+1
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/counter2.c b/usr/src/tools/smatch/src/validation/preprocessor/counter2.c
new file mode 100644
index 0000000000..9883b6822d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/counter2.c
@@ -0,0 +1,14 @@
+__FILE__ __COUNTER__
+#include <counter2.h>
+__FILE__ __COUNTER__
+/*
+ * check-name: __COUNTER__ #2
+ * check-command: sparse -Ipreprocessor -E $file
+ *
+ * check-output-start
+
+"preprocessor/counter2.c" 0
+"preprocessor/counter2.h" 1
+"preprocessor/counter2.c" 2
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/counter2.h b/usr/src/tools/smatch/src/validation/preprocessor/counter2.h
new file mode 100644
index 0000000000..447b70ab74
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/counter2.h
@@ -0,0 +1 @@
+__FILE__ __COUNTER__
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/counter3.c b/usr/src/tools/smatch/src/validation/preprocessor/counter3.c
new file mode 100644
index 0000000000..fa3f173b10
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/counter3.c
@@ -0,0 +1,14 @@
+/*
+ * check-name: __COUNTER__ #3
+ * check-command: sparse -Ipreprocessor -E preprocessor/counter1.c $file
+ *
+ * check-output-start
+
+0
+1
+"preprocessor/counter2.c" 0
+"preprocessor/counter2.h" 1
+"preprocessor/counter2.c" 2
+ * check-output-end
+ */
+#include "counter2.c"
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/dump-macros-empty.c b/usr/src/tools/smatch/src/validation/preprocessor/dump-macros-empty.c
new file mode 100644
index 0000000000..672c66c711
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/dump-macros-empty.c
@@ -0,0 +1,7 @@
+/*
+ * check-name: dump-macros with empty file
+ * check-command: sparse -E -dD empty-file
+ *
+ * check-output-ignore
+check-output-pattern-1-times: #define __CHECKER__ 1
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/dump-macros-multi.c b/usr/src/tools/smatch/src/validation/preprocessor/dump-macros-multi.c
new file mode 100644
index 0000000000..2f6e8d04fb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/dump-macros-multi.c
@@ -0,0 +1,7 @@
+/*
+ * check-name: dump-macros with multiple files
+ * check-command: sparse -E -dD empty-file $file
+ *
+ * check-output-ignore
+check-output-pattern-2-times: #define __CHECKER__ 1
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/dump-macros.c b/usr/src/tools/smatch/src/validation/preprocessor/dump-macros.c
new file mode 100644
index 0000000000..79f3de6a2c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/dump-macros.c
@@ -0,0 +1,18 @@
+#define ABC abc
+#undef ABC
+
+#define	DEF def
+#undef DEF
+#define DEF xyz
+
+#define NYDEF ydef
+/*
+ * check-name: dump-macros
+ * check-command: sparse -E -dD -DIJK=ijk -UNDEF -UNYDEF $file
+ *
+ * check-output-ignore
+check-output-pattern-1-times: #define __CHECKER__ 1
+check-output-contains: #define IJK ijk
+check-output-contains: #define DEF xyz
+check-output-contains: #define NYDEF ydef
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/early-escape.c b/usr/src/tools/smatch/src/validation/preprocessor/early-escape.c
new file mode 100644
index 0000000000..5ca5e8f42b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/early-escape.c
@@ -0,0 +1,22 @@
+#if 0
+"\l"
+#endif
+
+/*
+ * check-description:
+ *	Following the C standard, escape conversion must be
+ *	done in phase 5, just after preprocessing and just
+ *	before string concatenation. So we're not supposed
+ *	to receive a diagnostic for an unknown escape char
+ *	for a token which is excluded by the preprocessor.
+ * check-name: early-escape
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+
+ * check-output-end
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/predef-char-bit.c b/usr/src/tools/smatch/src/validation/preprocessor/predef-char-bit.c
new file mode 100644
index 0000000000..fed0166e48
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/predef-char-bit.c
@@ -0,0 +1,16 @@
+#define TEST_BIT(X, T)	if (__ ## X ## _BIT__  != 8 * sizeof(T)) return 1
+
+int test(void)
+{
+	TEST_BIT(CHAR, char);
+
+	return 0;
+}
+
+/*
+ * check-name: predefined __<type>_BIT__
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-contains: ret\\..*\\$0
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/predef-max.c b/usr/src/tools/smatch/src/validation/preprocessor/predef-max.c
new file mode 100644
index 0000000000..ad4b7eaf1b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/predef-max.c
@@ -0,0 +1,18 @@
+#define TEST_MAX(X, Z)	if (X != ((~ Z) >> 1))	return 1
+
+int test_max(void)
+{
+	TEST_MAX(__INT_MAX__, 0U);
+	TEST_MAX(__LONG_MAX__, 0UL);
+	TEST_MAX(__LONG_LONG_MAX__, 0ULL);
+
+	return 0;
+}
+
+/*
+ * check-name: predefined __<type>_MAX__
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-contains: ret\\..*\\$0
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/predef-sizeof.c b/usr/src/tools/smatch/src/validation/preprocessor/predef-sizeof.c
new file mode 100644
index 0000000000..12be2dd1dd
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/predef-sizeof.c
@@ -0,0 +1,25 @@
+#define TEST(X, T)	if (__SIZEOF_ ## X ## __ != sizeof(T))	return 1
+
+int test_sizeof(void)
+{
+	TEST(SHORT, short);
+	TEST(INT, int);
+	TEST(LONG, long);
+	TEST(LONG_LONG, long long);
+	TEST(INT128, __int128);
+	TEST(SIZE_T, __SIZE_TYPE__);
+	TEST(POINTER, void*);
+	TEST(FLOAT, float);
+	TEST(DOUBLE, double);
+	TEST(LONG_DOUBLE, long double);
+
+	return 0;
+}
+
+/*
+ * check-name: predefined __SIZEOF_<type>__
+ * check-command: test-linearize -Wno-decl $file
+ * check-output-ignore
+ *
+ * check-output-contains: ret\\..*\\$0
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor1.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor1.c
new file mode 100644
index 0000000000..7d81474387
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor1.c
@@ -0,0 +1,14 @@
+#define func(x) x
+#define bar func(
+#define foo bar foo
+foo )
+/*
+ * check-name: Preprocessor #1
+ * check-description: Used to cause infinite recursion.
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+foo
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor10.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor10.c
new file mode 100644
index 0000000000..02b56df4e8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor10.c
@@ -0,0 +1,19 @@
+/* concatenation of 'defi' and 'ned' should result in the same token
+ * we would get if we had 'defined' in the input stream.
+ */
+#define A
+#define B defi ## ned
+#if B(A)
+defined
+#else
+undefined
+#endif
+/*
+ * check-name: Preprocessor #10
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+defined
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor11.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor11.c
new file mode 100644
index 0000000000..4b37664869
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor11.c
@@ -0,0 +1,31 @@
+#define A(1) x
+#define B(x
+#define C(x,
+#define D(,)
+#define E(__VA_ARGS__)
+#define F(x+
+#define G(x...,
+#define H(x...,y)
+#define I(...+
+#define J(x,y)
+/*
+ * check-name: Preprocessor #11
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+
+ * check-output-end
+ *
+ * check-error-start
+preprocessor/preprocessor11.c:1:11: error: "1" may not appear in macro parameter list
+preprocessor/preprocessor11.c:2:11: error: missing ')' in macro parameter list
+preprocessor/preprocessor11.c:3:12: error: missing ')' in macro parameter list
+preprocessor/preprocessor11.c:4:11: error: parameter name missing
+preprocessor/preprocessor11.c:5:11: error: __VA_ARGS__ can only appear in the expansion of a C99 variadic macro
+preprocessor/preprocessor11.c:6:12: error: "+" may not appear in macro parameter list
+preprocessor/preprocessor11.c:7:12: error: missing ')' in macro parameter list
+preprocessor/preprocessor11.c:8:12: error: missing ')' in macro parameter list
+preprocessor/preprocessor11.c:9:11: error: missing ')' in macro parameter list
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor12.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor12.c
new file mode 100644
index 0000000000..e23e53b2b1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor12.c
@@ -0,0 +1,18 @@
+/*
+ * GNU kludge
+ */
+#define A(x,...) x,##__VA_ARGS__
+A(1)
+A(1,2)
+A(1,2,3)
+/*
+ * check-name: Preprocessor #12
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+1
+1,2
+1,2,3
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor13.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor13.c
new file mode 100644
index 0000000000..b1af8555a3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor13.c
@@ -0,0 +1,23 @@
+/*
+ * GNU kludge, corner case
+ */
+#define A(x,...) x##,##__VA_ARGS__
+A(1)
+A(1,2)
+A(1,2,3)
+/*
+ * check-name: Preprocessor #13
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+1
+1,2
+1,2,3
+ * check-output-end
+ *
+ * check-error-start
+preprocessor/preprocessor13.c:6:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor13.c:7:1: error: '##' failed: concatenation is not a valid token
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor14.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor14.c
new file mode 100644
index 0000000000..027af04036
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor14.c
@@ -0,0 +1,16 @@
+/*
+ * GNU kludge, another corner case
+ */
+#define A(x,y,...) ,##x##__VA_ARGS__
+A(,1)
+#define B(x,y,...) x##,##__VA_ARGS__
+B(,1)
+/*
+ * check-name: Preprocessor #14
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor15.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor15.c
new file mode 100644
index 0000000000..df8775194f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor15.c
@@ -0,0 +1,16 @@
+#define A defi
+#define B ned
+#define C(x,y) x##y
+#define D(x,y) C(x,y)
+#if D(A,B) B
+D(1,2)
+#endif
+/*
+ * check-name: Preprocessor #15
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+12
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor16.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor16.c
new file mode 100644
index 0000000000..75a4a0be5f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor16.c
@@ -0,0 +1,30 @@
+#if 0
+/*
+From 6.10.1(5):
+	Each directive's condition is checked in order.  If it evaluates
+	to false (zero), the group it controls is skipped: directives are
+	processed only through the name that determines the directive in
+	order to keep track of the level of nested conditionals; the rest
+	of the directives' preprocessing tokens are ignores, >>as are the
+	other preprocessing tokens in the group<<.
+
+In other words, bogus arguments of directives are silently ignored and
+so are text lines and non-directives (# <something unknown>).  We *do*
+complain about the things like double #else or #elif after #else, since
+they hit before we get to the level of groups.
+*/
+
+#define 1
+#undef 1
+#bullshit
+
+#endif
+/*
+ * check-name: Preprocessor #16
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor17.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor17.c
new file mode 100644
index 0000000000..bd54fa6e21
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor17.c
@@ -0,0 +1,15 @@
+#if 0
+/* these should not warn */
+#ifdef (
+#endif
+#ifndef (
+#endif
+#endif
+/*
+ * check-name: Preprocessor #17
+ * check-command: sparse -E $file
+ * check-output-start
+
+
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor18.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor18.c
new file mode 100644
index 0000000000..20169e8b5f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor18.c
@@ -0,0 +1,17 @@
+/* one warning for each, please... */
+#define 1
+#undef 1
+/*
+ * check-name: Preprocessor #18
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+
+ * check-output-end
+ *
+ * check-error-start
+preprocessor/preprocessor18.c:2:2: error: expected identifier to 'define'
+preprocessor/preprocessor18.c:3:2: error: expected identifier to 'undef'
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor19.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor19.c
new file mode 100644
index 0000000000..e70dad1e88
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor19.c
@@ -0,0 +1,18 @@
+/* got burned by that - freed the new definition in the case when we had
+   warned and replaced the old one */
+#define A x
+#define A y
+A
+/*
+ * check-name: Preprocessor #19
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+y
+ * check-output-end
+ * check-error-start
+preprocessor/preprocessor19.c:4:9: warning: preprocessor token A redefined
+preprocessor/preprocessor19.c:3:9: this was the original definition
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor2.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor2.c
new file mode 100644
index 0000000000..56abb53cf6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor2.c
@@ -0,0 +1,15 @@
+#define TWO a, b
+
+#define UNARY(x) BINARY(x)
+#define BINARY(x, y) x + y
+
+UNARY(TWO)
+/*
+ * check-name: Preprocessor #2
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+a + b
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor20.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor20.c
new file mode 100644
index 0000000000..90e93f3787
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor20.c
@@ -0,0 +1,14 @@
+#include "preprocessor20.h"
+#define X
+#define Y
+#include "preprocessor20.h"
+/*
+ * check-name: Preprocessor #20
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+A
+B
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor20.h b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor20.h
new file mode 100644
index 0000000000..322c543a69
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor20.h
@@ -0,0 +1,6 @@
+#ifdef X
+B
+#endif
+#ifndef Y
+A
+#endif
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor21.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor21.c
new file mode 100644
index 0000000000..4b55a6b894
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor21.c
@@ -0,0 +1,16 @@
+#if 1
+#if
+/*
+ * check-name: Preprocessor #21
+ * check-description: This used to hang Sparse.
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+
+ * check-output-end
+ *
+ * check-error-start
+preprocessor/preprocessor21.c:2:2: error: unterminated preprocessor conditional
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor22.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor22.c
new file mode 100644
index 0000000000..af5bcb37fa
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor22.c
@@ -0,0 +1,35 @@
+#define CONFIG_FOO 1
+
+#define define_struct(name, fields...) struct fields name;
+
+define_struct(a, {
+#ifdef CONFIG_FOO
+  int b;
+#elif defined(CONFIG_BAR)
+  int c;
+#else
+  int d;
+#endif
+});
+/*
+ * check-name: Preprocessor #22
+ *
+ * check-description: Directives are not allowed within a macro argument list,
+ * although cpp deals with it to treat macro more like C functions.
+ *
+ * check-command: sparse -E $file
+ *
+ * check-error-start
+preprocessor/preprocessor22.c:6:1: error: directive in argument list
+preprocessor/preprocessor22.c:8:1: error: directive in argument list
+preprocessor/preprocessor22.c:10:1: error: directive in argument list
+preprocessor/preprocessor22.c:12:1: error: directive in argument list
+ * check-error-end
+ *
+ * check-output-start
+
+struct {
+int b;
+} a;;
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor23.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor23.c
new file mode 100644
index 0000000000..a778483882
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor23.c
@@ -0,0 +1,51 @@
+#define H(x,...) ,##x##__VA_ARGS__##,##__VA_ARGS__
+H()
+H(x)
+H(,)
+H(x,)
+H(,x)
+H(x,x)
+#define I(x,...) ,##x##__VA_ARGS__
+I()
+I(x)
+I(,)
+I(x,)
+I(,x)
+I(x,x)
+#define J(...) ,##__VA_ARGS__
+J()
+J(x)
+/*
+ * check-name: Preprocessor #23
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+,
+,x
+,,
+,x,
+,x,x
+,xx,x
+,x
+,
+,x
+,x
+,xx
+,x
+ * check-output-end
+ *
+ * check-error-start
+preprocessor/preprocessor23.c:3:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:4:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:5:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:5:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:6:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:6:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:7:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:7:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:10:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:12:1: error: '##' failed: concatenation is not a valid token
+preprocessor/preprocessor23.c:14:1: error: '##' failed: concatenation is not a valid token
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor3.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor3.c
new file mode 100644
index 0000000000..e9f6ae7200
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor3.c
@@ -0,0 +1,32 @@
+/*
+ * Each iteration of the scanning of "SCAN()" re-evaluates the recursive
+ * B->A->B expansion.
+ *
+ * Did I already mention that the C preprocessor language
+ * is a perverse thing?
+ */
+
+#define LP (
+
+#define A() B LP )
+#define B() A LP )
+
+#define SCAN(x) x
+
+A()                     // B ( )
+SCAN( A() )             // A ( )
+SCAN(SCAN( A() ))       // B ( )
+SCAN(SCAN(SCAN( A() ))) // A ( )
+/*
+ * check-name: Preprocessor #3
+ * check-description: Sparse used to get this wrong, outputting A third, not B.
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+B ( )
+A ( )
+B ( )
+A ( )
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor4.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor4.c
new file mode 100644
index 0000000000..710c494faa
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor4.c
@@ -0,0 +1,15 @@
+#define foo bar
+#define mac(x) x(foo)
+
+mac(foo)
+
+/*
+ * check-name: Preprocessor #4
+ * check-description: More examples from the comp.std.c discussion.
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+bar(bar)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor5.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor5.c
new file mode 100644
index 0000000000..b4316275e1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor5.c
@@ -0,0 +1,14 @@
+#define a a|
+#define b(x) x
+
+b(a)
+/*
+ * check-name: Preprocessor #5
+ * check-description: Yet more examples from comp.std.c.
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+a|
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor6.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor6.c
new file mode 100644
index 0000000000..41da2674d9
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor6.c
@@ -0,0 +1,29 @@
+/* We used to get '##' wrong for the kernel.
+ *
+ * It could possibly be argued that the kernel usage is undefined (since the
+ * different sides of the '##' are not proper tokens), but we try to do it
+ * right anyway.
+ *
+ * We used to break up the "003d" into two tokens ('003' and 'd') and then put
+ * the 'o' marker to mark the token 003 as an octal number, resulting in:
+ *
+ *	static char __vendorstr_o03 d [ ] __devinitdata = "Lockheed Martin-Marietta Corp";
+ *
+ * which didn't work, of course.
+ */
+
+#define __devinitdata __attribute__((section(".devinit")))
+
+#define VENDOR( vendor, name ) \
+	static char __vendorstr_##vendor[] __devinitdata = name;
+VENDOR(003d,"Lockheed Martin-Marietta Corp")
+
+/*
+ * check-name: Preprocessor #6
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+static char __vendorstr_003d[] __attribute__((section(".devinit"))) = "Lockheed Martin-Marietta Corp";
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor7.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor7.c
new file mode 100644
index 0000000000..07fce8c3fa
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor7.c
@@ -0,0 +1,14 @@
+#define A(x) C(B, D
+#define D A(1))
+#define C(x,y) E(y)
+#define E(y) #y
+A(2))
+/*
+ * check-name: Preprocessor #7
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+"\"D\""
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor8.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor8.c
new file mode 100644
index 0000000000..524825c1c4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor8.c
@@ -0,0 +1,38 @@
+#define A(x) ## x
+#define B(x) x ##
+#define C(x) x ## ## ##
+#define D(x) x#y
+#define E x#y
+#define F(x,y) x x##y #x y
+#define G a##b
+#define H 1##2
+#define I(x,y,z) x y z
+"A(x)"			: A(x)
+"B(x)"			: B(x)
+"C(x)"			: C(x)
+"D(x)"			: D(x)
+"x#y"			: E
+"ab GH \"G\" 12"	: F(G,H)
+"a ## b"		: I(a,##,b)
+/*
+ * check-name: Preprocessor #8
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+"A(x)" : A(x)
+"B(x)" : B(x)
+"C(x)" : C(x)
+"D(x)" : D(x)
+"x#y" : x#y
+"ab GH \"G\" 12" : ab GH "G" 12
+"a ## b" : a ## b
+ * check-output-end
+ *
+ * check-error-start
+preprocessor/preprocessor8.c:1:14: error: '##' cannot appear at the ends of macro expansion
+preprocessor/preprocessor8.c:2:16: error: '##' cannot appear at the ends of macro expansion
+preprocessor/preprocessor8.c:3:22: error: '##' cannot appear at the ends of macro expansion
+preprocessor/preprocessor8.c:4:15: error: '#' is not followed by a macro parameter
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/preprocessor9.c b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor9.c
new file mode 100644
index 0000000000..20f9c8fc33
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/preprocessor9.c
@@ -0,0 +1,16 @@
+/* Only # in the input stream marks the beginning of preprocessor command,
+ * and here we get it from macro expansion.
+ */
+#define A # define X 1
+A
+X
+/*
+ * check-name: Preprocessor #9
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+# define X 1
+X
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/stringify.c b/usr/src/tools/smatch/src/validation/preprocessor/stringify.c
new file mode 100644
index 0000000000..7fe965d52a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/stringify.c
@@ -0,0 +1,29 @@
+#define A(x) #x
+A('a')
+A("a")
+A(a)
+A(\n)
+A('\n')
+A("\n")
+A('"')
+A("a\nb")
+A(L"a\nb")
+A('\12')
+/*
+ * check-name: Preprocessor #14
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+"'a'"
+"\"a\""
+"a"
+"\n"
+"'\\n'"
+"\"\\n\""
+"'\"'"
+"\"a\\nb\""
+"L\"a\\nb\""
+"'\\12'"
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/preprocessor/wide.c b/usr/src/tools/smatch/src/validation/preprocessor/wide.c
new file mode 100644
index 0000000000..21b643ce19
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/preprocessor/wide.c
@@ -0,0 +1,15 @@
+#define A(x) L##x
+A('a')
+A("bc")
+/*
+ * check-name: wide char token-pasting
+ * check-description: Used to cause infinite recursion.
+ * check-command: sparse -E $file
+ *
+ * check-output-start
+
+L'a'
+L"bc"
+ * check-output-end
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/prototype.c b/usr/src/tools/smatch/src/validation/prototype.c
new file mode 100644
index 0000000000..c338e1619a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/prototype.c
@@ -0,0 +1,6 @@
+static int prototype(void);
+
+/*
+ * check-name: Compile skip function prototype
+ * check-command: sparsec -c $file -o tmp.o
+ */
diff --git a/usr/src/tools/smatch/src/validation/ptr-inherit.c b/usr/src/tools/smatch/src/validation/ptr-inherit.c
new file mode 100644
index 0000000000..58524a7175
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/ptr-inherit.c
@@ -0,0 +1,80 @@
+#define	__user		__attribute__((address_space(1)))
+#define	__noderef	__attribute__((noderef))
+#define	__bitwise	__attribute__((bitwise))
+#define	__nocast	__attribute__((nocast))
+#define	__safe		__attribute__((safe))
+
+
+/* Should be inherited? */
+static void test_const(void)
+{
+	const int o;
+	int *p = &o;			/* check-should-fail */
+}
+
+static void test_volatile(void)
+{
+	volatile int o;
+	int *p = &o;			/* check-should-fail */
+}
+
+static void test_noderef(void)
+{
+	int __noderef o;
+	int *p = &o;			/* check-should-fail */
+}
+
+static void test_bitwise(void)
+{
+	int __bitwise o;
+	int *p = &o;			/* check-should-fail */
+}
+
+static void test_user(void)
+{
+	int __user o;
+	int *p = &o;			/* check-should-fail */
+}
+
+static void test_nocast(void)
+{
+	int __nocast o;
+	int __nocast *p = &o;		/* check-should-pass */
+}
+
+/* Should be ignored? */
+static void test_static(void)
+{
+	/* storage is not inherited */
+	static int o;
+	int *p = &o;			/* check-should-pass */
+}
+
+static void test_tls(void)
+{
+	/* storage is not inherited */
+	static __thread int o;
+	int *p = &o;			/* check-should-pass */
+}
+
+/*
+ * check-name: ptr-inherit.c
+ *
+ * check-error-start
+ptr-inherit.c:12:19: warning: incorrect type in initializer (different modifiers)
+ptr-inherit.c:12:19:    expected int *p
+ptr-inherit.c:12:19:    got int const *<noident>
+ptr-inherit.c:18:19: warning: incorrect type in initializer (different modifiers)
+ptr-inherit.c:18:19:    expected int *p
+ptr-inherit.c:18:19:    got int volatile *<noident>
+ptr-inherit.c:24:19: warning: incorrect type in initializer (different modifiers)
+ptr-inherit.c:24:19:    expected int *p
+ptr-inherit.c:24:19:    got int [noderef] *<noident>
+ptr-inherit.c:30:19: warning: incorrect type in initializer (different base types)
+ptr-inherit.c:30:19:    expected int *p
+ptr-inherit.c:30:19:    got restricted int *<noident>
+ptr-inherit.c:36:19: warning: incorrect type in initializer (different address spaces)
+ptr-inherit.c:36:19:    expected int *p
+ptr-inherit.c:36:19:    got int <asn:1>*<noident>
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/pure-function.c b/usr/src/tools/smatch/src/validation/pure-function.c
new file mode 100644
index 0000000000..04bb85e4db
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/pure-function.c
@@ -0,0 +1,16 @@
+
+static __attribute__((__pure__)) int pure1(void)
+{
+	int i = 0;
+	return i;
+}
+
+static __attribute__((__pure__)) void *pure2(void)
+{
+    void *i = (void *)0;
+    return i;
+}
+
+/*
+ * check-name: Pure function attribute
+ */
diff --git a/usr/src/tools/smatch/src/validation/reserved.c b/usr/src/tools/smatch/src/validation/reserved.c
new file mode 100644
index 0000000000..29554560b2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/reserved.c
@@ -0,0 +1,158 @@
+static int (auto);
+static int (break);
+static int (case);
+static int (char);
+static int (const);
+static int (__const);
+static int (__const__);
+static int (continue);
+static int (default);
+static int (do);
+static int (double);
+static int (else);
+static int (enum);
+static int (extern);
+static int (float);
+static int (for);
+static int (goto);
+static int (if);
+static int (inline);
+static int (__inline);
+static int (__inline__);
+static int (int);
+static int (long);
+static int (register);
+static int (restrict);
+static int (__restrict);
+static int (__restrict__);
+static int (return);
+static int (short);
+static int (signed);
+static int (sizeof);
+static int (static);
+static int (struct);
+static int (switch);
+static int (typedef);
+static int (union);
+static int (unsigned);
+static int (void);
+static int (volatile);
+static int (volatile);
+static int (__volatile);
+static int (__volatile__);
+static int (while);
+
+static int (_Alignas);
+static int (_Alignof);
+static int (_Atomic);
+static int (_Bool);
+static int (_Complex);
+static int (_Generic);
+static int (_Imaginary);
+static int (_Noreturn);
+static int (_Static_assert);
+static int (_Thread_local);
+
+// Sparse extensions
+static int (__context__);
+static int (__range__);
+static int (__sizeof_ptr__);
+
+// GCC extensions
+static int (__alignof);
+static int (__alignof__);
+static int (asm);			// not reserved!
+static int (__asm);
+static int (__asm__);
+static int (__label__);
+static int (__thread);
+static int (typeof);
+static int (__typeof);
+static int (__typeof__);
+
+static int (__int128);
+static int (__int128_t);
+static int (__uint128_t);
+
+static int (__builtin_ms_va_list);
+static int (__builtin_offsetof);
+static int (__builtin_types_compatible_p);
+static int (__builtin_va_list);
+
+/*
+ * check-name: const et.al. are reserved identifiers
+ * check-error-start:
+reserved.c:1:12: error: Trying to use reserved word 'auto' as identifier
+reserved.c:2:12: error: Trying to use reserved word 'break' as identifier
+reserved.c:3:12: error: Trying to use reserved word 'case' as identifier
+reserved.c:4:12: error: Trying to use reserved word 'char' as identifier
+reserved.c:5:12: error: Trying to use reserved word 'const' as identifier
+reserved.c:6:12: error: Trying to use reserved word '__const' as identifier
+reserved.c:7:12: error: Trying to use reserved word '__const__' as identifier
+reserved.c:8:12: error: Trying to use reserved word 'continue' as identifier
+reserved.c:9:12: error: Trying to use reserved word 'default' as identifier
+reserved.c:10:12: error: Trying to use reserved word 'do' as identifier
+reserved.c:11:12: error: Trying to use reserved word 'double' as identifier
+reserved.c:12:12: error: Trying to use reserved word 'else' as identifier
+reserved.c:13:12: error: Trying to use reserved word 'enum' as identifier
+reserved.c:14:12: error: Trying to use reserved word 'extern' as identifier
+reserved.c:15:12: error: Trying to use reserved word 'float' as identifier
+reserved.c:16:12: error: Trying to use reserved word 'for' as identifier
+reserved.c:17:12: error: Trying to use reserved word 'goto' as identifier
+reserved.c:18:12: error: Trying to use reserved word 'if' as identifier
+reserved.c:19:12: error: Trying to use reserved word 'inline' as identifier
+reserved.c:20:12: error: Trying to use reserved word '__inline' as identifier
+reserved.c:21:12: error: Trying to use reserved word '__inline__' as identifier
+reserved.c:22:12: error: Trying to use reserved word 'int' as identifier
+reserved.c:23:12: error: Trying to use reserved word 'long' as identifier
+reserved.c:24:12: error: Trying to use reserved word 'register' as identifier
+reserved.c:25:12: error: Trying to use reserved word 'restrict' as identifier
+reserved.c:26:12: error: Trying to use reserved word '__restrict' as identifier
+reserved.c:27:12: error: Trying to use reserved word '__restrict__' as identifier
+reserved.c:28:12: error: Trying to use reserved word 'return' as identifier
+reserved.c:29:12: error: Trying to use reserved word 'short' as identifier
+reserved.c:30:12: error: Trying to use reserved word 'signed' as identifier
+reserved.c:31:12: error: Trying to use reserved word 'sizeof' as identifier
+reserved.c:32:12: error: Trying to use reserved word 'static' as identifier
+reserved.c:33:12: error: Trying to use reserved word 'struct' as identifier
+reserved.c:34:12: error: Trying to use reserved word 'switch' as identifier
+reserved.c:35:12: error: Trying to use reserved word 'typedef' as identifier
+reserved.c:36:12: error: Trying to use reserved word 'union' as identifier
+reserved.c:37:12: error: Trying to use reserved word 'unsigned' as identifier
+reserved.c:38:12: error: Trying to use reserved word 'void' as identifier
+reserved.c:39:12: error: Trying to use reserved word 'volatile' as identifier
+reserved.c:40:12: error: Trying to use reserved word 'volatile' as identifier
+reserved.c:41:12: error: Trying to use reserved word '__volatile' as identifier
+reserved.c:42:12: error: Trying to use reserved word '__volatile__' as identifier
+reserved.c:43:12: error: Trying to use reserved word 'while' as identifier
+reserved.c:45:12: error: Trying to use reserved word '_Alignas' as identifier
+reserved.c:46:12: error: Trying to use reserved word '_Alignof' as identifier
+reserved.c:47:12: error: Trying to use reserved word '_Atomic' as identifier
+reserved.c:48:12: error: Trying to use reserved word '_Bool' as identifier
+reserved.c:49:12: error: Trying to use reserved word '_Complex' as identifier
+reserved.c:50:12: error: Trying to use reserved word '_Generic' as identifier
+reserved.c:51:12: error: Trying to use reserved word '_Imaginary' as identifier
+reserved.c:52:12: error: Trying to use reserved word '_Noreturn' as identifier
+reserved.c:53:12: error: Trying to use reserved word '_Static_assert' as identifier
+reserved.c:54:12: error: Trying to use reserved word '_Thread_local' as identifier
+reserved.c:57:12: error: Trying to use reserved word '__context__' as identifier
+reserved.c:58:12: error: Trying to use reserved word '__range__' as identifier
+reserved.c:59:12: error: Trying to use reserved word '__sizeof_ptr__' as identifier
+reserved.c:62:12: error: Trying to use reserved word '__alignof' as identifier
+reserved.c:63:12: error: Trying to use reserved word '__alignof__' as identifier
+reserved.c:65:12: error: Trying to use reserved word '__asm' as identifier
+reserved.c:66:12: error: Trying to use reserved word '__asm__' as identifier
+reserved.c:67:12: error: Trying to use reserved word '__label__' as identifier
+reserved.c:68:12: error: Trying to use reserved word '__thread' as identifier
+reserved.c:69:12: error: Trying to use reserved word 'typeof' as identifier
+reserved.c:70:12: error: Trying to use reserved word '__typeof' as identifier
+reserved.c:71:12: error: Trying to use reserved word '__typeof__' as identifier
+reserved.c:73:12: error: Trying to use reserved word '__int128' as identifier
+reserved.c:74:12: error: Trying to use reserved word '__int128_t' as identifier
+reserved.c:75:12: error: Trying to use reserved word '__uint128_t' as identifier
+reserved.c:77:12: error: Trying to use reserved word '__builtin_ms_va_list' as identifier
+reserved.c:78:12: error: Trying to use reserved word '__builtin_offsetof' as identifier
+reserved.c:79:12: error: Trying to use reserved word '__builtin_types_compatible_p' as identifier
+reserved.c:80:12: error: Trying to use reserved word '__builtin_va_list' as identifier
+ * check-error-end:
+ */
diff --git a/usr/src/tools/smatch/src/validation/restrict-array.c b/usr/src/tools/smatch/src/validation/restrict-array.c
new file mode 100644
index 0000000000..04bfdad9d5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/restrict-array.c
@@ -0,0 +1,37 @@
+#define __restrict_arr __restrict
+
+struct aiocb64;
+struct sigevent;
+
+extern int lio_listio64 (int __mode,
+			 struct aiocb64 *__const __list[__restrict_arr],
+			 int __nent, struct sigevent *__restrict __sig);
+
+#undef __restrict_arr
+#define __restrict_arr __restrict__
+
+struct gaicb;
+
+extern int getaddrinfo_a (int __mode, struct gaicb *__list[__restrict_arr],
+			  int __ent, struct sigevent *__restrict __sig);
+
+#undef __restrict_arr
+#define __restrict_arr restrict
+
+typedef struct re_pattern_buffer regex_t;
+typedef int regoff_t;
+typedef struct
+{
+  regoff_t rm_so;  /* Byte offset from string's start to substring's start.  */
+  regoff_t rm_eo;  /* Byte offset from string's start to substring's end.  */
+} regmatch_t;
+typedef unsigned long int size_t;
+
+extern int regexec (const regex_t *__restrict __preg,
+		    const char *__restrict __string, size_t __nmatch,
+		    regmatch_t __pmatch[__restrict_arr],
+		    int __eflags);
+
+/*
+ * check-name: restrict array attribute
+ */
diff --git a/usr/src/tools/smatch/src/validation/restricted-typeof.c b/usr/src/tools/smatch/src/validation/restricted-typeof.c
new file mode 100644
index 0000000000..1592664553
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/restricted-typeof.c
@@ -0,0 +1,8 @@
+typedef unsigned __attribute__((bitwise)) A;
+static A x;
+static __typeof__(x) y;
+static A *p = &y;
+/*
+ * check-name: typeof with bitwise types
+ * check-command: sparse -Wbitwise $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/sizeof-bool.c b/usr/src/tools/smatch/src/validation/sizeof-bool.c
new file mode 100644
index 0000000000..05e76a44e8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sizeof-bool.c
@@ -0,0 +1,13 @@
+static int a(void)
+{
+	return sizeof(_Bool);
+}
+/*
+ * check-name: sizeof(_Bool) is valid
+ * check-description: sizeof(_Bool) was rejected because _Bool is not an even
+ * number of bytes
+ * check-command: sparse -Wsizeof-bool $file
+ * check-error-start
+sizeof-bool.c:3:16: warning: expression using sizeof bool
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sizeof-compound-postfix.c b/usr/src/tools/smatch/src/validation/sizeof-compound-postfix.c
new file mode 100644
index 0000000000..3b716feda6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sizeof-compound-postfix.c
@@ -0,0 +1,8 @@
+struct foo {int x, y;};
+static int a(void)
+{
+	return sizeof (struct foo){0,1}.y;
+}
+/*
+ * check-name: Handling of sizeof compound-literal . member
+ */
diff --git a/usr/src/tools/smatch/src/validation/sizeof-void.c b/usr/src/tools/smatch/src/validation/sizeof-void.c
new file mode 100644
index 0000000000..0fd917a21f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sizeof-void.c
@@ -0,0 +1,44 @@
+#define is_constexpr(x) \
+	(sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8)))
+
+static int test(void)
+{
+	unsigned int s = 0, i = 0;
+	void *ptr = &i;
+
+	// OK
+	s += sizeof i;
+	s += sizeof &i;
+	s += sizeof ptr;
+	s += sizeof &ptr;
+
+	// KO
+	s += sizeof(void);
+	s += sizeof *ptr;
+	s += is_constexpr(ptr++);
+	s += is_constexpr((i++, 1));
+	s += is_constexpr(sizeof *ptr);
+	s += is_constexpr(ptr + 1);
+	s += is_constexpr(&ptr + 1);
+	s += is_constexpr(*(((char *)&ptr) + 1));
+
+	return s;
+}
+
+/*
+ * check-name: sizeof(void) is valid
+ * check-description: sizeof(void) was rejected because void is an incomplete
+ * type
+ * check-command: sparse -Wpointer-arith $file
+ *
+ * check-error-start
+sizeof-void.c:16:14: warning: expression using sizeof(void)
+sizeof-void.c:17:14: warning: expression using sizeof(void)
+sizeof-void.c:18:14: warning: expression using sizeof(void)
+sizeof-void.c:19:14: warning: expression using sizeof(void)
+sizeof-void.c:20:14: warning: expression using sizeof(void)
+sizeof-void.c:21:14: warning: expression using sizeof(void)
+sizeof-void.c:22:14: warning: expression using sizeof(void)
+sizeof-void.c:23:14: warning: expression using sizeof(void)
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_WtoA.c b/usr/src/tools/smatch/src/validation/sm_WtoA.c
new file mode 100644
index 0000000000..62bfc51b67
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_WtoA.c
@@ -0,0 +1,29 @@
+void wwww();
+void wwwA();
+
+void xxxW (void)
+{
+	wwwA();
+	www();
+}
+
+void DRAW (void)
+{
+	wwwA();
+}
+
+void xxxA (void)
+{
+	wwwA();
+	www();
+}
+
+
+/*
+ * check-name: Cross calls WtoA
+ * check-command: smatch -p=wine sm_WtoA.c
+ *
+ * check-output-start
+sm_WtoA.c:6 xxxW() warn: WtoA call 'wwwA()'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_absolute1.c b/usr/src/tools/smatch/src/validation/sm_absolute1.c
new file mode 100644
index 0000000000..527a68bb02
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_absolute1.c
@@ -0,0 +1,20 @@
+#include "check_debug.h"
+
+char x;
+int y;
+int func(void)
+{
+	y = x;
+	__smatch_absolute_min(y);
+	__smatch_absolute_max(y);
+}
+
+/*
+ * check-name: smatch: absolute #1
+ * check-command: smatch -I.. sm_absolute1.c
+ *
+ * check-output-start
+sm_absolute1.c:8 func() absolute min: y = (-128)
+sm_absolute1.c:9 func() absolute max: y = 127
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_absolute2.c b/usr/src/tools/smatch/src/validation/sm_absolute2.c
new file mode 100644
index 0000000000..006b4f9c68
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_absolute2.c
@@ -0,0 +1,34 @@
+#include "check_debug.h"
+
+static int my_var;
+
+int x;
+int func(int *p)
+{
+	unsigned int a = -1;
+
+	x = a;
+	__smatch_absolute_min(a);
+	__smatch_absolute_max(a);
+	__smatch_absolute_min(x);
+	__smatch_absolute_max(x);
+	__smatch_implied(a);
+	__smatch_implied(x);
+	__smatch_sval_info(a);
+	__smatch_sval_info(x);
+}
+/*
+ * check-name: smatch: absolute #2
+ * check-command: smatch -I.. sm_absolute2.c
+ *
+ * check-output-start
+sm_absolute2.c:11 func() absolute min: a = u32max
+sm_absolute2.c:12 func() absolute max: a = u32max
+sm_absolute2.c:13 func() absolute min: x = (-1)
+sm_absolute2.c:14 func() absolute max: x = (-1)
+sm_absolute2.c:15 func() implied: a = 'u32max'
+sm_absolute2.c:16 func() implied: x = '(-1)'
+sm_absolute2.c:17 func() implied: a u32 ->value = ffffffff
+sm_absolute2.c:18 func() implied: x s32 ->value = ffffffffffffffff
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_array_overflow.c b/usr/src/tools/smatch/src/validation/sm_array_overflow.c
new file mode 100644
index 0000000000..ad73ec669d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_array_overflow.c
@@ -0,0 +1,50 @@
+int a[] = {1, 2, 3, 4};
+char *b = "abc";
+char c[4];
+char d[4] = "";
+
+int x;
+static int options_write(void)
+{
+	int i;
+	char *str = b;
+	char *str2 = "123";
+	char *str3;
+	char *str4;
+	char *str5;
+	unsigned int j = 4;
+
+	str3 = str2;
+	str4 = str;
+	if (x)
+		str5 = "asdf";
+	else
+		str5 = "aa";
+
+	for (i = 0; i < 4 && frob(); i++)
+		;
+	a[i] = 42;
+	b[i] = '\0';
+	c[i] = '\0';
+	str[j] = '\0';
+	str2[j] = '\0';
+	str3[j] = '\0';
+	str4[j] = '\0';
+	str5[j] = '\0';
+	d[j] = '\0';
+}
+/*
+ * check-name: smatch array check
+ * check-command: smatch --spammy sm_array_overflow.c
+ *
+ * check-output-start
+sm_array_overflow.c:26 options_write() error: buffer overflow 'a' 4 <= 4
+sm_array_overflow.c:27 options_write() error: buffer overflow 'b' 4 <= 4
+sm_array_overflow.c:28 options_write() error: buffer overflow 'c' 4 <= 4
+sm_array_overflow.c:29 options_write() error: buffer overflow 'str' 4 <= 4
+sm_array_overflow.c:30 options_write() error: buffer overflow 'str2' 4 <= 4
+sm_array_overflow.c:31 options_write() error: buffer overflow 'str3' 4 <= 4
+sm_array_overflow.c:32 options_write() error: buffer overflow 'str4' 4 <= 4
+sm_array_overflow.c:34 options_write() error: buffer overflow 'd' 4 <= 4
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_array_overflow2.c b/usr/src/tools/smatch/src/validation/sm_array_overflow2.c
new file mode 100644
index 0000000000..6cfcd7092c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_array_overflow2.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
+
+int a[] = {1, 2, 3, 4};
+int b[] = {
+	[3] = 1,
+};
+
+int x;
+int main(void)
+{
+	if (x < ARRAY_SIZE(a))
+		a[x] = 1;
+	if (x < ARRAY_SIZE(b))
+		b[x] = 1;
+	if (x < ARRAY_SIZE(b))
+		b[4] = 1;
+	printf("%d\n", ARRAY_SIZE(b));
+}
+/*
+ * check-name: smatch indexed array check
+ * check-command: smatch sm_array_overflow2.c
+ *
+ * check-output-start
+sm_array_overflow2.c:18 main() error: buffer overflow 'b' 4 <= 4
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_array_overflow3.c b/usr/src/tools/smatch/src/validation/sm_array_overflow3.c
new file mode 100644
index 0000000000..0bc93ac323
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_array_overflow3.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
+
+int a[] = {1, 2, 3, 4};
+
+int main(void)
+{
+	int *p;
+
+	for (p = a; p < &a[ARRAY_SIZE(a)]; p++)
+		printf("%d\n", *p);
+	p = &a[5];
+	return 0;
+}
+/*
+ * check-name: smatch array check #3
+ * check-command: smatch sm_array_overflow3.c
+ *
+ * check-output-start
+sm_array_overflow3.c:13 main() error: buffer overflow 'a' 4 <= 5
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_array_overflow4.c b/usr/src/tools/smatch/src/validation/sm_array_overflow4.c
new file mode 100644
index 0000000000..36966d4fcb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_array_overflow4.c
@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <string.h>
+
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
+
+long long a[] = {1, 2};
+
+int main(char *arg0)
+{
+	short *s = a;
+	short *s2 = (&(a));
+	char buf[4], buf2[4];
+	int i;
+
+	printf("%d\n", s[1]);
+	printf("%d\n", s[2]);
+	printf("%d\n", s[3]);
+	printf("%d\n", s[4]);
+	printf("%d\n", s[5]);
+	printf("%d\n", s[6]);
+	printf("%d\n", s[7]);
+	printf("%d\n", s[8]);
+	printf("%d\n", s2[8]);
+	printf("%d\n", ((short *)a)[6]);
+	printf("%d\n", ((short *)a)[8]);
+	strcpy(buf, "1234");
+	strcpy(buf2, arg0);
+
+	return 0;
+}
+/*
+ * check-name: smatch overflow check #4
+ * check-command: smatch --spammy sm_array_overflow4.c
+ *
+ * check-output-start
+sm_array_overflow4.c:22 main() error: buffer overflow 's' 8 <= 8
+sm_array_overflow4.c:23 main() error: buffer overflow 's2' 8 <= 8
+sm_array_overflow4.c:25 main() error: buffer overflow 'a' 8 <= 8
+sm_array_overflow4.c:26 main() error: strcpy() '"1234"' too large for 'buf' (5 vs 4)
+sm_array_overflow4.c:27 main() warn: strcpy() 'arg0' of unknown size might be too large for 'buf2'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_array_overflow5.c b/usr/src/tools/smatch/src/validation/sm_array_overflow5.c
new file mode 100644
index 0000000000..c81d70a3c5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_array_overflow5.c
@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+void *kmalloc(int size, int mask);
+
+struct foo {
+	int x, y, z;
+	int buf[0];
+};
+
+int main(void)
+{
+	struct foo *p;
+
+	p = kmalloc(sizeof(*p) + 100, 0);
+	if (!p)
+		return -12;
+	__smatch_buf_size(p->buf);
+
+	return 0;
+}
+
+
+/*
+ * check-name: smatch: overflow check #5
+ * check-command: smatch -p=kernel -I.. sm_array_overflow5.c
+ *
+ * check-output-start
+sm_array_overflow5.c:19 main() buf size: 'p->buf' 25 elements, 100 bytes
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_bitwise1.c b/usr/src/tools/smatch/src/validation/sm_bitwise1.c
new file mode 100644
index 0000000000..e36da4b075
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_bitwise1.c
@@ -0,0 +1,22 @@
+#include "check_debug.h"
+
+unsigned int x;
+void test(void)
+{
+	__smatch_implied(x & 0x1);
+	__smatch_implied(x & 0x2);
+	__smatch_implied(x & ~(0xffU));
+	__smatch_implied(x & ~(0xff));
+}
+
+/*
+ * check-name: smatch bitwise #1
+ * check-command: smatch -I.. sm_bitwise1.c
+ *
+ * check-output-start
+sm_bitwise1.c:6 test() implied: x & 1 = '0-1'
+sm_bitwise1.c:7 test() implied: x & 2 = '0,2'
+sm_bitwise1.c:8 test() implied: x & ~(255) = '0,256-4294967040'
+sm_bitwise1.c:9 test() implied: x & ~(255) = '0-4294967040'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_bitwise2.c b/usr/src/tools/smatch/src/validation/sm_bitwise2.c
new file mode 100644
index 0000000000..faa8e3202c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_bitwise2.c
@@ -0,0 +1,22 @@
+#include "check_debug.h"
+
+unsigned int x;
+int y;
+void test(void)
+{
+	if (x & 0x1)
+		__smatch_implied(x);
+	if (y & 0x4)
+		__smatch_implied(y);
+
+}
+
+/*
+ * check-name: smatch bitwise #2
+ * check-command: smatch -I.. sm_bitwise2.c
+ *
+ * check-output-start
+sm_bitwise2.c:8 test() implied: x = '1-u32max'
+sm_bitwise2.c:10 test() implied: y = 's32min-(-1),4-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_buf_size1.c b/usr/src/tools/smatch/src/validation/sm_buf_size1.c
new file mode 100644
index 0000000000..709f5472c4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_buf_size1.c
@@ -0,0 +1,26 @@
+#include "check_debug.h"
+
+void func(void)
+{
+	int a[4];
+	char b[4];
+	char *c = (char *)a;
+	int *d = (int *)b;
+
+	__smatch_buf_size(a);
+	__smatch_buf_size(b);
+	__smatch_buf_size(c);
+	__smatch_buf_size(d);
+}
+
+/*
+ * check-name: smatch buf size #1
+ * check-command: smatch -I.. sm_buf_size1.c
+ *
+ * check-output-start
+sm_buf_size1.c:10 func() buf size: 'a' 4 elements, 16 bytes
+sm_buf_size1.c:11 func() buf size: 'b' 4 elements, 4 bytes
+sm_buf_size1.c:12 func() buf size: 'c' 16 elements, 16 bytes
+sm_buf_size1.c:13 func() buf size: 'd' 1 elements, 4 bytes
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_buf_size2.c b/usr/src/tools/smatch/src/validation/sm_buf_size2.c
new file mode 100644
index 0000000000..1f6a7cd80e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_buf_size2.c
@@ -0,0 +1,28 @@
+#include "check_debug.h"
+
+void *malloc(int);
+
+void func(void)
+{
+	int *a;
+	short *b;
+	long long *c;
+
+	a = malloc(sizeof(int) * 4);
+	b = a;
+	c = b;
+	__smatch_buf_size(a);
+	__smatch_buf_size(b);
+	__smatch_buf_size(c);
+}
+
+/*
+ * check-name: smatch buf size #2
+ * check-command: smatch -I.. sm_buf_size2.c
+ *
+ * check-output-start
+sm_buf_size2.c:14 func() buf size: 'a' 4 elements, 16 bytes
+sm_buf_size2.c:15 func() buf size: 'b' 8 elements, 16 bytes
+sm_buf_size2.c:16 func() buf size: 'c' 2 elements, 16 bytes
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_buf_size3.c b/usr/src/tools/smatch/src/validation/sm_buf_size3.c
new file mode 100644
index 0000000000..4bde6dbea6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_buf_size3.c
@@ -0,0 +1,22 @@
+#include "check_debug.h"
+
+void *malloc(int);
+
+void func(void)
+{
+	char *a;
+
+	a = malloc(sizeof(int) * 4);
+	__smatch_buf_size(a);
+	__smatch_buf_size((int *)a);
+}
+
+/*
+ * check-name: smatch buf size #3
+ * check-command: smatch -I.. sm_buf_size3.c
+ *
+ * check-output-start
+sm_buf_size3.c:10 func() buf size: 'a' 16 elements, 16 bytes
+sm_buf_size3.c:11 func() buf size: 'a' 4 elements, 16 bytes
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_buf_size4.c b/usr/src/tools/smatch/src/validation/sm_buf_size4.c
new file mode 100644
index 0000000000..0df4914d58
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_buf_size4.c
@@ -0,0 +1,24 @@
+#include "check_debug.h"
+
+long long a[] = {1, 2};
+int b[] = {3, 4};
+
+int main(char *arg0)
+{
+	short *s = a;
+
+	__smatch_buf_size(a);
+	__smatch_buf_size(b);
+	__smatch_buf_size(s);
+	return 0;
+}
+/*
+ * check-name: smatch buf size #4
+ * check-command: smatch -I.. sm_buf_size4.c
+ *
+ * check-output-start
+sm_buf_size4.c:10 main() buf size: 'a' 2 elements, 16 bytes
+sm_buf_size4.c:11 main() buf size: 'b' 2 elements, 8 bytes
+sm_buf_size4.c:12 main() buf size: 's' 8 elements, 16 bytes
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_buf_size5.c b/usr/src/tools/smatch/src/validation/sm_buf_size5.c
new file mode 100644
index 0000000000..0c138f5050
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_buf_size5.c
@@ -0,0 +1,29 @@
+#include "check_debug.h"
+
+struct foo {
+	char buf[42];
+	int x[4];
+};
+
+int function(void)
+{
+	struct foo foo;
+
+	__smatch_buf_size(&foo);
+	__smatch_buf_size(&(foo.buf[0]));
+	__smatch_buf_size(&foo.x[0]);
+	__smatch_buf_size(&foo.x[1]);
+
+	return 0;
+}
+/*
+ * check-name: smatch buf size #5
+ * check-command: smatch --spammy -I.. sm_buf_size5.c
+ *
+ * check-output-start
+sm_buf_size5.c:12 function() buf size: '&foo' 1 elements, 60 bytes
+sm_buf_size5.c:13 function() buf size: '&(foo.buf[0])' 42 elements, 42 bytes
+sm_buf_size5.c:14 function() buf size: '&foo.x[0]' 4 elements, 16 bytes
+sm_buf_size5.c:15 function() buf size: '&foo.x[1]' 3 elements, 12 bytes
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_buf_size6.c b/usr/src/tools/smatch/src/validation/sm_buf_size6.c
new file mode 100644
index 0000000000..e5f7074b0b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_buf_size6.c
@@ -0,0 +1,31 @@
+#include "check_debug.h"
+
+void *malloc(int size);
+
+int function(void)
+{
+	int *p;
+	int array[1000];
+
+	p = malloc(4000);
+
+	__smatch_buf_size(p);
+	__smatch_buf_size(&p[0]);
+	__smatch_buf_size(array);
+	__smatch_buf_size(&array);
+	__smatch_buf_size(&array[0]);
+
+	return 0;
+}
+/*
+ * check-name: smatch buf size #6
+ * check-command: smatch --spammy -I.. sm_buf_size6.c
+ *
+ * check-output-start
+sm_buf_size6.c:12 function() buf size: 'p' 1000 elements, 4000 bytes
+sm_buf_size6.c:13 function() buf size: '&p[0]' 1000 elements, 4000 bytes
+sm_buf_size6.c:14 function() buf size: 'array' 1000 elements, 4000 bytes
+sm_buf_size6.c:15 function() buf size: '&array' 1000 elements, 4000 bytes
+sm_buf_size6.c:16 function() buf size: '&array[0]' 1000 elements, 4000 bytes
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_buf_size7.c b/usr/src/tools/smatch/src/validation/sm_buf_size7.c
new file mode 100644
index 0000000000..e65aed28c8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_buf_size7.c
@@ -0,0 +1,26 @@
+#include "check_debug.h"
+
+int test(void)
+{
+	int a[] = { [1] = 2 };
+	int b[] = { 1, 2, 3 };
+	int c[] = { 0, [0] = 1, 2, 3};
+	int d[] = { 0, [3] = 4, 5};
+
+	__smatch_buf_size(a);
+	__smatch_buf_size(b);
+	__smatch_buf_size(c);
+	__smatch_buf_size(d);
+}
+
+/*
+ * check-name: smatch buf size #7
+ * check-command: smatch -I.. sm_buf_size7.c
+ *
+ * check-output-start
+sm_buf_size7.c:10 test() buf size: 'a' 2 elements, 8 bytes
+sm_buf_size7.c:11 test() buf size: 'b' 3 elements, 12 bytes
+sm_buf_size7.c:12 test() buf size: 'c' 3 elements, 12 bytes
+sm_buf_size7.c:13 test() buf size: 'd' 5 elements, 20 bytes
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_buf_size8.c b/usr/src/tools/smatch/src/validation/sm_buf_size8.c
new file mode 100644
index 0000000000..f6b85e17b9
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_buf_size8.c
@@ -0,0 +1,56 @@
+#include <stdlib.h>
+#include "check_debug.h"
+
+struct foo {
+	int x, y, z;
+	int count;
+	char msg[0];
+};
+
+struct bar {
+	int x, y, z;
+	int count;
+	char msg[1];
+};
+
+struct outer1 {
+	int x, y, z;
+	struct foo foo;
+};
+
+struct outer2 {
+	int x, y, z;
+	struct bar bar;
+};
+
+int test(void)
+{
+	struct foo *p;
+	struct bar *q;
+	struct outer1 *a;
+	struct outer2 *b;
+
+	p = malloc(sizeof(*p) + 100);
+	__smatch_buf_size(p->msg);
+
+	q = malloc(sizeof(*q) + 100);
+	__smatch_buf_size(q->msg);
+
+	a = malloc(sizeof(*a) + 100);
+	__smatch_buf_size(a->foo);
+
+	b = malloc(sizeof(*b) + 100);
+	__smatch_buf_size(b->bar);
+}
+
+/*
+ * check-name: smatch buf size #8
+ * check-command: smatch -I.. sm_buf_size8.c
+ *
+ * check-output-start
+sm_buf_size8.c:34 test() buf size: 'p->msg' 100 elements, 100 bytes
+sm_buf_size8.c:37 test() buf size: 'q->msg' 101 elements, 101 bytes
+sm_buf_size8.c:40 test() buf size: 'a->foo' 0 elements, 116 bytes
+sm_buf_size8.c:43 test() buf size: 'b->bar' 0 elements, 120 bytes
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_casts.c b/usr/src/tools/smatch/src/validation/sm_casts.c
new file mode 100644
index 0000000000..3e712c0060
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_casts.c
@@ -0,0 +1,35 @@
+void frob(void);
+
+char c;
+static int options_write(void)
+{
+	char a;
+	unsigned char b;
+
+	a = (char)0xff;
+	a = 0xff;
+	(char)b = 0xff;
+	b = 0xff;
+	if (c > -400)
+		frob();
+	if (c < -400)
+		frob();
+	if (400 > c)
+		frob();
+	if (-400 > c)
+		frob();
+	b = -12;
+
+}
+/*
+ * check-name: smatch cast handling
+ * check-command: smatch sm_casts.c
+ *
+ * check-output-start
+sm_casts.c:13 options_write() warn: always true condition '(c > -400) => ((-128)-127 > (-400))'
+sm_casts.c:15 options_write() warn: impossible condition '(c < -400) => ((-128)-127 < (-400))'
+sm_casts.c:17 options_write() warn: always true condition '(400 > c) => (400 > (-128)-127)'
+sm_casts.c:19 options_write() warn: impossible condition '(-400 > c) => ((-400) > (-128)-127)'
+sm_casts.c:21 options_write() warn: assigning (-12) to unsigned variable 'b'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_casts2.c b/usr/src/tools/smatch/src/validation/sm_casts2.c
new file mode 100644
index 0000000000..d3057c1530
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_casts2.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+
+unsigned int frob();
+
+unsigned char *a;
+unsigned int *b;
+int *c;
+unsigned char *****d;
+int main(void)
+{
+
+	if (*a == (unsigned int)-1)
+		frob();
+	if (*b == (unsigned int)-1)
+		frob();
+	if (*c == (unsigned int)-1)
+		frob();
+	if (*d == (unsigned int)-1)
+		frob();
+	if (*d == -1)
+		frob();
+	if (*****d == (unsigned int)-1)
+		frob();
+	return 0;
+}
+/*
+ * check-name: smatch casts pointers
+ * check-command: smatch sm_casts2.c
+ *
+ * check-output-start
+sm_casts2.c:12 main() warn: impossible condition '(*a == -1) => (0-255 == u32max)'
+sm_casts2.c:22 main() warn: impossible condition '(*****d == -1) => (0-255 == u32max)'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_casts3.c b/usr/src/tools/smatch/src/validation/sm_casts3.c
new file mode 100644
index 0000000000..fa42bb14b5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_casts3.c
@@ -0,0 +1,20 @@
+#include "check_debug.h"
+
+unsigned int a;
+int b;
+int func(void)
+{
+	b = a;
+	__smatch_implied(a);
+	__smatch_implied(b);
+}
+
+/*
+ * check-name: smatch: casts #3
+ * check-command: smatch -I.. sm_casts3.c
+ *
+ * check-output-start
+sm_casts3.c:8 func() implied: a = ''
+sm_casts3.c:9 func() implied: b = 's32min-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_casts4.c b/usr/src/tools/smatch/src/validation/sm_casts4.c
new file mode 100644
index 0000000000..a1d6c1bd78
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_casts4.c
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+long long l;
+unsigned long long ul;
+int i;
+unsigned int ui;
+signed char c;
+unsigned char uc;
+
+int main(void)
+{
+	int idx;
+
+	if (c < -2)
+		return 1;
+	if (uc < -2)
+		return 1;
+	if (i < -2)
+		return 1;
+	if (ui < -2)
+		return 1;
+	if (l < -2)
+		return 1;
+	if (ul < -2)
+		return 1;
+
+	__smatch_implied(l);
+	__smatch_implied(ul);
+	__smatch_implied(i);
+	__smatch_implied(ui);
+	__smatch_implied(c);
+	__smatch_implied(uc);
+
+	return 0;
+}
+
+
+/*
+ * check-name: smatch: casts #4
+ * check-command: smatch -I.. sm_casts4.c
+ *
+ * check-output-start
+sm_casts4.c:18 main() warn: impossible condition '(uc < -2) => (0-255 < (-2))'
+sm_casts4.c:29 main() implied: l = '(-2)-s64max'
+sm_casts4.c:30 main() implied: ul = '18446744073709551614-u64max'
+sm_casts4.c:31 main() implied: i = '(-2)-s32max'
+sm_casts4.c:32 main() implied: ui = '4294967294-u32max'
+sm_casts4.c:33 main() implied: c = '(-2)-127'
+sm_casts4.c:34 main() implied: uc = ''
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_casts5.c b/usr/src/tools/smatch/src/validation/sm_casts5.c
new file mode 100644
index 0000000000..e3c96d6652
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_casts5.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+long long l;
+long long ul;
+int i;
+int ui;
+signed char c;
+char uc;
+
+int main(void)
+{
+	int idx;
+
+	if (c < -2)
+		return 1;
+	if (uc < (unsigned int)-2)
+		return 1;
+	if (i < -2)
+		return 1;
+	if (ui < (unsigned int)-2)
+		return 1;
+	if (l < -2)
+		return 1;
+	if (ul < (unsigned int)-2)
+		return 1;
+
+	__smatch_implied(l);
+	__smatch_implied(ul);
+	__smatch_implied(i);
+	__smatch_implied(ui);
+	__smatch_implied(c);
+	__smatch_implied(uc);
+
+	return 0;
+}
+
+
+/*
+ * check-name: smatch: casts #5
+ * check-command: smatch -I.. sm_casts5.c
+ *
+ * check-output-start
+sm_casts5.c:29 main() implied: l = '(-2)-s64max'
+sm_casts5.c:30 main() implied: ul = '4294967294-s64max'
+sm_casts5.c:31 main() implied: i = '(-2)-s32max'
+sm_casts5.c:32 main() implied: ui = '(-2)-(-1)'
+sm_casts5.c:33 main() implied: c = '(-2)-127'
+sm_casts5.c:34 main() implied: uc = '(-2)-(-1)'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_casts6.c b/usr/src/tools/smatch/src/validation/sm_casts6.c
new file mode 100644
index 0000000000..56b451f228
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_casts6.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+long long l;
+long long ul;
+int i;
+int ui;
+signed char c;
+char uc;
+
+int main(void)
+{
+	int idx;
+
+	if (c < 2)
+		return 1;
+	if (uc < (unsigned int)2)
+		return 1;
+	if (i < 2)
+		return 1;
+	if (ui < (unsigned int)2)
+		return 1;
+	if (l < 2)
+		return 1;
+	if (ul < (unsigned int)2)
+		return 1;
+
+	__smatch_implied(l);
+	__smatch_implied(ul);
+	__smatch_implied(i);
+	__smatch_implied(ui);
+	__smatch_implied(c);
+	__smatch_implied(uc);
+
+	return 0;
+}
+
+
+/*
+ * check-name: smatch: casts #6
+ * check-command: smatch -I.. sm_casts6.c
+ *
+ * check-output-start
+sm_casts6.c:29 main() implied: l = '2-s64max'
+sm_casts6.c:30 main() implied: ul = '2-s64max'
+sm_casts6.c:31 main() implied: i = '2-s32max'
+sm_casts6.c:32 main() implied: ui = 's32min-(-1),2-s32max'
+sm_casts6.c:33 main() implied: c = '2-127'
+sm_casts6.c:34 main() implied: uc = '(-128)-(-1),2-127'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_casts7.c b/usr/src/tools/smatch/src/validation/sm_casts7.c
new file mode 100644
index 0000000000..674d023aff
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_casts7.c
@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+int a;
+int x;
+
+int main(void)
+{
+	a = (unsigned short)x;
+	__smatch_implied(a);
+
+	return 0;
+}
+
+
+/*
+ * check-name: smatch: casts #7
+ * check-command: smatch -I.. sm_casts7.c
+ *
+ * check-output-start
+sm_casts7.c:11 main() implied: a = '0-u16max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_check_kunmap.c b/usr/src/tools/smatch/src/validation/sm_check_kunmap.c
new file mode 100644
index 0000000000..871f30c689
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_check_kunmap.c
@@ -0,0 +1,30 @@
+void something();
+
+int kmap(int p);
+int kunmap(int p);
+int kmap_atomic(int p);
+int kunmap_atomic(int p);
+
+int page;
+int x;
+int y;
+int z;
+
+void func(void)
+{
+	x = kmap(page);
+	kunmap(page);
+	kunmap(x);
+	y = kmap_atomic(z);
+	kunmap_atomic(y);
+	kunmap_atomic(z);
+}
+/*
+ * check-name: smatch check kunmap
+ * check-command: smatch -p=kernel sm_check_kunmap.c
+ *
+ * check-output-start
+sm_check_kunmap.c:17 func() warn: passing the wrong variable to kunmap()
+sm_check_kunmap.c:20 func() warn: passing the wrong variable to kmap_atomic()
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_chunk1.c b/usr/src/tools/smatch/src/validation/sm_chunk1.c
new file mode 100644
index 0000000000..3302c78df8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_chunk1.c
@@ -0,0 +1,22 @@
+#include "check_debug.h"
+
+static void perf_calculate_period(unsigned long nsec, unsigned long count)
+{
+	if (nsec + count > 64)
+		return;
+
+	__smatch_implied(nsec + count);
+	nsec = 100;
+	__smatch_implied(nsec + count);
+}
+
+
+/*
+ * check-name: smatch chunk #1
+ * check-command: smatch -I.. sm_chunk1.c
+ *
+ * check-output-start
+sm_chunk1.c:8 perf_calculate_period() implied: nsec + count = '0-64'
+sm_chunk1.c:10 perf_calculate_period() implied: nsec + count = ''
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_chunk2.c b/usr/src/tools/smatch/src/validation/sm_chunk2.c
new file mode 100644
index 0000000000..cb998ecf65
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_chunk2.c
@@ -0,0 +1,41 @@
+#include "check_debug.h"
+
+void initialize(void *p);
+
+int main(int x)
+{
+	unsigned int aaa[10];
+	int y, z;
+
+	initialize(&aaa);
+	initialize(&y);
+	initialize(&z);
+
+	if (aaa[5] > 3)
+		return 0;
+	aaa[0] = 42;
+	__smatch_implied(aaa[0]);
+	__smatch_implied(aaa[5]);
+	aaa[y] = 10;
+	__smatch_implied(aaa[5]);
+	if (aaa[z] > 4)
+		return 0;
+	__smatch_implied(aaa[z]);
+	z = 3;
+	__smatch_implied(aaa[z]);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch chunk #2
+ * check-command: smatch -I.. sm_chunk2.c
+ *
+ * check-output-start
+sm_chunk2.c:17 main() implied: aaa[0] = '42'
+sm_chunk2.c:18 main() implied: aaa[5] = '0-3'
+sm_chunk2.c:20 main() implied: aaa[5] = '0-u32max'
+sm_chunk2.c:23 main() implied: aaa[z] = '0-4'
+sm_chunk2.c:25 main() implied: aaa[z] = '0-u32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare.c b/usr/src/tools/smatch/src/validation/sm_compare.c
new file mode 100644
index 0000000000..6f252ceeb8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare.c
@@ -0,0 +1,41 @@
+#include "check_debug.h"
+
+int a, b, c;
+
+static int frob(void)
+{
+	if (a > 5)
+		return;
+	if (b > 5)
+		return;
+	if (c != 5)
+		return;
+
+	if (a == 10)
+		__smatch_value("a");
+	if (b != 10)
+		__smatch_value("b");
+	if (c != 5)
+		__smatch_value("c");
+	if (5 != c)
+		__smatch_value("c");
+
+	__smatch_value("a");
+	__smatch_value("b");
+	__smatch_value("c");
+}
+
+/*
+ * check-name: Smatch Comparison
+ * check-command: smatch -I.. sm_compare.c
+ *
+ * check-output-start
+sm_compare.c:15 frob() a = empty
+sm_compare.c:17 frob() b = s32min-5
+sm_compare.c:19 frob() c = empty
+sm_compare.c:21 frob() c = empty
+sm_compare.c:23 frob() a = s32min-5
+sm_compare.c:24 frob() b = s32min-5
+sm_compare.c:25 frob() c = 5
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare10.c b/usr/src/tools/smatch/src/validation/sm_compare10.c
new file mode 100644
index 0000000000..410e16cd78
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare10.c
@@ -0,0 +1,20 @@
+#include "check_debug.h"
+
+int a, b, c;
+static int options_write(void)
+{
+	if (c <= b)
+		return;
+	if (a >= b)
+		return;
+	__smatch_compare(a, c);
+}
+
+/*
+ * check-name: smatch compare #10
+ * check-command: smatch -I.. sm_compare10.c
+ *
+ * check-output-start
+sm_compare10.c:10 options_write() a < c
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare11.c b/usr/src/tools/smatch/src/validation/sm_compare11.c
new file mode 100644
index 0000000000..8967f31555
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare11.c
@@ -0,0 +1,26 @@
+#include "check_debug.h"
+
+int frob();
+
+static int options_write(void)
+{
+	int a = frob();
+	int b = frob();
+	int c = frob();
+	int d = frob();
+
+	a = d;
+	if (a > b + c) {
+		a = b + c;
+	}
+	__smatch_compare(a, d);
+}
+
+/*
+ * check-name: smatch compare #11
+ * check-command: smatch -I.. sm_compare11.c
+ *
+ * check-output-start
+sm_compare11.c:16 options_write() a <= d
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare12.c b/usr/src/tools/smatch/src/validation/sm_compare12.c
new file mode 100644
index 0000000000..39723dacdc
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare12.c
@@ -0,0 +1,38 @@
+#include "check_debug.h"
+
+#define min_t(type, x, y) ({			\
+	type __min1 = (x);			\
+	type __min2 = (y);			\
+	__min1 < __min2 ? __min1: __min2; })
+
+int frob();
+
+static int options_write(void)
+{
+	int a = frob();
+	int b = frob();
+	int c = frob();
+	int d = frob();
+
+	a = min_t(int, b + c, d);
+	__smatch_compare(a, d);
+	__smatch_compare(a, b + c);
+	b++;
+	__smatch_compare(a, b + c);
+	a++;  /* argh...  really one increment should mean a <= b + c */
+	a++;
+	__smatch_compare(a, b + c);
+
+}
+
+/*
+ * check-name: smatch compare #12
+ * check-command: smatch -I.. sm_compare12.c
+ *
+ * check-output-start
+sm_compare12.c:18 options_write() a <= d
+sm_compare12.c:19 options_write() a <= b + c
+sm_compare12.c:21 options_write() a < b + c
+sm_compare12.c:24 options_write() a <none> b + c
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare13.c b/usr/src/tools/smatch/src/validation/sm_compare13.c
new file mode 100644
index 0000000000..150ef2c96e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare13.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+int cmp_x(int x, int y)
+{
+	if (x < y) {
+		__smatch_compare(x, y);
+		return -1;
+	}
+	if (x == y) {
+		__smatch_compare(x, y);
+		return 0;
+	}
+	__smatch_compare(x, y);
+	return 1;
+}
+
+/*
+ * check-name: smatch compare #13
+ * check-command: smatch -I.. sm_compare13.c
+ *
+ * check-output-start
+sm_compare13.c:8 cmp_x() x < y
+sm_compare13.c:12 cmp_x() x == y
+sm_compare13.c:15 cmp_x() x > y
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare14.c b/usr/src/tools/smatch/src/validation/sm_compare14.c
new file mode 100644
index 0000000000..c8fe2579c6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare14.c
@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+int cmp_x(int x, int y)
+{
+	if (x < y)
+		return -1;
+	if (x == y)
+		return 0;
+	return 1;
+}
+
+int x, y;
+int test(void)
+{
+	if (cmp_x(x, 4) < 0) {
+		__smatch_implied(x);
+	} else
+		__smatch_implied(x);
+}
+/*
+ * check-name: smatch compare #14
+ * check-command: smatch -I.. sm_compare14.c
+ *
+ * check-output-start
+sm_compare14.c:18 test() implied: x = 's32min-3'
+sm_compare14.c:20 test() implied: x = '4-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare15.c b/usr/src/tools/smatch/src/validation/sm_compare15.c
new file mode 100644
index 0000000000..545e858eeb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare15.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+int __fswab(int x)
+{
+	return x;
+}
+
+int a;
+int cmp_x(int x, int y)
+{
+	if (__fswab(a) > 5)
+		return;
+	__smatch_implied(a);
+}
+
+
+/*
+ * check-name: smatch compare #15
+ * check-command: smatch -I.. sm_compare15.c
+ *
+ * check-output-start
+sm_compare15.c:15 cmp_x() implied: a = 's32min-5'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare16.c b/usr/src/tools/smatch/src/validation/sm_compare16.c
new file mode 100644
index 0000000000..baa053a868
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare16.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+int return_x(int x)
+{
+	return x;
+}
+
+int a;
+int cmp_x(int x, int y)
+{
+	if (a > return_x(5))
+		return;
+	__smatch_implied(a);
+}
+
+
+/*
+ * check-name: smatch compare #16
+ * check-command: smatch -I.. sm_compare16.c
+ *
+ * check-output-start
+sm_compare16.c:15 cmp_x() implied: a = 's32min-5'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare17.c b/usr/src/tools/smatch/src/validation/sm_compare17.c
new file mode 100644
index 0000000000..41f8ec6570
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare17.c
@@ -0,0 +1,30 @@
+#include "check_debug.h"
+
+int frob();
+
+int xxx;
+static int options_write(void)
+{
+	int a = -1;
+	int found = 0;
+
+	if (xxx < 0)
+		return;
+	while (frob()) {
+		if (++a == xxx) {
+			found = 1;
+			break;
+		}
+	}
+	if (!found)
+		__smatch_compare(a, xxx);
+}
+
+/*
+ * check-name: smatch compare #17
+ * check-command: smatch -I.. sm_compare17.c
+ *
+ * check-output-start
+sm_compare17.c:20 options_write() a < xxx
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare2.c b/usr/src/tools/smatch/src/validation/sm_compare2.c
new file mode 100644
index 0000000000..e7ff80a102
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare2.c
@@ -0,0 +1,41 @@
+#include "check_debug.h"
+
+int a, b, c;
+
+int main(void)
+{
+	if (a < 4)
+		return 1;
+	if (a > 10)
+		return 2;
+	__smatch_value("a");
+
+	if (b < 3)
+		return 3;
+	if (b > 15)
+		return 4;
+	__smatch_value("b");
+
+	if (b > a) {
+		__smatch_value("a");
+		__smatch_value("b");
+	} else {
+		__smatch_value("a");
+		__smatch_value("b");
+	}
+	return 5;
+}
+
+/*
+ * check-name: Smatch Comparison #2
+ * check-command: smatch -I.. sm_compare2.c
+ *
+ * check-output-start
+sm_compare2.c:11 main() a = 4-10
+sm_compare2.c:17 main() b = 3-15
+sm_compare2.c:20 main() a = 4-10
+sm_compare2.c:21 main() b = 5-15
+sm_compare2.c:23 main() a = 4-10
+sm_compare2.c:24 main() b = 3-10
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare3.c b/usr/src/tools/smatch/src/validation/sm_compare3.c
new file mode 100644
index 0000000000..6209790eba
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare3.c
@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+int a, b, c, d;
+int e, f, g;
+int main(void)
+{
+	if (b > 1000000000)
+		return 0;
+
+	if (a >= b)
+		return 1;
+	if (a < 0 || b < 0)
+		return 1;
+	c = b - a;
+	__smatch_implied(c);
+	__smatch_compare(b, c);
+
+	if (e < 0 || e > b)
+		return;
+	if (f <= 0 || f > b)
+		return;
+	g = e + f;
+
+	__smatch_implied(g);
+	__smatch_implied(e);
+	__smatch_compare(g, e);
+	__smatch_compare(e, g);
+	__smatch_implied(g - e);
+	__smatch_implied(g - f);
+
+	return 0;
+}
+
+/*
+ * check-name: Smatch compare #3
+ * check-command: smatch -I.. sm_compare3.c
+ *
+ * check-output-start
+sm_compare3.c:17 main() implied: c = '1-1000000000'
+sm_compare3.c:18 main() b <= c
+sm_compare3.c:26 main() implied: g = '1-2000000000'
+sm_compare3.c:27 main() implied: e = '0-1000000000'
+sm_compare3.c:28 main() g > e
+sm_compare3.c:29 main() e < g
+sm_compare3.c:30 main() implied: g - e = '1-2000000000'
+sm_compare3.c:31 main() implied: g - f = '0-1999999999'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare4.c b/usr/src/tools/smatch/src/validation/sm_compare4.c
new file mode 100644
index 0000000000..ebac1685f1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare4.c
@@ -0,0 +1,35 @@
+#include "check_debug.h"
+
+int some_func();
+
+int a, b, c, d;
+
+void func (void)
+{
+	d = some_func();
+
+	if (a + 3 > 100)
+		return;
+	__smatch_implied(a);
+	if (3 + b > 100)
+		return;
+	__smatch_implied(b);
+	if (c - 3 > 100)
+		return;
+	__smatch_implied(c);
+	if (3 - d > 100)
+		return;
+	__smatch_implied(d);
+}
+
+/*
+ * check-name: Smatch compare #4
+ * check-command: smatch -I.. sm_compare4.c
+ *
+ * check-output-start
+sm_compare4.c:13 func() implied: a = 's32min-97'
+sm_compare4.c:16 func() implied: b = 's32min-97'
+sm_compare4.c:19 func() implied: c = 's32min-103'
+sm_compare4.c:22 func() implied: d = 's32min-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare5.c b/usr/src/tools/smatch/src/validation/sm_compare5.c
new file mode 100644
index 0000000000..a5b0e91621
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare5.c
@@ -0,0 +1,29 @@
+#include "check_debug.h"
+
+int a, b, c, d;
+void func(void)
+{
+	a = b + 3;
+	c = d - 3;
+
+	if (a > 10)
+		return;
+	__smatch_implied(a);
+	__smatch_implied(b);
+	if (10 > c)
+		return;
+	__smatch_implied(c);
+	__smatch_implied(d);
+}
+
+/*
+ * check-name: Smatch compare #5
+ * check-command: smatch -I.. sm_compare5.c
+ *
+ * check-output-start
+sm_compare5.c:11 func() implied: a = 's32min-10'
+sm_compare5.c:12 func() implied: b = 's32min-7'
+sm_compare5.c:15 func() implied: c = '10-s32max'
+sm_compare5.c:16 func() implied: d = '13-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare6.c b/usr/src/tools/smatch/src/validation/sm_compare6.c
new file mode 100644
index 0000000000..60b8da73f5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare6.c
@@ -0,0 +1,23 @@
+#include "check_debug.h"
+
+int returns_less(int x)
+{
+	int y;
+
+	if (x > 10)
+		y = 10;
+	else
+		y = x;
+
+	__smatch_compare(x, y);
+	return y;
+}
+
+/*
+ * check-name: smatch compare #6
+ * check-command: smatch -I.. sm_compare6.c
+ *
+ * check-output-start
+sm_compare6.c:12 returns_less() x >= y
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare7.c b/usr/src/tools/smatch/src/validation/sm_compare7.c
new file mode 100644
index 0000000000..fb9de888c6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare7.c
@@ -0,0 +1,24 @@
+#include "check_debug.h"
+
+int a, b, c, e, f, g;
+static int options_write(void)
+{
+	if (b >= c)
+		return;
+	a = c;
+	__smatch_compare(a, b);
+	if (f >= e)
+		return;
+	g = f;
+	__smatch_compare(g, e);
+}
+
+/*
+ * check-name: smatch compare #7
+ * check-command: smatch -I.. sm_compare7.c
+ *
+ * check-output-start
+sm_compare7.c:9 options_write() a > b
+sm_compare7.c:13 options_write() g < e
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare8.c b/usr/src/tools/smatch/src/validation/sm_compare8.c
new file mode 100644
index 0000000000..87b5d64174
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare8.c
@@ -0,0 +1,17 @@
+#include "check_debug.h"
+
+void *a, *b;
+static int options_write(void)
+{
+	a = b + 1;
+	__smatch_compare(a, b);
+}
+
+/*
+ * check-name: smatch compare #8
+ * check-command: smatch -I.. sm_compare8.c
+ *
+ * check-output-start
+sm_compare8.c:7 options_write() a > b
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compare9.c b/usr/src/tools/smatch/src/validation/sm_compare9.c
new file mode 100644
index 0000000000..87f772c572
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compare9.c
@@ -0,0 +1,17 @@
+#include "check_debug.h"
+
+void *a, *b;
+static int options_write(void)
+{
+	a = b / 2;
+	__smatch_compare(a, b);
+}
+
+/*
+ * check-name: smatch compare #9
+ * check-command: smatch -I.. sm_compare9.c
+ *
+ * check-output-start
+sm_compare9.c:7 options_write() a < b
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compound_condition.c b/usr/src/tools/smatch/src/validation/sm_compound_condition.c
new file mode 100644
index 0000000000..2f9e0c41d5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compound_condition.c
@@ -0,0 +1,27 @@
+struct ture {
+	int a;
+};
+
+struct ture *a;
+struct ture *b;
+
+void func (void)
+{
+	if (!a && !(a = returns_nonnull()))
+		return;
+	a->a = 1;
+
+	if (b || (b = returns_nonnull())) {
+		b->a  = 1;
+		return;
+	}
+	b->a = 1;
+}
+/*
+ * check-name: Compound Conditions
+ * check-command: smatch sm_compound_condition.c
+ *
+ * check-output-start
+sm_compound_condition.c:18 func() error: we previously assumed 'b' could be null (see line 14)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compound_conditions2.c b/usr/src/tools/smatch/src/validation/sm_compound_conditions2.c
new file mode 100644
index 0000000000..ddcd6473b2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compound_conditions2.c
@@ -0,0 +1,73 @@
+#include "check_debug.h"
+
+int aaa;
+int x, y, z;
+
+void func (void)
+{
+	aaa = 0;
+	if (y)
+		aaa = 1;
+	if (x)
+		aaa = 2;
+
+	if (x) {
+		__smatch_value("aaa");
+		if (y)
+			__smatch_value("aaa");
+		else
+			__smatch_value("aaa");
+	}
+	if (!x) {		
+		__smatch_value("aaa");
+		if (y)		
+			__smatch_value("aaa");
+		else
+			__smatch_value("aaa");
+	}
+	if (y) {
+		__smatch_value("aaa");
+		if (x)
+			__smatch_value("aaa");
+		else
+			__smatch_value("aaa");
+	}
+	if (!y) {
+		__smatch_value("aaa");
+		if (x)		
+			__smatch_value("aaa");
+		else
+			__smatch_value("aaa");
+	}
+	if (x && y)
+		__smatch_value("aaa");
+	if (x || y)
+		__smatch_value("aaa");
+	else
+		__smatch_value("aaa");
+	if (!x && !y)
+		__smatch_value("aaa");
+}
+/*
+ * check-name: Compound Conditions #2
+ * check-command: smatch -I.. sm_compound_conditions2.c
+ *
+ * check-output-start
+sm_compound_conditions2.c:15 func() aaa = 2
+sm_compound_conditions2.c:17 func() aaa = 2
+sm_compound_conditions2.c:19 func() aaa = 2
+sm_compound_conditions2.c:22 func() aaa = 0-1
+sm_compound_conditions2.c:24 func() aaa = 1
+sm_compound_conditions2.c:26 func() aaa = 0
+sm_compound_conditions2.c:29 func() aaa = 1-2
+sm_compound_conditions2.c:31 func() aaa = 2
+sm_compound_conditions2.c:33 func() aaa = 1
+sm_compound_conditions2.c:36 func() aaa = 0,2
+sm_compound_conditions2.c:38 func() aaa = 2
+sm_compound_conditions2.c:40 func() aaa = 0
+sm_compound_conditions2.c:43 func() aaa = 2
+sm_compound_conditions2.c:45 func() aaa = 1-2
+sm_compound_conditions2.c:47 func() aaa = 0
+sm_compound_conditions2.c:49 func() aaa = 0
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_compound_conditions3.c b/usr/src/tools/smatch/src/validation/sm_compound_conditions3.c
new file mode 100644
index 0000000000..f62e657e56
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_compound_conditions3.c
@@ -0,0 +1,29 @@
+#include "check_debug.h"
+
+int aaa;
+
+void func (void)
+{
+	if (aaa > 0 && aaa < 100) {
+		__smatch_value("aaa");
+	} else {
+		__smatch_value("aaa");
+	}
+	if (aaa > 0 && aaa < 100 && aaa < 10) {
+		__smatch_value("aaa");
+	} else {
+		if (aaa != 42)
+			__smatch_value("aaa");
+	}
+}
+/*
+ * check-name: Compound Conditions #3
+ * check-command: smatch -I.. sm_compound_conditions3.c
+ *
+ * check-output-start
+sm_compound_conditions3.c:8 func() aaa = 1-99
+sm_compound_conditions3.c:10 func() aaa = s32min-0,100-s32max
+sm_compound_conditions3.c:13 func() aaa = 1-9
+sm_compound_conditions3.c:16 func() aaa = s32min-0,10-41,43-s32max
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_deref_check_deref.c b/usr/src/tools/smatch/src/validation/sm_deref_check_deref.c
new file mode 100644
index 0000000000..5e4b2cde11
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_deref_check_deref.c
@@ -0,0 +1,37 @@
+struct ture {
+	int a;
+};
+struct cont {
+	struct ture *x;
+};
+
+struct ture *x;
+struct ture **px;
+struct cont *y;
+void func (void)
+{
+	int *a = &(x->a);
+	int *b = &x->a;
+	int *c = &(y->x->a);
+	int *d = &((*px)->a);
+
+	if (x)
+		frob();
+	if (px)
+		frob();
+	if (y->x)
+		frob();
+	if (y)
+		frob();
+
+	return;
+}
+/*
+ * check-name: Dereferencing before check
+ * check-command: smatch sm_deref_check_deref.c
+ *
+ * check-output-start
+sm_deref_check_deref.c:20 func() warn: variable dereferenced before check 'px' (see line 16)
+sm_deref_check_deref.c:24 func() warn: variable dereferenced before check 'y' (see line 15)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_dev_hold.c b/usr/src/tools/smatch/src/validation/sm_dev_hold.c
new file mode 100644
index 0000000000..f69f70f385
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_dev_hold.c
@@ -0,0 +1,27 @@
+void dev_hold(int *x);
+
+void dev_put(int *x){}
+
+extern int y,z;
+int *x;
+
+int func (void)
+{
+	dev_hold(x);
+	if (y) {
+		dev_put(x);
+		return -1;
+	}
+	if (z) {
+		return -1;
+	}
+	return 0;
+}
+/*
+ * check-name: dev_hold() check
+ * check-command: smatch --project=kernel sm_dev_hold.c
+ *
+ * check-output-start
+sm_dev_hold.c:16 func() warn: 'x' held on error path.
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_double_free1.c b/usr/src/tools/smatch/src/validation/sm_double_free1.c
new file mode 100644
index 0000000000..b2c673a85d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_double_free1.c
@@ -0,0 +1,21 @@
+#include <stdlib.h>
+
+void func (void)
+{
+	void *x;
+
+	x = malloc(42);
+
+	free(x);
+	free(x);
+
+	return 0;
+}
+/*
+ * check-name: double free test #1
+ * check-command: smatch sm_double_free1.c
+ *
+ * check-output-start
+sm_double_free1.c:10 func() error: double free of 'x'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_double_free2.c b/usr/src/tools/smatch/src/validation/sm_double_free2.c
new file mode 100644
index 0000000000..6335a0b4cf
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_double_free2.c
@@ -0,0 +1,28 @@
+#include <stdlib.h>
+
+struct ture {
+	int a;
+};
+
+void func (void)
+{
+	void *x;
+
+	x = malloc(sizeof(struct ture));
+	x->a = 1;
+
+	if (x->a)
+		free(x);
+
+	free(x);
+
+	return 0;
+}
+/*
+ * check-name: double free test #2
+ * check-command: smatch sm_double_free2.c
+ *
+ * check-output-start
+sm_double_free2.c:17 func() error: double free of 'x'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_efault.c b/usr/src/tools/smatch/src/validation/sm_efault.c
new file mode 100644
index 0000000000..e3d52adb55
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_efault.c
@@ -0,0 +1,21 @@
+#include "check_debug.h"
+
+int clear_user();
+
+int func(int *p)
+{
+	int ret;
+
+	ret = clear_user();
+	if (ret)
+		return ret;
+	return 0;
+}
+/*
+ * check-name: smatch return -EFAULT
+ * check-command: smatch -p=kernel -I.. sm_efault.c
+ *
+ * check-output-start
+sm_efault.c:11 func() warn: maybe return -EFAULT instead of the bytes remaining?
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_equiv1.c b/usr/src/tools/smatch/src/validation/sm_equiv1.c
new file mode 100644
index 0000000000..8bd7e57500
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_equiv1.c
@@ -0,0 +1,40 @@
+#include "check_debug.h"
+
+int *something();
+
+int *one;
+int *two;
+int func(void)
+{
+	one = something();
+	two = one;
+
+	if (two == 1) {
+		__smatch_value("one");
+		__smatch_value("two");
+	}
+	__smatch_value("one");
+	__smatch_value("two");
+	if (one == 2) {
+		__smatch_value("one");
+		__smatch_value("two");
+	}
+	__smatch_value("one");
+	__smatch_value("two");
+	return 0;
+}
+/*
+ * check-name: smatch equivalent variables #1
+ * check-command: smatch -I.. -m64 sm_equiv1.c
+ *
+ * check-output-start
+sm_equiv1.c:13 func() one = 1
+sm_equiv1.c:14 func() two = 1
+sm_equiv1.c:16 func() one = s64min-s64max
+sm_equiv1.c:17 func() two = s64min-s64max
+sm_equiv1.c:19 func() one = 2
+sm_equiv1.c:20 func() two = 2
+sm_equiv1.c:22 func() one = s64min-s64max
+sm_equiv1.c:23 func() two = s64min-s64max
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_equiv2.c b/usr/src/tools/smatch/src/validation/sm_equiv2.c
new file mode 100644
index 0000000000..d66da29ef8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_equiv2.c
@@ -0,0 +1,35 @@
+#include "check_debug.h"
+
+int *something();
+
+int red;
+int blue;
+int x;
+int func(void)
+{
+	red = 0;
+
+	if (x) {
+		red = 5;
+	}
+	blue = red;
+
+	if (x) {
+		__smatch_value("red");
+		__smatch_value("blue");
+	}
+	__smatch_value("red");
+	__smatch_value("blue");
+	return 0;
+}
+/*
+ * check-name: smatch equivalent variables #2 (implications)
+ * check-command: smatch -I.. sm_equiv2.c
+ *
+ * check-output-start
+sm_equiv2.c:18 func() red = 5
+sm_equiv2.c:19 func() blue = 5
+sm_equiv2.c:21 func() red = 0,5
+sm_equiv2.c:22 func() blue = 0,5
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_equiv3.c b/usr/src/tools/smatch/src/validation/sm_equiv3.c
new file mode 100644
index 0000000000..e8efbddd75
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_equiv3.c
@@ -0,0 +1,34 @@
+#include "check_debug.h"
+
+int *something();
+void frob();
+
+int red;
+int blue;
+int x;
+int func(void)
+{
+
+	red = something();
+	if (x < 4)
+		red = something();
+	else if (x > 5)
+		red = 0;
+
+	blue = red;
+	red = 0;
+	if (!blue)
+		return;
+	__smatch_value("red");
+	__smatch_value("blue");
+	return 0;
+}
+/*
+ * check-name: smatch equivalent variables #3
+ * check-command: smatch -I.. sm_equiv3.c
+ *
+ * check-output-start
+sm_equiv3.c:22 func() red = 0
+sm_equiv3.c:23 func() blue = s32min-(-1),1-s32max
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_equiv4.c b/usr/src/tools/smatch/src/validation/sm_equiv4.c
new file mode 100644
index 0000000000..c73baac4f1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_equiv4.c
@@ -0,0 +1,22 @@
+#include "check_debug.h"
+
+void *ioremap();
+void iounmap(void *);
+
+int *a, *b, *c;
+int func(void)
+{
+	a = ioremap();
+	b = ioremap();
+	c = a;
+	iounmap(c);
+	return -1;
+}
+/*
+ * check-name: smatch equivalent variables #4
+ * check-command: smatch -p=kernel --spammy -I.. sm_equiv4.c
+ *
+ * check-output-start
+sm_equiv4.c:13 func() warn: 'b' was not released on error
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_err_ptr.c b/usr/src/tools/smatch/src/validation/sm_err_ptr.c
new file mode 100644
index 0000000000..d89f5d86d1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_err_ptr.c
@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+int *add_inode();
+int IS_ERR(void *);
+
+int main(void)
+{
+	int *p;
+
+	p = add_inode();
+	if (!IS_ERR(p)) {
+		*p = 1;
+	}
+	*p = 1;
+
+	return 0;
+}
+/*
+ * check-name: dereferencing ERR_PTR bugs
+ * check-command: smatch -p=kernel sm_err_ptr.c
+ *
+ * check-output-start
+sm_err_ptr.c:14 main() error: 'p' dereferencing possible ERR_PTR()
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_fake_assignment.c b/usr/src/tools/smatch/src/validation/sm_fake_assignment.c
new file mode 100644
index 0000000000..28f7fdb446
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_fake_assignment.c
@@ -0,0 +1,33 @@
+#include "check_debug.h"
+
+struct ture {
+	int x, y;
+};
+
+struct ture outside = {
+	.x = 1,
+	.y = 2,
+};
+
+struct ture buf[10];
+void test(void)
+{
+	int a, b;
+
+	a = 0;
+	b = 0;
+	buf[a++] = outside;
+	buf[++b] = outside;
+	__smatch_implied(a);
+	__smatch_implied(b);
+}
+
+/*
+ * check-name: smatch fake assignment
+ * check-command: smatch -I.. sm_fake_assignment.c
+ *
+ * check-output-start
+sm_fake_assignment.c:21 test() implied: a = '1'
+sm_fake_assignment.c:22 test() implied: b = '1'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_get_user1.c b/usr/src/tools/smatch/src/validation/sm_get_user1.c
new file mode 100644
index 0000000000..989e895725
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_get_user1.c
@@ -0,0 +1,37 @@
+#include "check_debug.h"
+
+int frob(void);
+#define get_user(x, y) ({ int __val_gu = frob(); x = __val_gu; 0; })
+
+void func(void)
+{
+	int *user_ptr;
+	int foo, bar;
+	unsigned int x;
+
+	get_user(foo, user_ptr);
+	bar = foo + 1;
+
+	get_user(bar, user_ptr);
+	if (bar > foo)
+		bar = foo;
+	foo = bar * 8;
+
+	get_user(x, user_ptr);
+	if (x > foo)
+		x = foo;
+	foo = x * 8;
+
+	get_user(x, user_ptr);
+	foo = x * 8;
+}
+/*
+ * check-name: smatch get_user() #1
+ * check-command: smatch -p=kernel -I.. sm_get_user1.c
+ *
+ * check-output-start
+sm_get_user1.c:13 func() warn: check for integer over/underflow 'foo'
+sm_get_user1.c:18 func() warn: check for integer underflow 'bar'
+sm_get_user1.c:26 func() warn: check for integer overflow 'x'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied.c b/usr/src/tools/smatch/src/validation/sm_implied.c
new file mode 100644
index 0000000000..9e318effa5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied.c
@@ -0,0 +1,30 @@
+struct ture {
+	int a;
+};
+
+struct ture *a;
+struct ture *b;
+
+void func (void)
+{
+	struct ture *aa;
+
+	b = 0;
+	if (a)
+		goto x;
+	aa = returns_nonnull();
+	b = 1;
+x:
+	if (b)
+		aa->a = 1;
+	aa->a = 1;
+	return;
+}
+/*
+ * check-name: Smatch implied #1
+ * check-command: smatch --spammy sm_implied.c
+ *
+ * check-output-start
+sm_implied.c:20 func() error: potentially dereferencing uninitialized 'aa'.
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied10.c b/usr/src/tools/smatch/src/validation/sm_implied10.c
new file mode 100644
index 0000000000..b52f01195f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied10.c
@@ -0,0 +1,30 @@
+#include "check_debug.h"
+
+void frob(void){}
+
+int x[10];
+int offset;
+void func(int *y)
+{
+	if (({int test2 = !!(!y || !*y); frob(); frob(); frob(); test2;}))
+		__smatch_value("y");
+	else
+		__smatch_value("y");
+
+	if (({int test2 = !!(offset >= 10 || x[offset] == 1); frob(); frob(); frob(); test2;}))
+		__smatch_value("offset");
+	else
+		__smatch_value("offset");
+
+}
+/*
+ * check-name: smatch implied #10
+ * check-command: smatch -I.. -m64 sm_implied10.c
+ *
+ * check-output-start
+sm_implied10.c:10 func() y = 0,4096-2117777777777777777
+sm_implied10.c:12 func() y = 4096-2117777777777777777
+sm_implied10.c:15 func() offset = 0-s32max
+sm_implied10.c:17 func() offset = 0-9
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied11.c b/usr/src/tools/smatch/src/validation/sm_implied11.c
new file mode 100644
index 0000000000..5a8b02b5c3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied11.c
@@ -0,0 +1,34 @@
+#include "check_debug.h"
+
+struct foo {
+	int x;
+};
+
+void *frob();
+
+struct foo *foo;
+
+static void ad_agg_selection_logic(void)
+{
+	int a;
+
+
+	if (foo && foo->x)
+		a = 1;
+	else
+		a = 0;
+
+	if (frob())
+		a = frob();
+
+	if (a)
+		__smatch_implied(foo);
+}
+/*
+ * check-name: smatch implied #11
+ * check-command: smatch -I.. -m64 sm_implied11.c
+ *
+ * check-output-start
+sm_implied11.c:25 ad_agg_selection_logic() implied: foo = '0,4096-2117777777777777777'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied12.c b/usr/src/tools/smatch/src/validation/sm_implied12.c
new file mode 100644
index 0000000000..ad9e49487d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied12.c
@@ -0,0 +1,38 @@
+#include "check_debug.h"
+
+struct foo {
+	int x;
+};
+
+void *frob();
+
+struct foo *foo;
+
+int x;
+
+static void ad_agg_selection_logic(void)
+{
+	int a;
+
+
+	if (x) {
+		if (foo && foo->x)
+			a = 1;
+		else
+			a = 0;
+
+		if (frob())
+			a = frob();
+
+		if (a)
+			__smatch_implied(foo);
+	}
+}
+/*
+ * check-name: smatch implied #12
+ * check-command: smatch -I.. -m64 sm_implied12.c
+ *
+ * check-output-start
+sm_implied12.c:28 ad_agg_selection_logic() implied: foo = '0,4096-2117777777777777777'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied13.c b/usr/src/tools/smatch/src/validation/sm_implied13.c
new file mode 100644
index 0000000000..fad085a5a0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied13.c
@@ -0,0 +1,24 @@
+#include "check_debug.h"
+
+int main(int x)
+{
+	int a = 1;
+
+	if (x & 12)
+		a = 2;
+	__smatch_implied(a);
+	if (!(x & 12))
+		return 0;
+	__smatch_implied(a);
+	return 0;
+}
+
+/*
+ * check-name: smatch implied #13
+ * check-command: smatch -I.. sm_implied13.c
+ *
+ * check-output-start
+sm_implied13.c:9 main() implied: a = '1-2'
+sm_implied13.c:12 main() implied: a = '2'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied14.c b/usr/src/tools/smatch/src/validation/sm_implied14.c
new file mode 100644
index 0000000000..d3183c4710
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied14.c
@@ -0,0 +1,47 @@
+#include "check_debug.h"
+
+static int test(int x)
+{
+	if (x == 12)
+		return 10;
+	return 0;
+}
+
+int a, b;
+static void func(void)
+{
+	if (a == 12)
+		b = 1;
+	else
+		b = 4;
+	if (test(a) == 10) {
+		__smatch_implied(a);
+		__smatch_implied(b);
+	} else {
+		__smatch_implied(a);
+		__smatch_implied(b);
+	}
+
+	if (a == 12)
+		b = 10;
+	else
+		b = 40;
+
+	if (test(a))
+		__smatch_implied(b);
+	else
+		__smatch_implied(b);
+}
+/*
+ * check-name: smatch implied #14
+ * check-command: smatch -I.. sm_implied14.c
+ *
+ * check-output-start
+sm_implied14.c:18 func() implied: a = '12'
+sm_implied14.c:19 func() implied: b = '1'
+sm_implied14.c:21 func() implied: a = 's32min-11,13-s32max'
+sm_implied14.c:22 func() implied: b = '4'
+sm_implied14.c:31 func() implied: b = '10'
+sm_implied14.c:33 func() implied: b = '40'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied15.c b/usr/src/tools/smatch/src/validation/sm_implied15.c
new file mode 100644
index 0000000000..5aee587357
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied15.c
@@ -0,0 +1,43 @@
+#include "check_debug.h"
+
+int some_func(void);
+
+int a;
+int frob(int *p)
+{
+	int ret = 0;
+
+	*p = 4;
+	if (a)
+		goto out;
+
+	*p = some_func();
+	if (*p < 10 || *p > 100) {
+		ret = -12;
+		goto out;
+	}
+
+out:
+	return ret;
+}
+
+void test(void)
+{
+	int var = 0;
+	int ret;
+
+	ret = frob(&var);
+	__smatch_implied(var);
+	if (ret)
+		return;
+	__smatch_implied(var);
+}
+/*
+ * check-name: smatch implied #15
+ * check-command: smatch -I.. sm_implied15.c
+ *
+ * check-output-start
+sm_implied15.c:30 test() implied: var = 's32min-s32max'
+sm_implied15.c:33 test() implied: var = '4,10-100'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied16.c b/usr/src/tools/smatch/src/validation/sm_implied16.c
new file mode 100644
index 0000000000..50b6fe2415
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied16.c
@@ -0,0 +1,43 @@
+#include "check_debug.h"
+
+int frob(void);
+
+int a;
+int func (char *input)
+{
+	int x = frob();
+
+	if (a == 1) {
+		if (x != -5)
+			return;
+	} else if (a == 2) {
+		if (x != 0)
+			return;
+	} else if (a == 3) {
+		if (x != 42)
+			return;
+	} else {
+		return;
+	}
+
+	if (x) {
+		__smatch_implied(x);
+		__smatch_implied(a);
+	}
+
+	if (x == -5)
+		__smatch_implied(a);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch implied #16
+ * check-command: smatch -I.. sm_implied16.c
+ *
+ * check-output-start
+sm_implied16.c:24 func() implied: x = '(-5),42'
+sm_implied16.c:25 func() implied: a = '1,3'
+sm_implied16.c:29 func() implied: a = '1'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied17.c b/usr/src/tools/smatch/src/validation/sm_implied17.c
new file mode 100644
index 0000000000..588f63aae3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied17.c
@@ -0,0 +1,36 @@
+#include "check_debug.h"
+
+int frob(void);
+
+int a;
+int func (char *input)
+{
+	int x = frob();
+
+	if (a == 1) {
+		if (x != -5)
+			return;
+	} else if (a == 2) {
+		if (x < 0 || x > 10)
+			return;
+	} else {
+		return;
+	}
+
+	if (x)
+		;
+
+	if (x == -5)
+		__smatch_implied(a);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch implied #17
+ * check-command: smatch -I.. sm_implied17.c
+ *
+ * check-output-start
+sm_implied17.c:24 func() implied: a = '1'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied18.c b/usr/src/tools/smatch/src/validation/sm_implied18.c
new file mode 100644
index 0000000000..db148c916c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied18.c
@@ -0,0 +1,35 @@
+#include "check_debug.h"
+
+int a, b;
+
+int frob(int *data)
+{
+	if (a)
+		return 0;
+	if (b)
+		return -1;
+	*data = 42;
+	return 1;
+}
+
+void test(void)
+{
+	int x = -1;
+	int ret;
+
+	ret = frob(&x);
+	if (ret < 0)
+		return;
+	if (ret == 0)
+		return;
+	__smatch_implied(x);
+}
+
+/*
+ * check-name: smatch implied #18
+ * check-command: smatch -I.. sm_implied18.c
+ *
+ * check-output-start
+sm_implied18.c:25 test() implied: x = '42'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied19.c b/usr/src/tools/smatch/src/validation/sm_implied19.c
new file mode 100644
index 0000000000..e65487bcfa
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied19.c
@@ -0,0 +1,34 @@
+#include "check_debug.h"
+
+int xxx, yyy;
+int aaa, bbb;
+int id, vbus;
+void frob(void)
+{
+	if (xxx)
+		id = yyy;
+	else
+		id = 1;
+
+	if (aaa)
+		vbus = bbb;
+	else
+		vbus = id;
+
+	if (id)
+		;
+	if (!vbus)
+		;
+
+	if (!id)
+		__smatch_implied(vbus);
+}
+
+/*
+ * check-name: smatch implied #19
+ * check-command: smatch -I.. sm_implied19.c
+ *
+ * check-output-start
+sm_implied19.c:24 frob() implied: vbus = 's32min-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied2.c b/usr/src/tools/smatch/src/validation/sm_implied2.c
new file mode 100644
index 0000000000..c25e3567c2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied2.c
@@ -0,0 +1,41 @@
+struct ture {
+	int a;
+};
+
+struct ture *a;
+struct ture *b;
+struct ture *c;
+
+void func (void)
+{
+	struct ture *aa, *ab;
+
+	b = 0;
+	if (a) {
+		aa = returns_nonnull();
+		ab = returns_nonnull();
+	} else {
+		b = -1;
+	}
+	if (!(b)) {
+		if (c) {
+			aa = (void *)0;
+			ab = (void *)0;
+			b = -1;
+		}
+	}
+	if (!c)
+		aa->a = 1;
+	if (b)
+		return;
+	ab->a = 1;
+	return;
+}
+/*
+ * check-name: Smatch implied #2
+ * check-command: smatch --spammy sm_implied2.c
+ *
+ * check-output-start
+sm_implied2.c:28 func() error: potentially dereferencing uninitialized 'aa'.
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied3.c b/usr/src/tools/smatch/src/validation/sm_implied3.c
new file mode 100644
index 0000000000..ccad9f9de1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied3.c
@@ -0,0 +1,36 @@
+#define NULL ((void *)0)
+
+struct ture {
+	int *a;
+};
+
+struct ture *b;
+struct ture *c;
+
+void func (void)
+{
+	struct ture *ab;
+	int ret = 0;
+
+	if (b) {
+		ret = -1;
+		goto foo;
+	}
+
+	if (c) {}
+
+	ab = some_func();
+	if (NULL == ab) {
+		ret = -1;
+		goto foo;
+	}
+foo:
+	if (ret) {
+		return;
+	}
+	ab->a = 1;
+}
+/*
+ * check-name: Smatch implied #3
+ * check-command: smatch sm_implied3.c
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied4.c b/usr/src/tools/smatch/src/validation/sm_implied4.c
new file mode 100644
index 0000000000..1a3435e618
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied4.c
@@ -0,0 +1,35 @@
+void _spin_lock(int name);
+void _spin_unlock(int name);
+
+void frob(void){}
+int a;
+int b;
+int c;
+int func (void)
+{
+	int mylock = 1;
+	int mylock2 = 2;
+
+	if (a == 3)
+	      	_spin_lock(mylock);
+	if (b)
+		frob();
+	if (a == 3)
+	      	_spin_unlock(mylock);
+	if (a)
+	      	_spin_lock(mylock);
+	if (c)
+		return 0;
+	if (!!a)
+	      	_spin_unlock(mylock);
+	return 0;
+}
+
+/*
+ * check-name: Smatch implied #4
+ * check-command: smatch --project=kernel --spammy sm_implied4.c
+ *
+ * check-output-start
+sm_implied4.c:22 func() warn: 'spin_lock:mylock' is sometimes locked here and sometimes unlocked.
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied5.c b/usr/src/tools/smatch/src/validation/sm_implied5.c
new file mode 100644
index 0000000000..09b4a13ac9
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied5.c
@@ -0,0 +1,27 @@
+struct ture {
+	int a;
+};
+
+int out_a;
+
+void func (void)
+{
+	struct ture *aa;
+	int a = 0;
+
+	if (out_a) {	
+		aa = returns_nonnull();
+		a = something();
+	}
+	if (a)
+		aa->a = 1;
+	aa->a = 0xF00D;
+}
+/*
+ * check-name: Smatch implied #5
+ * check-command: smatch --spammy sm_implied5.c
+ *
+ * check-output-start
+sm_implied5.c:18 func() error: potentially dereferencing uninitialized 'aa'.
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied6.c b/usr/src/tools/smatch/src/validation/sm_implied6.c
new file mode 100644
index 0000000000..d4dce8b4ea
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied6.c
@@ -0,0 +1,41 @@
+struct foo {
+	int a;
+};
+
+struct foo *a;
+struct foo *b;
+struct foo *c;
+struct foo *d;
+int x, y, z;
+
+void func (void)
+{
+	a = 0;
+	b = 0;
+	c = 0;
+	d = 0;
+
+	if (x)
+		a = returns_nonnull();
+	else
+		b = returns_nonnull();
+	if (y)
+		a = returns_nonnull();
+	else
+		c = returns_nonnull();
+	__smatch_extra_values();
+	if (x || y) {
+		a->a = 1;
+		b->a = 2;
+	}else {
+		c->a = 3;
+	}
+}
+/*
+ * check-name: Smatch implied #6
+ * check-command: smatch --spammy sm_implied6.c
+ *
+ * check-output-start
+sm_implied6.c:29 func() error: potential NULL dereference 'b'.
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied7.c b/usr/src/tools/smatch/src/validation/sm_implied7.c
new file mode 100644
index 0000000000..f50190f7e6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied7.c
@@ -0,0 +1,22 @@
+#include "check_debug.h"
+int a, b, c;
+int frob(void) {
+	if (a && b != 1)
+		return;
+
+	__smatch_value("a");
+	if (b == 0 && c) {
+		__smatch_value("a");
+	}
+	__smatch_value("a");
+}
+/*
+ * check-name: Smatch implied #7
+ * check-command: smatch -I.. sm_implied7.c
+ *
+ * check-output-start
+sm_implied7.c:7 frob() a = s32min-s32max
+sm_implied7.c:9 frob() a = 0
+sm_implied7.c:11 frob() a = s32min-s32max
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied8.c b/usr/src/tools/smatch/src/validation/sm_implied8.c
new file mode 100644
index 0000000000..04c9ecf1d3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied8.c
@@ -0,0 +1,38 @@
+#include "check_debug.h"
+
+void frob();
+
+int test, test2;
+
+int x;
+void func (void)
+{
+	if (({int test = !!x; frob(); frob(); frob(); test;}))
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+	if (test)
+		__smatch_value("x");
+	if (({test2 = !(x == 3); frob(); frob(); frob(); test2;}))
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+	test = !!(x == 10);
+	if (!test)
+		__smatch_value("x");
+	__smatch_value("x");
+}
+/*
+ * check-name: smatch implied #8
+ * check-command: smatch -I.. sm_implied8.c
+ *
+ * check-output-start
+sm_implied8.c:11 func() x = s32min-(-1),1-s32max
+sm_implied8.c:13 func() x = 0
+sm_implied8.c:15 func() x = s32min-(-1),1-s32max
+sm_implied8.c:17 func() x = s32min-2,4-s32max
+sm_implied8.c:19 func() x = 3
+sm_implied8.c:22 func() x = s32min-9,11-s32max
+sm_implied8.c:23 func() x = s32min-s32max
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_implied9.c b/usr/src/tools/smatch/src/validation/sm_implied9.c
new file mode 100644
index 0000000000..9e76d39d34
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_implied9.c
@@ -0,0 +1,34 @@
+#include "check_debug.h"
+
+void frob(void){}
+
+void func(int y)
+{
+	int test2;
+
+	if (({int test2 = !!(y < 0 || y >= 10); frob(); frob(); frob(); test2;}))
+		__smatch_value("y");
+	else
+		__smatch_value("y");
+
+	test2 = (y < 3 || y >= 5);
+	if (test2)
+		__smatch_value("y");
+	else
+		__smatch_value("y");
+
+	if (({int test3 = y < -98; frob(); frob(); frob(); test3;}))
+		__smatch_value("y");
+}
+/*
+ * check-name: smatch implied #9
+ * check-command: smatch -I.. sm_implied9.c
+ *
+ * check-output-start
+sm_implied9.c:10 func() y = s32min-(-1),10-s32max
+sm_implied9.c:12 func() y = 0-9
+sm_implied9.c:16 func() y = s32min-2,5-s32max
+sm_implied9.c:18 func() y = 3-4
+sm_implied9.c:21 func() y = s32min-(-99)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_impossible1.c b/usr/src/tools/smatch/src/validation/sm_impossible1.c
new file mode 100644
index 0000000000..a81cbcd0a8
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_impossible1.c
@@ -0,0 +1,25 @@
+#include "check_debug.h"
+
+int zero(void)
+{
+	return 0;
+}
+
+
+int main(unsigned int x, unsigned int y)
+{
+	if (zero())
+		__smatch_states("register_impossible_return");
+	else
+		__smatch_states("register_impossible_return");
+}
+
+/*
+ * check-name: smatch impossible #1
+ * check-command: smatch -I.. sm_impossible1.c
+ *
+ * check-output-start
+sm_impossible1.c:12 main() [register_impossible_return] 'impossible' = 'impossible'
+sm_impossible1.c:14 main() register_impossible_return: no states
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_impossible2.c b/usr/src/tools/smatch/src/validation/sm_impossible2.c
new file mode 100644
index 0000000000..905bec5f46
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_impossible2.c
@@ -0,0 +1,25 @@
+#include "check_debug.h"
+
+int one(void)
+{
+	return 1;
+}
+
+
+int main(unsigned int x, unsigned int y)
+{
+	if (one())
+		__smatch_states("register_impossible_return");
+	else
+		__smatch_states("register_impossible_return");
+}
+
+/*
+ * check-name: smatch impossible #2
+ * check-command: smatch -I.. sm_impossible2.c
+ *
+ * check-output-start
+sm_impossible2.c:12 main() register_impossible_return: no states
+sm_impossible2.c:14 main() [register_impossible_return] 'impossible' = 'impossible'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_impossible3.c b/usr/src/tools/smatch/src/validation/sm_impossible3.c
new file mode 100644
index 0000000000..40e9e48d62
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_impossible3.c
@@ -0,0 +1,29 @@
+#include "check_debug.h"
+
+int frob(void);
+
+int main(void)
+{
+	int x;
+
+	x = frob();
+
+	if (x != -28)
+		return;
+
+	if (x != -28 && x != -30)
+		__smatch_implied(x);
+	__smatch_implied(x);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch impossible #3
+ * check-command: smatch -I.. sm_impossible3.c
+ *
+ * check-output-start
+sm_impossible3.c:15 main() implied: x = ''
+sm_impossible3.c:16 main() implied: x = '(-28)'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_indirection1.c b/usr/src/tools/smatch/src/validation/sm_indirection1.c
new file mode 100644
index 0000000000..0906d2156b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_indirection1.c
@@ -0,0 +1,22 @@
+#include "check_debug.h"
+
+int a;
+
+int frob(int size)
+{
+	int *p = &a;
+
+	*p = 42;
+	__smatch_implied(a);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch: pointer indirection #1
+ * check-command: smatch -p=kernel -I.. sm_indirection1.c
+ *
+ * check-output-start
+sm_indirection1.c:10 frob() implied: a = '42'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_indirection2.c b/usr/src/tools/smatch/src/validation/sm_indirection2.c
new file mode 100644
index 0000000000..f4e7b26814
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_indirection2.c
@@ -0,0 +1,42 @@
+#include "check_debug.h"
+
+struct foo {
+	int a, b, c;
+};
+
+struct bar {
+	struct foo *foo;
+};
+
+struct foo *get_foo(struct bar *bar)
+{
+	return bar->foo;
+}
+
+void frob(struct bar *bar)
+{
+	struct foo *f = bar->foo;
+	f->a = 5;
+}
+
+int test(struct bar *bar)
+{
+	struct foo *f = get_foo(bar);
+
+	f->a = 1;
+	frob(bar);
+	__smatch_implied(bar->foo->a);
+	__smatch_implied(f->a);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch: indirection #2
+ * check-command: smatch -I.. sm_indirection2.c
+ *
+ * check-output-start
+sm_indirection2.c:28 test() implied: bar->foo->a = '5'
+sm_indirection2.c:29 test() implied: f->a = '5'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_initializer.c b/usr/src/tools/smatch/src/validation/sm_initializer.c
new file mode 100644
index 0000000000..238d575f0d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_initializer.c
@@ -0,0 +1,37 @@
+#include "check_debug.h"
+
+struct bar {
+	int a, b, c;
+};
+
+struct foo {
+	struct bar bar;
+	int x, y, z;
+};
+
+int test(int size)
+{
+	struct foo foo = {
+		.bar.a = 42,
+		.bar.b = 43,
+		-1,
+	};
+	__smatch_implied(foo.bar.b);
+	__smatch_implied(foo.bar.c);
+	__smatch_implied(foo.x);
+	__smatch_implied(foo.y);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch: nested initializer
+ * check-command: smatch -I.. sm_initializer.c
+ *
+ * check-output-start
+sm_initializer.c:19 test() implied: foo.bar.b = '43'
+sm_initializer.c:20 test() implied: foo.bar.c = '0'
+sm_initializer.c:21 test() implied: foo.x = '(-1)'
+sm_initializer.c:22 test() implied: foo.y = '0'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_inline1.c b/usr/src/tools/smatch/src/validation/sm_inline1.c
new file mode 100644
index 0000000000..3dc8d37ae3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_inline1.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+int frob(int *x)
+{
+	*x = *x * 3;
+	return 0;
+}
+
+int *x;
+int y;
+int main(void)
+{
+	*x = 1;
+	frob(x);
+	__smatch_implied(*x);
+	frob(x);
+	__smatch_implied(*x);
+
+	y = 2;
+	frob(&y);
+	__smatch_implied(y);
+	frob(&y);
+	__smatch_implied(y);
+
+	return 0;
+}
+
+
+/*
+ * check-name: smatch: inline #1
+ * check-command: smatch -I.. sm_inline1.c
+ *
+ * check-output-start
+sm_inline1.c:17 main() implied: *x = '3'
+sm_inline1.c:19 main() implied: *x = '9'
+sm_inline1.c:23 main() implied: y = '6'
+sm_inline1.c:25 main() implied: y = '18'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_inline2.c b/usr/src/tools/smatch/src/validation/sm_inline2.c
new file mode 100644
index 0000000000..51636452e0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_inline2.c
@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <string.h>
+#include "check_debug.h"
+
+int frob(int *x)
+{
+	*x = *x * 3;
+	return 0;
+}
+
+int *x;
+int main(void)
+{
+	frob(x);
+	if (x)
+		return 1;
+	return 0;
+}
+
+
+/*
+ * check-name: smatch: inline #2
+ * check-command: smatch -I.. sm_inline2.c
+ *
+ * check-output-start
+sm_inline2.c:15 main() warn: variable dereferenced before check 'x' (see line 14)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_inline3.c b/usr/src/tools/smatch/src/validation/sm_inline3.c
new file mode 100644
index 0000000000..e4fb268ef4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_inline3.c
@@ -0,0 +1,39 @@
+#include "check_debug.h"
+
+void memset(void *p, char pat, int size);
+
+struct foo {
+	int a, b;
+};
+
+void my_func(struct foo *p)
+{
+	memset(p, 0, sizeof(*p));
+	p->a = 1;
+}
+
+struct foo *my_pointer;
+
+void test(void)
+{
+	struct foo foo;
+
+	my_func(my_pointer);
+	my_func(&foo);
+	__smatch_implied(my_pointer->a);
+	__smatch_implied(my_pointer->b);
+	__smatch_implied(foo.a);
+	__smatch_implied(foo.b);
+}
+
+/*
+ * check-name: smatch: inline #3
+ * check-command: smatch -I.. sm_inline3.c
+ *
+ * check-output-start
+sm_inline3.c:23 test() implied: my_pointer->a = '1'
+sm_inline3.c:24 test() implied: my_pointer->b = '0'
+sm_inline3.c:25 test() implied: foo.a = '1'
+sm_inline3.c:26 test() implied: foo.b = '0'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_locking.c b/usr/src/tools/smatch/src/validation/sm_locking.c
new file mode 100644
index 0000000000..af7373293b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_locking.c
@@ -0,0 +1,39 @@
+void _spin_lock(int name);
+void _spin_unlock(int name);
+
+int a, b, c;
+
+int func (void)
+{
+	int mylock = 1;
+	int mylock2 = 1;
+	int mylock3 = 1;
+
+	if (a) {
+		return;
+	}
+
+	_spin_lock(mylock);
+	_spin_unlock(mylock);
+
+	if (b) {
+		_spin_unlock(mylock2);
+		return;
+	}
+
+	if (c)
+		_spin_lock(mylock3);
+	return;
+}
+/*
+ * check-name: Smatch locking #1
+ * check-command: smatch --project=kernel --spammy sm_locking.c
+ *
+ * check-output-start
+sm_locking.c:26 func() warn: 'spin_lock:mylock3' is sometimes locked here and sometimes unlocked.
+sm_locking.c:26 func() warn: inconsistent returns 'spin_lock:mylock2'.
+  Locked on:   line 13
+               line 26
+  Unlocked on: line 21
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_locking2.c b/usr/src/tools/smatch/src/validation/sm_locking2.c
new file mode 100644
index 0000000000..37ce24869d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_locking2.c
@@ -0,0 +1,39 @@
+void _spin_lock(int name);
+void _spin_unlock(int name);
+int _spin_trylock(int name);
+
+int a;
+int b;
+int func (void)
+{
+	int mylock = 1;
+	int mylock2 = 1;
+	int mylock3 = 1;
+
+	if (!_spin_trylock(mylock)) {
+		return;
+	}
+
+	_spin_unlock(mylock);
+	_spin_unlock(mylock2);
+
+	if (a)
+		_spin_unlock(mylock);
+	_spin_lock(mylock2);
+
+	if (!_spin_trylock(mylock3))
+		return;
+	return;
+}
+/*
+ * check-name: Smatch locking #2
+ * check-command: smatch --project=kernel sm_locking2.c
+ *
+ * check-output-start
+sm_locking2.c:21 func() error: double unlock 'spin_lock:mylock'
+sm_locking2.c:26 func() warn: inconsistent returns 'spin_lock:mylock3'.
+  Locked on:   line 26
+  Unlocked on: line 14
+               line 25
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_locking3.c b/usr/src/tools/smatch/src/validation/sm_locking3.c
new file mode 100644
index 0000000000..c63ec5cab2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_locking3.c
@@ -0,0 +1,33 @@
+int _spin_trylock(int name);
+void _spin_lock(int name);
+void _spin_unlock(int name);
+
+int func (void)
+{
+	int mylock = 1;
+
+	if (!({frob(); frob(); _spin_trylock(mylock);})) 
+		return;
+
+	frob();
+	_spin_unlock(mylock);
+
+	if (((_spin_trylock(mylock)?1:0)?1:0))
+		return;
+	frob_somemore();
+	_spin_unlock(mylock);
+
+	return;
+}
+/*
+ * check-name: Smatch locking #3
+ * check-command: smatch --project=kernel sm_locking3.c
+ *
+ * check-output-start
+sm_locking3.c:18 func() error: double unlock 'spin_lock:mylock'
+sm_locking3.c:20 func() warn: inconsistent returns 'spin_lock:mylock'.
+  Locked on:   line 16
+  Unlocked on: line 10
+               line 20
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_locking4.c b/usr/src/tools/smatch/src/validation/sm_locking4.c
new file mode 100644
index 0000000000..301fac7086
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_locking4.c
@@ -0,0 +1,36 @@
+void _spin_lock(int name);
+void _spin_unlock(int name);
+
+void frob(void){}
+int a;
+int b;
+void func (void)
+{
+	int mylock = 1;
+	int mylock2 = 2;
+
+	if (1)
+	      	_spin_unlock(mylock);
+	frob();
+	if (a)
+		return;
+	if (!0)
+	      	_spin_lock(mylock);
+	if (0)
+	      	_spin_unlock(mylock);
+	if (b)
+		return;
+	if (!1)
+	      	_spin_lock(mylock);
+}
+/*
+ * check-name: Smatch locking #4
+ * check-command: smatch --project=kernel sm_locking4.c
+ *
+ * check-output-start
+sm_locking4.c:23 func() warn: inconsistent returns 'spin_lock:mylock'.
+  Locked on:   line 22
+               line 23
+  Unlocked on: line 16
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_locking6.c b/usr/src/tools/smatch/src/validation/sm_locking6.c
new file mode 100644
index 0000000000..9366c2c11f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_locking6.c
@@ -0,0 +1,45 @@
+int __raw_local_irq_save();
+int _spin_trylock(int x);
+int raw_local_irq_restore(flags);
+
+#define spin_trylock_irqsave(lock, flags) \
+({ \
+        (flags) = __raw_local_irq_save(); \
+        _spin_trylock(lock) ? 1 : ({ raw_local_irq_restore(flags);  0; }); \
+})
+
+void _spin_unlock_irqrestore(int lock, int flags);
+
+int zzz;
+
+void func (void)
+{
+	int lock = 1;
+	int flags = 1;
+
+	if (!spin_trylock_irqsave(lock, flags))
+		return;
+	_spin_unlock_irqrestore(lock, flags);
+	if (zzz)
+		return;
+	if (spin_trylock_irqsave(lock, flags))
+		return;
+	return;
+}
+/*
+ * check-name: Smatch locking #6
+ * check-command: smatch -p=kernel sm_locking6.c
+ *
+ * check-output-start
+sm_locking6.c:27 func() warn: inconsistent returns 'irqsave:flags'.
+  Locked on:   line 26
+  Unlocked on: line 21
+               line 24
+               line 27
+sm_locking6.c:27 func() warn: inconsistent returns 'spin_lock:lock'.
+  Locked on:   line 26
+  Unlocked on: line 21
+               line 24
+               line 27
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_locking7.c b/usr/src/tools/smatch/src/validation/sm_locking7.c
new file mode 100644
index 0000000000..f2177ff3e0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_locking7.c
@@ -0,0 +1,37 @@
+#include "check_debug.h"
+
+unsigned long arch_local_irq_save();
+void arch_local_irq_restore(unsigned long flags);
+int spin_trylock();
+void frob();
+
+void func(int *y)
+{
+	int lock;
+	unsigned long flags;
+
+	if (({
+		int __ret;
+		flags = arch_local_irq_save();
+		__ret = spin_trylock(&lock);
+		if (!__ret)
+			arch_local_irq_restore(flags);
+		__ret;
+	    }))
+		return;
+	frob();
+}
+
+/*
+ * check-name: smatch locking #7
+ * check-command: smatch -p=kernel -I.. sm_locking7.c
+ *
+ * check-output-start
+sm_locking7.c:22 func() warn: inconsistent returns 'irqsave:flags'.
+  Locked on:   line 21
+  Unlocked on: line 22
+sm_locking7.c:22 func() warn: inconsistent returns 'spin_lock:&lock'.
+  Locked on:   line 21
+  Unlocked on: line 22
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_loops1.c b/usr/src/tools/smatch/src/validation/sm_loops1.c
new file mode 100644
index 0000000000..03b1dfd9a1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_loops1.c
@@ -0,0 +1,37 @@
+#include "check_debug.h"
+
+void frob();
+
+void func(int *x)
+{
+	int a,b,c;
+
+	for (a = 0; a < 10; a++)
+		__smatch_value("a");
+	__smatch_value("a");
+	for (; a != 10; a++)
+		__smatch_value("a");
+	__smatch_value("a");
+	for (a = 0; a != 10; a++)
+		__smatch_value("a");
+	__smatch_value("a");
+	for (a = 0; a <= 10; a++)
+		__smatch_value("a");
+	__smatch_value("a");
+	return;
+}
+/*
+ * check-name: smatch loops #1
+ * check-command: smatch -I.. sm_loops1.c
+ *
+ * check-output-start
+sm_loops1.c:10 func() a = 0-9
+sm_loops1.c:11 func() a = 10
+sm_loops1.c:13 func() a = empty
+sm_loops1.c:14 func() a = 10
+sm_loops1.c:16 func() a = 0-9
+sm_loops1.c:17 func() a = 10
+sm_loops1.c:19 func() a = 0-10
+sm_loops1.c:20 func() a = 11
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_loops2.c b/usr/src/tools/smatch/src/validation/sm_loops2.c
new file mode 100644
index 0000000000..7fcf417b8a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_loops2.c
@@ -0,0 +1,44 @@
+#include "check_debug.h"
+
+int checker(void);
+
+int x;
+int y;
+void func(void)
+{
+	while (x--)
+		__smatch_value("x");
+	__smatch_value("x");
+	for (x = 0; x < y; x++) {
+		if (checker())
+			break;
+	}
+	__smatch_value("x");
+	while (x--)
+		__smatch_value("x");
+	__smatch_value("x");
+	x = 10;
+	while (x--)
+		__smatch_value("x");
+	__smatch_value("x");
+	x = 10;
+	while (--x)
+		__smatch_value("x");
+	__smatch_value("x");
+}
+/*
+ * check-name: smatch loops #1
+ * check-command: smatch -I.. sm_loops2.c
+ *
+ * check-output-start
+sm_loops2.c:10 func() x = s32min-s32max
+sm_loops2.c:11 func() x = s32min-s32max
+sm_loops2.c:16 func() x = 0-s32max
+sm_loops2.c:18 func() x = 0-s32max
+sm_loops2.c:19 func() x = (-1)
+sm_loops2.c:22 func() x = 0-9
+sm_loops2.c:23 func() x = (-1)
+sm_loops2.c:26 func() x = 1-9
+sm_loops2.c:27 func() x = 0
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_loops3.c b/usr/src/tools/smatch/src/validation/sm_loops3.c
new file mode 100644
index 0000000000..dcee5d8d56
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_loops3.c
@@ -0,0 +1,30 @@
+#include "check_debug.h"
+
+int checker(void);
+
+int x;
+int i;
+void func(void)
+{
+	int ar[10];
+
+	if (i < 0)
+		return;
+	if(i == 0)
+		x = 11;
+	else
+		x = 1;
+
+	while(i--) {
+		__smatch_value("x");
+		ar[x] = 1;
+	}
+}
+/*
+ * check-name: smatch loops #3
+ * check-command: smatch -I.. sm_loops3.c
+ *
+ * check-output-start
+sm_loops3.c:19 func() x = 1
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_loops4.c b/usr/src/tools/smatch/src/validation/sm_loops4.c
new file mode 100644
index 0000000000..1b35b21310
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_loops4.c
@@ -0,0 +1,30 @@
+#include "check_debug.h"
+
+char *some_func(void);
+
+int x,y;
+int i;
+void func(void)
+{
+	char *p;
+	char *p2;
+
+	if (x > 0)
+		p = some_func();
+	for (i = 0; i < x; i++)
+		*p = 'x';
+	*p = 'x';
+	if (y > 0)
+		p2 = some_func();
+	i = 0;
+	if (i < y)
+		*p2 = 'x';
+}
+/*
+ * check-name: smatch loops #4
+ * check-command: smatch -I.. sm_loops4.c
+ *
+ * check-output-start
+sm_loops4.c:16 func() error: potentially dereferencing uninitialized 'p'.
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_loops5.c b/usr/src/tools/smatch/src/validation/sm_loops5.c
new file mode 100644
index 0000000000..0ed7171189
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_loops5.c
@@ -0,0 +1,21 @@
+#include "check_debug.h"
+
+int frob(void);
+
+int a, b, c;
+void test(void)
+{
+	a = 0;
+	do {
+		frob();
+	} while (a++ < 3);
+	__smatch_implied(a);
+}
+/*
+ * check-name: smatch loops #5
+ * check-command: smatch -I.. sm_loops5.c
+ *
+ * check-output-start
+sm_loops5.c:12 test() implied: a = '4'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_loops6.c b/usr/src/tools/smatch/src/validation/sm_loops6.c
new file mode 100644
index 0000000000..1bc9983054
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_loops6.c
@@ -0,0 +1,52 @@
+#include "check_debug.h"
+
+extern int xxx;
+
+int test(struct bar *bar)
+{
+	int a = 10, b = 10, c = 10, d = 10, e = 10;
+
+	while (a--)
+		__smatch_implied(a);
+	__smatch_implied(a);
+
+	while (--b)
+		__smatch_implied(b);
+	__smatch_implied(b);
+
+	while (--c >= 0)
+		__smatch_implied(c);
+	__smatch_implied(c);
+
+	while (d-- >= 0)
+		__smatch_implied(d);
+	__smatch_implied(d);
+
+	while (e-- >= 0) {
+		if (xxx)
+			break;
+		__smatch_implied(e);
+	}
+	__smatch_implied(e);
+
+	return 0;
+}
+
+
+/*
+ * check-name: smatch loops #6
+ * check-command: smatch -I.. sm_loops6.c
+ *
+ * check-output-start
+sm_loops6.c:10 test() implied: a = '0-9'
+sm_loops6.c:11 test() implied: a = '(-1)'
+sm_loops6.c:14 test() implied: b = '1-9'
+sm_loops6.c:15 test() implied: b = '0'
+sm_loops6.c:18 test() implied: c = '0-9'
+sm_loops6.c:19 test() implied: c = '(-1)'
+sm_loops6.c:22 test() implied: d = '(-1)-9'
+sm_loops6.c:23 test() implied: d = '(-2)'
+sm_loops6.c:28 test() implied: e = '(-1)-9'
+sm_loops6.c:30 test() implied: e = '(-2)-9'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_macros.c b/usr/src/tools/smatch/src/validation/sm_macros.c
new file mode 100644
index 0000000000..896b9a99d1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_macros.c
@@ -0,0 +1,32 @@
+#include "check_debug.h"
+
+#define add(x, y) x + y
+#define sub(x, y) x - y
+
+int x;
+void func(int *p)
+{
+	int a = 1;
+	int b = 2;
+
+	x = 4 * add(2, 3);
+	x = 4 + add(2, 3);
+	x = 4 * add(2, 3) * 8;
+	x = add(2, 3) * 4;
+	x = add(2, 3) - 4;
+	x = -sub(2, 3);
+	x = sub(2, 3)++;
+}
+/*
+ * check-name: Smatch macro precedence bugs
+ * check-command: smatch -I.. sm_macros.c
+ *
+ * check-output-start
+sm_macros.c:12 func() warn: the 'add' macro might need parens
+sm_macros.c:14 func() warn: the 'add' macro might need parens
+sm_macros.c:14 func() warn: the 'add' macro might need parens
+sm_macros.c:15 func() warn: the 'add' macro might need parens
+sm_macros.c:17 func() warn: the 'sub' macro might need parens
+sm_macros.c:18 func() warn: the 'sub' macro might need parens
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_math1.c b/usr/src/tools/smatch/src/validation/sm_math1.c
new file mode 100644
index 0000000000..2fc4c86a22
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_math1.c
@@ -0,0 +1,37 @@
+#include "check_debug.h"
+
+int something();
+
+void func(void)
+{
+	int x = 3;
+	int y = 42;
+	int z = 7;
+
+	x--;
+	y -= 100;
+	__smatch_value("y");
+	while (something()) {
+		y++;
+		__smatch_value("y");
+	}
+	z += something();
+	__smatch_value("z");
+	__smatch_value("x");
+label_I1:
+	x--;
+	__smatch_value("x");
+	goto label_I1;
+}
+/*
+ * check-name: smatch math test #1
+ * check-command: smatch -I.. sm_math1.c
+ *
+ * check-output-start
+sm_math1.c:13 func() y = (-58)
+sm_math1.c:16 func() y = (-57)-s32max
+sm_math1.c:19 func() z = s32min-s32max
+sm_math1.c:20 func() x = 2
+sm_math1.c:23 func() x = s32min-1
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_math2.c b/usr/src/tools/smatch/src/validation/sm_math2.c
new file mode 100644
index 0000000000..d9bd164306
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_math2.c
@@ -0,0 +1,25 @@
+#include "check_debug.h"
+
+unsigned char buf[2];
+
+void test(void)
+{
+	int a = buf[1];
+	int b = buf[0] << 8;
+	int c = (buf[0] << 8) | buf[1];
+
+	__smatch_implied(a);
+	__smatch_implied(b);
+	__smatch_implied(c);
+}
+
+/*
+ * check-name: smatch math #2
+ * check-command: smatch -I.. sm_math2.c
+ *
+ * check-output-start
+sm_math2.c:11 test() implied: a = '0-255'
+sm_math2.c:12 test() implied: b = '0,256-65280'
+sm_math2.c:13 test() implied: c = '0-u16max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_memleak2.c b/usr/src/tools/smatch/src/validation/sm_memleak2.c
new file mode 100644
index 0000000000..a6a0df85b1
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_memleak2.c
@@ -0,0 +1,19 @@
+#include <stdlib.h>
+
+void func (void)
+{
+	void *ptr;
+
+	ptr = malloc(42);
+	ptr = (void *) 0;
+
+	return;
+}
+/*
+ * check-name: leak test #2
+ * check-command: smatch sm_memleak2.c
+ *
+ * check-output-start
+sm_memleak2.c:8 func() warn: overwrite may leak 'ptr'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_memory.c b/usr/src/tools/smatch/src/validation/sm_memory.c
new file mode 100644
index 0000000000..145b1c0b49
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_memory.c
@@ -0,0 +1,35 @@
+void *kmalloc(void);
+void free(void *);
+
+struct ture {
+	int *a;
+};
+
+struct ture *a;
+struct ture *b;
+void func (void)
+{
+	struct ture *aa;
+	struct ture *ab;
+	struct ture *ac;
+	aa = kmalloc();
+	ab = kmalloc();
+	ac = kmalloc();
+
+	a = aa;
+	if (ab) {
+		free(ab);
+		return;
+	}
+	free(ac);
+	return;
+}
+/*
+ * check-name: leak test #1
+ * check-command: smatch sm_memory.c
+ *
+ * check-output-start
+sm_memory.c:22 func() warn: possible memory leak of 'ac'
+sm_memory.c:22 func() error: memory leak of 'ac'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_mod.c b/usr/src/tools/smatch/src/validation/sm_mod.c
new file mode 100644
index 0000000000..3c5df3d62b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_mod.c
@@ -0,0 +1,38 @@
+#include "check_debug.h"
+
+int a, b;
+
+int frob(int size)
+{
+	if (a <= 0 || a > 10)
+		return;
+	if (a % 4) {
+		__smatch_implied(a);
+	} else {
+		__smatch_implied(a);
+	}
+
+	if (b <= 0 || b > 100)
+		return;
+	if (b % 4) {
+		__smatch_implied(b);
+	} else {
+		__smatch_implied(b);
+	}
+
+
+
+	return 0;
+}
+
+/*
+ * check-name: smatch mod condition
+ * check-command: smatch -I.. sm_mod.c
+ *
+ * check-output-start
+sm_mod.c:10 frob() implied: a = '1-10'
+sm_mod.c:12 frob() implied: a = '4,8'
+sm_mod.c:18 frob() implied: b = '1-99'
+sm_mod.c:20 frob() implied: b = '4-100'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_mtag1.c b/usr/src/tools/smatch/src/validation/sm_mtag1.c
new file mode 100644
index 0000000000..ee742f6d62
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_mtag1.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include "check_debug.h"
+
+static int xxx = 234;
+
+struct foo {
+	int a, b, c;
+	int (*func)(struct foo *p);
+};
+
+static int frob1(struct foo *p)
+{
+	printf("%d\n", p->a);
+	__smatch_implied(p->a);
+	return p->a + 1;
+}
+static int frob2(struct foo *p)
+{
+	printf("%d\n", p->a);
+	__smatch_implied(p->a);
+	return p->a + 1;
+}
+
+static struct foo one_struct = {
+	.a = 1,
+	.func = frob1,
+};
+static struct foo two_struct = {
+	.a = 2,
+	.func = frob2,
+};
+
+int main(void)
+{
+	struct foo *p = &one_struct;
+	int ret;
+
+	ret = p->func(p);
+//	__smatch_implied(ret);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch mtag #1
+ * check-command: validation/smatch_db_test.sh -I.. sm_mtag1.c
+ *
+ * check-output-start
+sm_mtag1.c:14 frob1() implied: p->a = '1'
+sm_mtag1.c:20 frob2() implied: p->a = '2'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_mtag2.c b/usr/src/tools/smatch/src/validation/sm_mtag2.c
new file mode 100644
index 0000000000..60b7913c68
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_mtag2.c
@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include "check_debug.h"
+
+struct foo {
+	int a, b, c;
+	int (*func)(int *p);
+	void (*func2)(int a);
+	void *data;
+};
+
+static int frob1(int *val)
+{
+	__smatch_implied(*val);
+	return *val + 1;
+}
+
+static int frob2(int *val)
+{
+	__smatch_implied(*val);
+	return *val + 1;
+}
+
+static struct foo one_struct = {
+	.a = 1,
+	.func = frob1,
+};
+
+static struct foo two_struct = {
+	.a = 2,
+	.func = frob2,
+};
+
+struct foo *unknown(void);
+struct foo *p;
+
+int main(void)
+{
+	int ret;
+
+	p = unknown();
+	ret = p->func(&p->a);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch mtag #2
+ * check-command: validation/smatch_db_test.sh -I.. sm_mtag2.c
+ *
+ * check-output-start
+sm_mtag2.c:13 frob1() implied: *val = '1'
+sm_mtag2.c:19 frob2() implied: *val = '2'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_mtag3.c b/usr/src/tools/smatch/src/validation/sm_mtag3.c
new file mode 100644
index 0000000000..0fb59781dc
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_mtag3.c
@@ -0,0 +1,29 @@
+#include "check_debug.h"
+
+int x;
+int array[10];
+
+int main(void)
+{
+	__smatch_implied(&x);
+	__smatch_implied((unsigned long)(array + 1) - (unsigned long)array);
+	__smatch_implied(array + 1 - array);
+	__smatch_implied(array + 1);
+	__smatch_implied((int *)0 + 1);
+
+	return 0;
+}
+
+
+/*
+ * check-name: smatch mtag #3
+ * check-command: smatch -I.. sm_mtag3.c
+ *
+ * check-output-start
+sm_mtag3.c:8 main() implied: &x = '799717014380380160'
+sm_mtag3.c:9 main() implied: (array[1]) - array = '4'
+sm_mtag3.c:10 main() implied: array[1] - array = '1'
+sm_mtag3.c:11 main() implied: array[1] = '7934625272050024452'
+sm_mtag3.c:12 main() implied: 0 + 1 = '4'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_mtag4.c b/usr/src/tools/smatch/src/validation/sm_mtag4.c
new file mode 100644
index 0000000000..ddf72292fc
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_mtag4.c
@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include "check_debug.h"
+
+struct foo {
+	int a, b, c;
+	int (*func)(int *p);
+	void (*func2)(int a);
+	void *data;
+};
+
+static void frob_int1(int val)
+{
+	__smatch_implied(val);
+}
+
+static void frob_int2(int val)
+{
+	__smatch_implied(val);
+}
+
+static struct foo one_struct = {
+	.b = 41,
+	.func2 = frob_int1,
+};
+
+static struct foo two_struct = {
+	.b = 42,
+	.func2 = frob_int2,
+};
+
+struct foo *unknown(void);
+struct foo *p;
+
+int main(void)
+{
+	int ret;
+
+	p = unknown();
+	p->func2(p->b);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch mtag #4
+ * check-command: validation/smatch_db_test.sh -I.. sm_mtag4.c
+ *
+ * check-output-start
+sm_mtag4.c:13 frob_int1() implied: val = '41'
+sm_mtag4.c:18 frob_int2() implied: val = '42'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_mtag5.c b/usr/src/tools/smatch/src/validation/sm_mtag5.c
new file mode 100644
index 0000000000..c7dfefac5e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_mtag5.c
@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include "check_debug.h"
+
+int x = 42;
+
+struct foo {
+	int a, b, c;
+};
+struct foo aaa = {
+	.a = 1, .b = 2, .c = 3,
+};
+
+int array[10];
+
+int main(void)
+{
+	__smatch_implied(&x);
+	__smatch_implied(&aaa);
+	__smatch_implied(&aaa.b);
+	__smatch_implied(array);
+	__smatch_implied(&array[1]);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch mtag #5
+ * check-command: smatch -I.. sm_mtag5.c
+ *
+ * check-output-start
+sm_mtag5.c:17 main() implied: &x = '799717014380380160'
+sm_mtag5.c:18 main() implied: &aaa = '126458562737565696'
+sm_mtag5.c:19 main() implied: &aaa.b = '126458562737565700'
+sm_mtag5.c:20 main() implied: array = '7934625272050024448'
+sm_mtag5.c:21 main() implied: &array[1] = '7934625272050024452'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_mtag6.c b/usr/src/tools/smatch/src/validation/sm_mtag6.c
new file mode 100644
index 0000000000..fea036520e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_mtag6.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include "check_debug.h"
+
+int frob1(int *p)
+{
+	__smatch_implied(*p);
+}
+
+int frob2(int *p)
+{
+	__smatch_implied(*p);
+}
+
+int x = 42;
+
+struct foo {
+	int a, b, c;
+};
+struct foo aaa = {
+	.a = 1, .b = 2, .c = 3,
+};
+
+int array[10];
+
+int main(void)
+{
+	frob1(&x);
+	frob2(&aaa.b);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch mtag #6
+ * check-command: validation/smatch_db_test.sh -I.. sm_mtag6.c
+ *
+ * check-output-start
+sm_mtag6.c:6 frob1() implied: *p = '42'
+sm_mtag6.c:11 frob2() implied: *p = '2'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_mtag7.c b/usr/src/tools/smatch/src/validation/sm_mtag7.c
new file mode 100644
index 0000000000..f9eccfa774
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_mtag7.c
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include "check_debug.h"
+
+struct foo {
+	int (*func)(struct foo *);
+	int a, b, c;
+	int *p;
+};
+
+int frob1(struct foo *p)
+{
+	__smatch_implied(*p->p);
+}
+
+int frob2(struct foo *p)
+{
+	__smatch_implied(*p->p);
+}
+
+int x = 42;
+int y = 43;
+
+struct foo aaa = {
+	.func = frob1,
+	.a = 1, .b = 2, .c = 3,
+	.p = &x,
+};
+struct foo bbb = {
+	.func = frob2,
+	.a = 10, .b = 11, .c = 13,
+	.p = &y,
+};
+
+int main(void)
+{
+	aaa.func(&aaa);
+	bbb.func(&bbb);
+	return 0;
+}
+
+/*
+ * check-name: smatch mtag #7
+ * check-command: validation/smatch_db_test.sh -I.. sm_mtag7.c
+ *
+ * check-output-start
+sm_mtag7.c:12 frob1() implied: *p->p = '42'
+sm_mtag7.c:17 frob2() implied: *p->p = '43'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_netdevice.c b/usr/src/tools/smatch/src/validation/sm_netdevice.c
new file mode 100644
index 0000000000..34cf1375a3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_netdevice.c
@@ -0,0 +1,31 @@
+
+void kfree(void *);
+
+struct net_device {
+	char *name;
+};
+
+void func(void)
+{
+	struct net_device dev;
+	struct net_device *dev2 = &dev;
+	struct net_device **dev3 = &dev2;
+	struct net_device *deva[10];
+	struct net_device **devb[10];
+	struct net_device ***devc = devb;
+
+	kfree(dev2);
+	kfree(dev3);
+	kfree(deva[0]);
+	kfree(devb[0]);
+	kfree(devc[0]);
+}
+/*
+ * check-name: free_netdev() vs kfree()
+ * check-command: smatch -p=kernel sm_netdevice.c
+ *
+ * check-output-start
+sm_netdevice.c:17 func() error: use free_netdev() here instead of kfree(dev2)
+sm_netdevice.c:19 func() error: use free_netdev() here instead of kfree(deva[0])
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_null_deref.c b/usr/src/tools/smatch/src/validation/sm_null_deref.c
new file mode 100644
index 0000000000..df399e6cc5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_null_deref.c
@@ -0,0 +1,52 @@
+#include "check_debug.h"
+
+struct foo {
+	int a;
+};
+
+struct foo *a;
+struct foo *b;
+struct foo *c;
+struct foo *d;
+
+static void func (void)
+{
+	struct foo *aa;
+	int ab = 0;
+	int ac = 1;
+
+	aa->a = 1;
+
+	if (a) {
+		a->a = 1;
+	}
+	a->a = 1;
+
+	if (a && b) {
+		b->a = 1;
+	}
+
+	if (a || b) {
+		b->a = 1;
+	}
+
+	if (c) {
+		ab = 1;
+	}
+
+	if (ab) {
+		c->a = 1;
+	}
+}
+/*
+ * check-name: Null Dereferences
+ * check-command: smatch --spammy -I.. sm_null_deref.c
+ *
+ * check-output-start
+sm_null_deref.c:18 func() error: potentially dereferencing uninitialized 'aa'.
+sm_null_deref.c:23 func() error: we previously assumed 'a' could be null (see line 20)
+sm_null_deref.c:25 func() warn: variable dereferenced before check 'a' (see line 23)
+sm_null_deref.c:30 func() error: we previously assumed 'b' could be null (see line 25)
+ * check-output-end
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/sm_null_deref2.c b/usr/src/tools/smatch/src/validation/sm_null_deref2.c
new file mode 100644
index 0000000000..94c38dea9b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_null_deref2.c
@@ -0,0 +1,24 @@
+int *ptr;
+int x, y, z;
+void frob(void) {
+	if ((y && !ptr) || z)
+		return;
+	if (ptr) {
+		/* in the current version of smatch this erases
+		   the old implications.  Later version should 
+		   fix this.  --Dec 2 2009 */
+		x = *ptr;
+	}
+	if (!y && ptr)
+		*ptr = 0; // smatch used to print an error here.
+	if (!y)
+		*ptr = 1;
+}
+/*
+ * check-name: Dereferencing Undefined
+ * check-command: smatch sm_null_deref2.c
+ *
+ * check-output-start
+sm_null_deref2.c:15 frob() error: we previously assumed 'ptr' could be null (see line 12)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_overflow.c b/usr/src/tools/smatch/src/validation/sm_overflow.c
new file mode 100644
index 0000000000..c4f33a87f6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_overflow.c
@@ -0,0 +1,27 @@
+struct field {                                                                                                               
+    int b[8];                                                                                                                
+};                                                                                                                           
+                                                                                                                             
+struct buffer {                                                                                                              
+    struct field a;                                                                                                          
+    int x;                                                                                                                   
+};                                                                                                                           
+                                                                                                                             
+int main(int argc, char* argv[])                                                                                             
+{                                                                                                                            
+    struct buffer b1;                                                                                                        
+    int i;                                                                                                                   
+                                                                                                                             
+    b1.a.b[10] = 1;                                                                                                          
+                                                                                                                             
+    return 42;                                                                                                               
+}                                                                                                                            
+                                                                                                                          
+/*
+ * check-name: Check array overflow
+ * check-command: smatch sm_overflow.c
+ *
+ * check-output-start
+sm_overflow.c:15 main() error: buffer overflow 'b1.a.b' 8 <= 10
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_overflow3.c b/usr/src/tools/smatch/src/validation/sm_overflow3.c
new file mode 100644
index 0000000000..565518066d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_overflow3.c
@@ -0,0 +1,29 @@
+#include "check_debug.h"
+
+void strcpy(char *to, char *from, int size);
+
+void func (char *a, char *b)
+{
+	char c[4];
+	char d[4];
+	char e[4];
+	char f[4];
+
+	b = "1234";
+	strcpy(a, b);
+	a[5] = '\0';
+	strcpy(c, b);
+	strcpy(d, "123");
+	strcpy(e, "1234");
+	strcpy(f, "12");
+	f[3] = '\0';
+}
+/*
+ * check-name: smatch strcpy overflow
+ * check-command: smatch -I.. sm_overflow3.c
+ *
+ * check-output-start
+sm_overflow3.c:15 func() error: strcpy() 'b' too large for 'c' (5 vs 4)
+sm_overflow3.c:17 func() error: strcpy() '"1234"' too large for 'e' (5 vs 4)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_overflow4.c b/usr/src/tools/smatch/src/validation/sm_overflow4.c
new file mode 100644
index 0000000000..2d8c9e58e5
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_overflow4.c
@@ -0,0 +1,20 @@
+#include "check_debug.h"
+
+void strndup(char *to, int size);
+void strcpy(char *dest, char *src);
+
+void func (char *a, char *b)
+{
+	char c[5];
+
+	a = strndup(b, 5);
+	strcpy(c, a);
+}
+/*
+ * check-name: smatch strndup overflow
+ * check-command: smatch -I.. sm_overflow4.c
+ *
+ * check-output-start
+sm_overflow4.c:11 func() error: strcpy() 'a' too large for 'c' (6 vs 5)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_overflow5.c b/usr/src/tools/smatch/src/validation/sm_overflow5.c
new file mode 100644
index 0000000000..e930e50a9a
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_overflow5.c
@@ -0,0 +1,21 @@
+#include "check_debug.h"
+
+void memdup(char *to, int size);
+void strcpy(char *dest, char *src);
+
+void func (char *a, char *b)
+{
+	char c[5];
+
+	a = memdup(b, 5);
+	strcpy(c, a);
+	a[5] = '\0';
+}
+/*
+ * check-name: smatch memdup overflow
+ * check-command: smatch -I.. sm_overflow5.c
+ *
+ * check-output-start
+sm_overflow5.c:12 func() error: buffer overflow 'a' 5 <= 5
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_overflow6.c b/usr/src/tools/smatch/src/validation/sm_overflow6.c
new file mode 100644
index 0000000000..7b5534762f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_overflow6.c
@@ -0,0 +1,29 @@
+#include "check_debug.h"
+
+int strlen(char *buf);
+void strcpy(char *dest, char *src);
+int snprintf(char *dest, int limit, char *format, char *str);
+int sprintf(char *dest, char *format, char *str);
+
+char *str;
+
+int main(void)
+{
+	char buf[10];
+	char buf1[10];
+
+	if (strlen(str) > 11)
+		return;
+	snprintf(buf, 11, "%s", str);
+	sprintf(buf1, "%s", str);
+}
+/*
+ * check-name: smatch overflow #6
+ * check-command: smatch -I.. sm_overflow6.c
+ *
+ * check-output-start
+sm_overflow6.c:17 main() error: snprintf() is printing too much 11 vs 10
+sm_overflow6.c:17 main() error: snprintf() chops off the last chars of 'str': 12 vs 11
+sm_overflow6.c:18 main() error: sprintf() copies too much data from 'str': 12 vs 10
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_pointer_assign.c b/usr/src/tools/smatch/src/validation/sm_pointer_assign.c
new file mode 100644
index 0000000000..c7aabaa6af
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_pointer_assign.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include "check_debug.h"
+
+int *aaa, *bbb;
+
+int main(void)
+{
+	if (*aaa < 0 || *aaa > 34)
+		return -1;
+	bbb = aaa;
+	__smatch_implied(*bbb);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch pointer assign
+ * check-command: smatch -I.. sm_pointer_assign.c
+ *
+ * check-output-start
+sm_pointer_assign.c:11 main() implied: *bbb = '0-34'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_precedence.c b/usr/src/tools/smatch/src/validation/sm_precedence.c
new file mode 100644
index 0000000000..42b965eaff
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_precedence.c
@@ -0,0 +1,43 @@
+struct foo {
+	unsigned int x:1;
+};
+
+int frob();
+int a,b,c,d, x, y;
+struct foo *z;
+static int options_write(void)
+{
+	if (x & y == 0)
+		frob();
+	if (x | y == 0)
+		frob();
+	if (a == b & c == d)
+		frob();
+	if (a == c == d)
+		frob();
+	if (!a == b)
+		frob();
+	c = !a & b;
+	if (x + y == 0)
+		frob();
+	if (!a == !b)
+		frob();
+	if (!a == z->x)
+		frob();
+	if (!!a == b)
+		frob();
+
+}
+/*
+ * check-name: Smatch precedence check
+ * check-command: smatch sm_precedence.c
+ *
+ * check-output-start
+sm_precedence.c:10 options_write() warn: add some parenthesis here?
+sm_precedence.c:12 options_write() warn: add some parenthesis here?
+sm_precedence.c:14 options_write() warn: add some parenthesis here?
+sm_precedence.c:16 options_write() warn: add some parenthesis here?
+sm_precedence.c:18 options_write() warn: add some parenthesis here?
+sm_precedence.c:20 options_write() warn: add some parenthesis here?
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_range1.c b/usr/src/tools/smatch/src/validation/sm_range1.c
new file mode 100644
index 0000000000..39a8f8e7b3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_range1.c
@@ -0,0 +1,29 @@
+struct ture {
+	int x;
+};
+
+struct ture *p;	
+struct ture *q;
+int xxx;
+
+int func (void)
+{
+
+	for (xxx = 0; xxx < 10; xxx++) {
+		if (p && q)
+			break;	
+	}
+// this needs two pass processing to work.
+//	if (xxx == 5)
+//		q->x = 1;
+	if (xxx == 10)
+		return;
+	p->x = 1;
+
+	return 0;
+}
+
+/*
+ * check-name: Implied Ranges #1
+ * check-command: smatch sm_range1.c
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_range2.c b/usr/src/tools/smatch/src/validation/sm_range2.c
new file mode 100644
index 0000000000..2bfc676e21
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_range2.c
@@ -0,0 +1,43 @@
+#include "check_debug.h"
+int some_func();
+int a, b, c, d, e;
+int frob(void) {
+	if (a)
+		__smatch_value("a");
+	else
+		__smatch_value("a");
+	__smatch_value("a");
+	if (a) {
+		b = 0;
+		__smatch_value("b");
+	}
+	__smatch_value("b");
+	c = 0;
+	c = some_func();
+	__smatch_value("c");
+	if (d < -3 || d > 99)
+		return;
+	__smatch_value("d");
+	if (d) {
+		if (!e)
+			return;
+	}
+	__smatch_value("d");
+	__smatch_value("e");
+}
+/*
+ * check-name: Smatch range test #2
+ * check-command: smatch -I.. sm_range2.c
+ *
+ * check-output-start
+sm_range2.c:6 frob() a = s32min-(-1),1-s32max
+sm_range2.c:8 frob() a = 0
+sm_range2.c:9 frob() a = s32min-s32max
+sm_range2.c:12 frob() b = 0
+sm_range2.c:14 frob() b = s32min-s32max
+sm_range2.c:17 frob() c = s32min-s32max
+sm_range2.c:20 frob() d = (-3)-99
+sm_range2.c:25 frob() d = (-3)-99
+sm_range2.c:26 frob() e = s32min-s32max
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_range3.c b/usr/src/tools/smatch/src/validation/sm_range3.c
new file mode 100644
index 0000000000..397208e7cb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_range3.c
@@ -0,0 +1,85 @@
+#include "check_debug.h"
+
+int x;
+void func(void)
+{
+
+	if (x < 1)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	if (12 < x)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	if (x <= 23)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	if (34 <= x)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	if (x >= 45)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	if (56 >= x)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	if (x > 67)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	if (78 > x)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	if (89 == x)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	if (100 != x)
+		__smatch_value("x");
+	else
+		__smatch_value("x");
+
+	return;
+}
+/*
+ * check-name: smatch range comparison
+ * check-command: smatch -I.. sm_range3.c
+ *
+ * check-output-start
+sm_range3.c:8 func() x = s32min-0
+sm_range3.c:10 func() x = 1-s32max
+sm_range3.c:13 func() x = 13-s32max
+sm_range3.c:15 func() x = s32min-12
+sm_range3.c:18 func() x = s32min-23
+sm_range3.c:20 func() x = 24-s32max
+sm_range3.c:23 func() x = 34-s32max
+sm_range3.c:25 func() x = s32min-33
+sm_range3.c:28 func() x = 45-s32max
+sm_range3.c:30 func() x = s32min-44
+sm_range3.c:33 func() x = s32min-56
+sm_range3.c:35 func() x = 57-s32max
+sm_range3.c:38 func() x = 68-s32max
+sm_range3.c:40 func() x = s32min-67
+sm_range3.c:43 func() x = s32min-77
+sm_range3.c:45 func() x = 78-s32max
+sm_range3.c:48 func() x = 89
+sm_range3.c:50 func() x = s32min-88,90-s32max
+sm_range3.c:53 func() x = s32min-99,101-s32max
+sm_range3.c:55 func() x = 100
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_range4.c b/usr/src/tools/smatch/src/validation/sm_range4.c
new file mode 100644
index 0000000000..d0a2f0cfd6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_range4.c
@@ -0,0 +1,37 @@
+#include "check_debug.h"
+
+int a, b, c;
+
+static int frob(void)
+{
+	if (a > 5) {
+		__smatch_value("a");
+		return;
+	}
+	if (b++ > 5) {
+		__smatch_value("b");
+		return;
+	}
+	if (++c > 5) {
+		__smatch_value("c");
+		return;
+	}
+	__smatch_value("a");
+	__smatch_value("b");
+	__smatch_value("c");
+}
+
+
+/*
+ * check-name: Smatch Range #4
+ * check-command: smatch -I.. sm_range4.c
+ *
+ * check-output-start
+sm_range4.c:8 frob() a = 6-s32max
+sm_range4.c:12 frob() b = 7-s32max
+sm_range4.c:16 frob() c = 6-s32max
+sm_range4.c:19 frob() a = s32min-5
+sm_range4.c:20 frob() b = s32min-6
+sm_range4.c:21 frob() c = s32min-5
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_range5.c b/usr/src/tools/smatch/src/validation/sm_range5.c
new file mode 100644
index 0000000000..628b5c16cd
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_range5.c
@@ -0,0 +1,22 @@
+#include "check_debug.h"
+
+int main(unsigned int x, unsigned int y)
+{
+	switch (x) {
+	case 0 ... 9:
+		__smatch_implied(x);
+		break;
+	default:
+		__smatch_implied(x);
+	}
+}
+
+/*
+ * check-name: smatch range #5
+ * check-command: smatch -I.. sm_range5.c
+ *
+ * check-output-start
+sm_range5.c:7 main() implied: x = '0-9'
+sm_range5.c:10 main() implied: x = '10-u32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_range6.c b/usr/src/tools/smatch/src/validation/sm_range6.c
new file mode 100644
index 0000000000..a9998c7069
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_range6.c
@@ -0,0 +1,23 @@
+#include "check_debug.h"
+
+void func(void)
+{
+	long a = __smatch_rl("1-10+");
+	long b = __smatch_rl("0,+");
+	long c = __smatch_rl("10,23,45-+");
+
+	__smatch_implied(a);
+	__smatch_implied(b);
+	__smatch_implied(c);
+}
+
+/*
+ * check-name: smatch range #6
+ * check-command: smatch -I.. sm_range6.c
+ *
+ * check-output-start
+sm_range6.c:9 func() implied: a = '1-s64max'
+sm_range6.c:10 func() implied: b = '0-s64max'
+sm_range6.c:11 func() implied: c = '10,23,45-s64max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_real_absolute1.c b/usr/src/tools/smatch/src/validation/sm_real_absolute1.c
new file mode 100644
index 0000000000..584d882fae
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_real_absolute1.c
@@ -0,0 +1,21 @@
+#include "check_debug.h"
+
+
+void *p;
+int min1, min2;
+void func(unsigned long x)
+{
+	min1 = 18;
+	min2 = (((unsigned char *)p)[12] + 8);
+	if (min2 < min1)
+		__smatch_implied(min2);
+}
+
+/*
+ * check-name: Smatch real absolute #1
+ * check-command: smatch -I.. sm_real_absolute1.c
+ *
+ * check-output-start
+sm_real_absolute1.c:11 func() implied: min2 = '8-17'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_rosenberg.c b/usr/src/tools/smatch/src/validation/sm_rosenberg.c
new file mode 100644
index 0000000000..5240a9a7cb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_rosenberg.c
@@ -0,0 +1,75 @@
+#include "check_debug.h"
+
+void memset(void *ptr, char c, int size){}
+
+int copy_to_user(void *dest, void *data, int size){}
+int some_func(struct foo *p){}
+
+typedef struct zr364xx_pipeinfo {
+	char x;
+	int y;
+} aa_policy_t;
+
+struct aa_policy {
+	int x;
+};
+
+struct foo {
+	struct aa_policy a;
+	int x;
+	int y;
+};
+
+struct foo *p;
+struct foo global_dec;
+void *ptr;
+
+int main(void)
+{
+	struct zr364xx_pipeinfo one;
+	struct aa_policy two;
+	aa_policy_t three;
+	struct foo four;
+	struct foo five;
+	struct foo six;
+	struct foo seven;
+	struct foo eight;
+	struct foo nine;
+
+	p->a.x = 0;
+	global_dec.x = 0;
+	memset(&two, 0, sizeof(two));
+	four.x = 0;
+	six = five;
+	some_func(&seven);
+	eight.x = (four.x < 5 ? four.x : 5);
+	eight.y = !five.y;
+	if (some_func()) {
+		nine.x = 1;
+		nine.y = 2;
+	}
+
+	copy_to_user(ptr, &p->a, sizeof(struct aa_policy));
+	copy_to_user(ptr, &global_dec, sizeof(global_dec));
+	copy_to_user(ptr, &one, sizeof(one));
+	copy_to_user(ptr, &two, sizeof(two));
+	copy_to_user(ptr, &three, sizeof(three));
+	copy_to_user(ptr, &four, sizeof(four));
+	copy_to_user(ptr, &five, sizeof(five));
+	copy_to_user(ptr, &six, sizeof(six));
+	copy_to_user(ptr, &seven, sizeof(seven));
+	copy_to_user(ptr, &eight, sizeof(eight));
+	copy_to_user(ptr, &nine, sizeof(nine));
+	return 0;
+}
+/*
+ * check-name: Rosenberg Leaks
+ * check-command: smatch -p=kernel -I.. sm_rosenberg.c
+ *
+ * check-output-start
+sm_rosenberg.c:54 main() warn: check that 'one' doesn't leak information (struct has a hole after 'x')
+sm_rosenberg.c:56 main() warn: check that 'three' doesn't leak information (struct has a hole after 'x')
+sm_rosenberg.c:57 main() warn: check that 'four.y' doesn't leak information
+sm_rosenberg.c:62 main() warn: check that 'nine.x' doesn't leak information
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_select.c b/usr/src/tools/smatch/src/validation/sm_select.c
new file mode 100644
index 0000000000..8ae2e5961e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_select.c
@@ -0,0 +1,40 @@
+struct foo {
+	int a;
+};
+
+struct foo *a;
+struct foo *b;
+
+struct foo *c;
+struct foo *d;
+struct foo *e;
+void func (void)
+{
+	if (a?b:0) {
+		a->a = 1;
+		b->a = 1;
+	}
+	a->a = 1;
+	b->a = 1;
+	e->a = 1;
+	d = returns_nonnull();
+	if (c?d:e) {
+		c->a = 1;
+		d->a = 1;
+		e->a = 1;
+	}
+	e->a = 1;
+}
+
+/*
+ * check-name: Ternary Conditions
+ * check-command: smatch sm_select.c
+ *
+ * check-output-start
+sm_select.c:17 func() error: we previously assumed 'a' could be null (see line 13)
+sm_select.c:18 func() error: we previously assumed 'b' could be null (see line 13)
+sm_select.c:21 func() warn: variable dereferenced before check 'e' (see line 19)
+sm_select.c:22 func() error: we previously assumed 'c' could be null (see line 21)
+ * check-output-end
+ */
+
diff --git a/usr/src/tools/smatch/src/validation/sm_select3.c b/usr/src/tools/smatch/src/validation/sm_select3.c
new file mode 100644
index 0000000000..bb2ad0c1ea
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_select3.c
@@ -0,0 +1,104 @@
+#include "check_debug.h"
+
+int a, b, c;
+int func(void)
+{
+	if (a ? b : c)
+		__smatch_value("a");
+
+	__smatch_note("Test #1 a ? 1 : c");
+	if (a ? 1 : c) {	
+		__smatch_value("a");
+		__smatch_value("c");
+		if (!a)
+			__smatch_value("c");
+		if (!c)
+			__smatch_value("a");
+	} else {
+		__smatch_value("a");
+		__smatch_value("c");
+	}
+
+	__smatch_note("Test #2 a ? 0 : c");
+	if (a ? 0 : c) {	
+		__smatch_value("a");
+		__smatch_value("c");
+		if (!a)
+			__smatch_value("c");
+	} else {
+		__smatch_value("a");
+		__smatch_value("c");
+		if (!a)
+			__smatch_value("c");
+		if (!c)
+			__smatch_value("a");
+	}
+
+	__smatch_note("Test #3 a ? b : 1");
+	if (a ? b : 1) {	
+		__smatch_value("a");
+		__smatch_value("b");
+		if (!a)
+			__smatch_value("b");
+		if (!b)
+			__smatch_value("a");
+	} else {
+		__smatch_value("a");
+		__smatch_value("b");
+		if (!b)
+			__smatch_value("a");
+	}
+
+	__smatch_note("Test #2 a ? b : 0");
+	if (a ? b : 0) {	
+		__smatch_value("a");
+		__smatch_value("b");
+	} else {
+		__smatch_value("a");
+		__smatch_value("b");
+		if (a)
+			__smatch_value("b");
+		if (b)
+			__smatch_value("a");
+	}
+}
+
+
+/*
+ * check-name: Ternary Conditions #3
+ * check-command: smatch -I.. sm_select3.c
+ *
+ * check-output-start
+sm_select3.c:7 func() a = s32min-s32max
+sm_select3.c:9 func() Test #1 a ? 1 : c
+sm_select3.c:11 func() a = s32min-s32max
+sm_select3.c:12 func() c = s32min-s32max
+sm_select3.c:14 func() c = s32min-(-1),1-s32max
+sm_select3.c:16 func() a = s32min-(-1),1-s32max
+sm_select3.c:18 func() a = 0
+sm_select3.c:19 func() c = 0
+sm_select3.c:22 func() Test #2 a ? 0 : c
+sm_select3.c:24 func() a = 0
+sm_select3.c:25 func() c = s32min-(-1),1-s32max
+sm_select3.c:27 func() c = s32min-(-1),1-s32max
+sm_select3.c:29 func() a = s32min-s32max
+sm_select3.c:30 func() c = s32min-s32max
+sm_select3.c:32 func() c = 0
+sm_select3.c:34 func() a = s32min-s32max
+sm_select3.c:37 func() Test #3 a ? b : 1
+sm_select3.c:39 func() a = s32min-s32max
+sm_select3.c:40 func() b = s32min-s32max
+sm_select3.c:42 func() b = s32min-s32max
+sm_select3.c:44 func() a = 0
+sm_select3.c:46 func() a = s32min-(-1),1-s32max
+sm_select3.c:47 func() b = 0
+sm_select3.c:49 func() a = s32min-(-1),1-s32max
+sm_select3.c:52 func() Test #2 a ? b : 0
+sm_select3.c:54 func() a = s32min-(-1),1-s32max
+sm_select3.c:55 func() b = s32min-(-1),1-s32max
+sm_select3.c:57 func() a = s32min-s32max
+sm_select3.c:58 func() b = s32min-s32max
+sm_select3.c:60 func() b = 0
+sm_select3.c:62 func() a = 0
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_select4.c b/usr/src/tools/smatch/src/validation/sm_select4.c
new file mode 100644
index 0000000000..af7bbc8686
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_select4.c
@@ -0,0 +1,25 @@
+#include "check_debug.h"
+
+int frob();
+
+int a, b, c;
+void func(unsigned long x)
+{
+	if (x >= 4)
+		return;
+
+	__smatch_value("x");
+	if ((!(a) ? -19 : (((b && c) ? frob() : -515))))
+		__smatch_value("x");
+	__smatch_value("x");
+}
+/*
+ * check-name: Smatch Ternary #4
+ * check-command: smatch -I.. sm_select4.c
+ *
+ * check-output-start
+sm_select4.c:11 func() x = 0-3
+sm_select4.c:13 func() x = 0-3
+sm_select4.c:14 func() x = 0-3
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_select5.c b/usr/src/tools/smatch/src/validation/sm_select5.c
new file mode 100644
index 0000000000..cce93b30c2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_select5.c
@@ -0,0 +1,31 @@
+#include "check_debug.h"
+
+int load_sig(unsigned long sig)
+{
+	return sig < 4 ? 0 : -12;
+}
+
+int a;
+void test(void)
+{
+	int ret;
+
+	ret = load_sig(a);
+	if (ret) {
+		__smatch_implied(ret);
+		__smatch_implied(a);
+	} else {
+		__smatch_implied(a);
+	}
+}
+
+/*
+ * check-name: smatch select #5
+ * check-command: smatch -I.. sm_select5.c
+ *
+ * check-output-start
+sm_select5.c:15 test() implied: ret = '(-12)'
+sm_select5.c:16 test() implied: a = 's32min-s32max'
+sm_select5.c:18 test() implied: a = '0-3'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_select_assign.c b/usr/src/tools/smatch/src/validation/sm_select_assign.c
new file mode 100644
index 0000000000..c2cbda0636
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_select_assign.c
@@ -0,0 +1,38 @@
+#include "check_debug.h"
+
+void frob();
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+
+void func(void)
+{
+	int i;
+	int val;
+
+	for (i = 0; i < 10; i++) {
+		val = min(5, i);
+		__smatch_value("val");
+	}
+
+	i++;
+	__smatch_value("i");
+	val = min(100, i);
+	__smatch_value("val");
+
+	for (i = 0; i < 10; i++)
+		frob();
+
+	val = min(100, i);
+	__smatch_value("val");
+}
+/*
+ * check-name: assigning select statements
+ * check-command: smatch -I.. sm_select_assign.c
+ *
+ * check-output-start
+sm_select_assign.c:14 func() val = 0-5
+sm_select_assign.c:18 func() i = 11-s32max
+sm_select_assign.c:20 func() val = 11-100
+sm_select_assign.c:26 func() val = 10
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_skb.c b/usr/src/tools/smatch/src/validation/sm_skb.c
new file mode 100644
index 0000000000..ccd738c0c0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_skb.c
@@ -0,0 +1,55 @@
+struct sk_buff {
+	int valuable_information;
+};
+struct foo {
+	int x;
+};
+struct ture {
+	struct sk_buff *skb;
+};
+
+struct wrap1 {
+	struct ture *a;
+};
+struct wrap2 {
+	struct foo *c; 
+	struct wrap1 *b;
+};
+struct wrap3 {
+	struct foo *c; 
+};
+
+struct sk_buff *skb;
+struct sk_buff **ptr;
+struct ture *x;
+struct ture xx;
+struct wrap1 *u;
+struct wrap2 *y;
+struct wrap3 *z;
+
+void kfree(void *data);
+
+void func (void)
+{
+	kfree(skb);
+	kfree(x->skb);
+	kfree(xx.skb);
+	kfree(y->c);
+	kfree(u->a->skb);
+	kfree(u->a);
+	kfree(y->b->a->skb);
+	kfree(z->c);
+	kfree(ptr);
+}
+/*
+ * check-name: kfree_skb() test
+ * check-command: smatch -p=kernel sm_skb.c
+ *
+ * check-output-start
+sm_skb.c:34 func() error: use kfree_skb() here instead of kfree(skb)
+sm_skb.c:35 func() error: use kfree_skb() here instead of kfree(x->skb)
+sm_skb.c:36 func() error: use kfree_skb() here instead of kfree(xx.skb)
+sm_skb.c:38 func() error: use kfree_skb() here instead of kfree(u->a->skb)
+sm_skb.c:40 func() error: use kfree_skb() here instead of kfree(y->b->a->skb)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_skb2.c b/usr/src/tools/smatch/src/validation/sm_skb2.c
new file mode 100644
index 0000000000..ab96555ecf
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_skb2.c
@@ -0,0 +1,56 @@
+#include "check_debug.h"
+
+struct sk_buff {
+	unsigned char *head, *data;
+	unsigned short network_header;
+};
+
+struct foo {
+	int a, b, c;
+};
+
+static inline unsigned char *skb_network_header(const struct sk_buff *skb)
+{
+	return skb->head + skb->network_header;
+}
+
+static inline int skb_network_offset(const struct sk_buff *skb)
+{
+	return skb_network_header(skb) - skb->data;
+}
+
+int frob(struct sk_buff *skb)
+{
+	struct foo *p;
+	int x, y;
+
+	__smatch_user_rl(*skb->data);
+	__smatch_user_rl(skb->data + 1);
+	__smatch_user_rl(*(int *)skb->data);
+        __smatch_user_rl(skb->data - skb_network_header(skb));
+
+	p = skb->data;
+	x = *(int *)skb->data;
+	y = skb->data[1];
+
+	__smatch_user_rl(p->a);
+	__smatch_user_rl(x);
+	__smatch_user_rl(y);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch: userdata from skb
+ * check-command: smatch -p=kernel -I.. sm_skb2.c
+ *
+ * check-output-start
+sm_skb2.c:27 frob() user rl: '*skb->data' = '0-255'
+sm_skb2.c:28 frob() user rl: 'skb->data + 1' = ''
+sm_skb2.c:29 frob() user rl: '*skb->data' = 's32min-s32max'
+sm_skb2.c:30 frob() user rl: 'skb->data - skb_network_header(skb)' = ''
+sm_skb2.c:36 frob() user rl: 'p->a' = 's32min-s32max'
+sm_skb2.c:37 frob() user rl: 'x' = 's32min-s32max'
+sm_skb2.c:38 frob() user rl: 'y' = '0-255'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_skb3.c b/usr/src/tools/smatch/src/validation/sm_skb3.c
new file mode 100644
index 0000000000..62f5515724
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_skb3.c
@@ -0,0 +1,29 @@
+#include "check_debug.h"
+
+struct sk_buff {
+	unsigned char *head, *data;
+	unsigned short network_header;
+};
+
+struct foo {
+	int a, b, c;
+};
+
+int frob(struct sk_buff *skb)
+{
+	struct foo *p;
+
+	p = skb->data + sizeof(int) * 2;
+	__smatch_user_rl(p->a);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch: userdata from skb #3
+ * check-command: smatch -p=kernel -I.. sm_skb3.c
+ *
+ * check-output-start
+sm_skb3.c:17 frob() user rl: 'p->a' = 's32min-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_strlen.c b/usr/src/tools/smatch/src/validation/sm_strlen.c
new file mode 100644
index 0000000000..b5019a0f03
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_strlen.c
@@ -0,0 +1,24 @@
+int strlen(char *str);
+int strcpy(char *str);
+
+void func (char *input)
+{
+	int input_len;
+	char buf[4];
+
+	input_len = strlen(input);
+	if (input_len <= 5) {
+		strcpy(buf, input);
+	}
+	if (input_len <= 3) {
+		strcpy(buf, input);
+	}
+}
+/*
+ * check-name: Smatch strlen test
+ * check-command: smatch sm_strlen.c
+ *
+ * check-output-start
+sm_strlen.c:11 func() error: strcpy() 'input' too large for 'buf' (6 vs 4)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_strlen2.c b/usr/src/tools/smatch/src/validation/sm_strlen2.c
new file mode 100644
index 0000000000..3af86a6825
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_strlen2.c
@@ -0,0 +1,29 @@
+int strlen(char *str);
+int strcpy(char *str);
+
+void func (char *input1, char *input2, char *input3)
+{
+	char buf1[4];
+	char buf2[4];
+	char buf3[4];
+
+	if (strlen(input1) > 4)
+		return;
+	strcpy(buf1, input1);
+
+	if (10 > strlen(input2))
+		strcpy(buf2, input2);
+
+	if (strlen(input3) <= 4)
+		strcpy(buf3, input3);
+}
+/*
+ * check-name: Smatch strlen test #2
+ * check-command: smatch sm_strlen2.c
+ *
+ * check-output-start
+sm_strlen2.c:12 func() error: strcpy() 'input1' too large for 'buf1' (5 vs 4)
+sm_strlen2.c:15 func() error: strcpy() 'input2' too large for 'buf2' (10 vs 4)
+sm_strlen2.c:18 func() error: strcpy() 'input3' too large for 'buf3' (5 vs 4)
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_strlen3.c b/usr/src/tools/smatch/src/validation/sm_strlen3.c
new file mode 100644
index 0000000000..b147c1a7c3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_strlen3.c
@@ -0,0 +1,20 @@
+#include "check_debug.h"
+
+int strlen(const char *str);
+int strnlen(const char *str, int limit);
+
+int func(void)
+{
+	__smatch_implied(strlen("foo"));
+	__smatch_implied(strnlen("foo", 2));
+}
+
+/*
+ * check-name: Smatch strlen test #3
+ * check-command: smatch -I.. sm_strlen3.c
+ *
+ * check-output-start
+sm_strlen3.c:8 func() implied: strlen("foo") = '3'
+sm_strlen3.c:9 func() implied: strnlen("foo", 2) = '2'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_struct_assign1.c b/usr/src/tools/smatch/src/validation/sm_struct_assign1.c
new file mode 100644
index 0000000000..aa3067ecaf
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_struct_assign1.c
@@ -0,0 +1,31 @@
+#include "check_debug.h"
+
+void memcpy(void *dest, void *src, int size);
+void memset(void *dest, char c, int size);
+
+
+struct foo {
+	int x, y;
+};
+
+void test(void)
+{
+	struct foo src = {1, 41};
+	struct foo dest;
+
+	memcpy(&dest, &src, sizeof(dest));
+	__smatch_implied(dest.x + dest.y);
+	memset(&dest, 0, sizeof(dest));
+	__smatch_implied(dest.x + dest.y);
+
+}
+
+/*
+ * check-name: smatch struct assignment #1
+ * check-command: smatch -I.. sm_struct_assign1.c
+ *
+ * check-output-start
+sm_struct_assign1.c:17 test() implied: dest.x + dest.y = '42'
+sm_struct_assign1.c:19 test() implied: dest.x + dest.y = '0'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_switch.c b/usr/src/tools/smatch/src/validation/sm_switch.c
new file mode 100644
index 0000000000..cd48c3d3ca
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_switch.c
@@ -0,0 +1,59 @@
+//#include <stdlib.h>
+
+struct foo {
+	int a;
+};
+
+struct foo *a;
+struct foo *b;
+struct foo *c;
+struct foo *d;
+int x;
+
+void func (void)
+{
+	a = 0;
+	b = 0;
+	c = 0;
+	d = 0;
+
+	switch(x) {
+	case 1:
+		a = returns_nonnull();
+		break;
+	case 2:
+		b = returns_nonnull();
+		break;
+	case 3:
+		c = returns_nonnull();
+		break;
+	default:
+		d = returns_nonnull();
+	}
+
+	switch(x) {
+	case 1:
+		a->a = 1;
+	case 2:
+		a->a = 2;
+		b->a = 3;
+		break;
+	case 3:
+		c->a = 4;
+		break;
+	case 4:
+		d->a = 5;
+		break;
+	}
+}
+/*
+ * check-name: Smatch switch handling
+ * check-command: smatch --spammy sm_switch.c
+ * check-known-to-fail
+ *
+ * check-output-start
+sm_switch.c:38 func() warn: missing break? reassigning 'a->a'
+sm_switch.c:38 func() error: potential NULL dereference 'a'.
+sm_switch.c:39 func() error: potential NULL dereference 'b'.
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_switch2.c b/usr/src/tools/smatch/src/validation/sm_switch2.c
new file mode 100644
index 0000000000..4eb788f878
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_switch2.c
@@ -0,0 +1,51 @@
+struct foo {
+	int a;
+};
+
+struct foo *a;
+struct foo *b;
+struct foo *c;
+struct foo *d;
+int x;
+
+void func (void)
+{
+	a = 0;
+	b = 0;
+	c = 0;
+	d = 0;
+
+	if (x == 1)
+		a = some_func();
+	else if (x == 2)
+		b = some_func();
+	else if (x == 3)
+		c = some_func();
+	else
+		d = some_func();
+
+	switch(x) {
+	case 1:
+		a->a = 1;
+	case 2:
+		a->a = 2;
+		b->a = 3;
+		break;
+	case 3:
+		c->a = 4;
+		break;
+	case 4:
+		d->a = 5;
+		break;
+	}
+}
+/*
+ * check-name: Smatch switch handling #2
+ * check-command: smatch --spammy sm_switch2.c
+ *
+ * check-output-start
+sm_switch2.c:31 func() warn: missing break? reassigning 'a->a'
+sm_switch2.c:31 func() error: potential NULL dereference 'a'.
+sm_switch2.c:32 func() error: potential NULL dereference 'b'.
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_switch3.c b/usr/src/tools/smatch/src/validation/sm_switch3.c
new file mode 100644
index 0000000000..0478ef0bd6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_switch3.c
@@ -0,0 +1,49 @@
+#include "check_debug.h"
+
+int a, b;
+
+int frob(void);
+
+int test(int size)
+{
+	a = 0;
+
+	if (({switch (frob()) {
+		case 1:
+			a = 2;
+			break;
+		default:
+			a = 3;
+	     }
+	     b;}))
+		;
+	__smatch_implied(a);
+
+	a = 4;
+
+	if (({switch (2) {
+		case 1:
+			a = 5;
+			break;
+		case 2:
+			a = 6;
+			break;
+		default:
+			a = 7;
+	     }
+	     b;}))
+		;
+	__smatch_implied(a);
+
+	return 0;
+}
+
+/*
+ * check-name: smatch: switch #3
+ * check-command: smatch -I.. sm_switch3.c
+ *
+ * check-output-start
+sm_switch3.c:20 test() implied: a = '2-3'
+sm_switch3.c:36 test() implied: a = '6'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_user_data1.c b/usr/src/tools/smatch/src/validation/sm_user_data1.c
new file mode 100644
index 0000000000..a9d893c7cb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_user_data1.c
@@ -0,0 +1,30 @@
+#include "check_debug.h"
+
+int copy_from_user(void *dest, void *src, int size);
+
+struct my_struct {
+	int x, y;
+};
+
+void *pointer;
+
+void copy_stuff(struct my_struct *foo)
+{
+	copy_from_user(foo, pointer, sizeof(*foo));
+}
+
+void test(void)
+{
+	struct my_struct foo;
+
+	copy_stuff(&foo);
+	__smatch_user_rl(foo.x);
+}
+/*
+ * check-name: smatch user data #1
+ * check-command: smatch -p=kernel -I.. sm_user_data1.c
+ *
+ * check-output-start
+sm_user_data1.c:21 test() user rl: 'foo.x' = 's32min-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_user_data2.c b/usr/src/tools/smatch/src/validation/sm_user_data2.c
new file mode 100644
index 0000000000..65fca8ab76
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_user_data2.c
@@ -0,0 +1,32 @@
+#include "check_debug.h"
+
+int copy_from_user(void *dest, void *src, int size){}
+
+struct my_struct {
+	int x, y;
+};
+
+void *pointer;
+struct my_struct *dest;
+
+struct my_struct *returns_copy(void)
+{
+	copy_from_user(dest, pointer, sizeof(*dest));
+	return dest;
+}
+
+struct my_struct *a;
+void test(void)
+{
+	a = returns_copy();
+	__smatch_user_rl(a->x);
+}
+
+/*
+ * check-name: smatch user data #2
+ * check-command: smatch -p=kernel -I.. sm_user_data2.c
+ *
+ * check-output-start
+sm_user_data2.c:22 test() user rl: 'a->x' = 's32min-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_user_data3.c b/usr/src/tools/smatch/src/validation/sm_user_data3.c
new file mode 100644
index 0000000000..7819616fcb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_user_data3.c
@@ -0,0 +1,35 @@
+#include "check_debug.h"
+
+int copy_from_user(void *dest, void *src, int size){}
+
+struct my_struct {
+	int x, y;
+};
+
+struct my_struct *returns_filter(struct my_struct *p)
+{
+	return p;
+}
+
+struct my_struct *src, *a, *b;
+void test(void)
+{
+	copy_from_user(a, src, sizeof(*a));
+	b = returns_filter(a);
+	__smatch_user_rl(b->y);
+	b = returns_filter(src);
+	__smatch_user_rl(b->y);
+	b = returns_filter(a);
+	__smatch_user_rl(b->y);
+}
+
+/*
+ * check-name: smatch user data #3
+ * check-command: smatch -p=kernel -I.. sm_user_data3.c
+ *
+ * check-output-start
+sm_user_data3.c:19 test() user rl: 'b->y' = 's32min-s32max'
+sm_user_data3.c:21 test() user rl: 'b->y' = ''
+sm_user_data3.c:23 test() user rl: 'b->y' = 's32min-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_user_data4.c b/usr/src/tools/smatch/src/validation/sm_user_data4.c
new file mode 100644
index 0000000000..a249ea0db4
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_user_data4.c
@@ -0,0 +1,45 @@
+#include "check_debug.h"
+
+int copy_from_user(void *dest, void *src, int size);
+
+struct ear {
+	int x, y;
+};
+
+void *src;
+int returns_user_data(void)
+{
+	int x;
+
+	copy_from_user(&x, src, sizeof(int));
+	return x;
+}
+
+struct ear *dest;
+struct ear *returns_user_member(void)
+{
+	copy_from_user(&dest->x, src, sizeof(int));
+	return dest;
+}
+void test(void)
+{
+	struct ear *p;
+	int x;
+
+	x = returns_user_data();
+	__smatch_user_rl(x);
+	p = returns_user_member();
+	__smatch_user_rl(p);
+	__smatch_user_rl(p->x);
+}
+
+/*
+ * check-name: smatch user data #4
+ * check-command: smatch -p=kernel -I.. sm_user_data4.c
+ *
+ * check-output-start
+sm_user_data4.c:30 test() user rl: 'x' = 's32min-s32max'
+sm_user_data4.c:32 test() user rl: 'p' = ''
+sm_user_data4.c:33 test() user rl: 'p->x' = 's32min-s32max'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_val_parse1.c b/usr/src/tools/smatch/src/validation/sm_val_parse1.c
new file mode 100644
index 0000000000..f1c1fcd56b
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_val_parse1.c
@@ -0,0 +1,17 @@
+#include "check_debug.h"
+
+int main(int x)
+{
+	x = __smatch_type_rl(int, "s32min-s32max[$2 + 4]", 5);
+	__smatch_implied(x);
+
+	return 0;
+}
+/*
+ * check-name: smatch parse value
+ * check-command: smatch -I.. sm_val_parse1.c
+ *
+ * check-output-start
+sm_val_parse1.c:6 main() implied: x = '9'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_wine_filehandles.c b/usr/src/tools/smatch/src/validation/sm_wine_filehandles.c
new file mode 100644
index 0000000000..2b6ee4459d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_wine_filehandles.c
@@ -0,0 +1,26 @@
+void * CreateFile();
+void * socket();
+
+int func (void)
+{
+	int *x;
+
+	if (x = CreateFile()) {
+		
+	}
+
+	x = socket();
+	if (x != 0) {
+	      
+	}
+	return;
+}
+/*
+ * check-name: use INVALID_HANDLE_VALUE not zero
+ * check-command: smatch -p=wine sm_wine_filehandles.c
+ *
+ * check-output-start
+sm_wine_filehandles.c:8 func() error: comparing a filehandle against zero 'x'
+sm_wine_filehandles.c:13 func() error: comparing a filehandle against zero 'x'
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/sm_wine_locking.c b/usr/src/tools/smatch/src/validation/sm_wine_locking.c
new file mode 100644
index 0000000000..10c03b54ec
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/sm_wine_locking.c
@@ -0,0 +1,45 @@
+int create_window_handle(int x);
+void WIN_ReleasePtr(int x);
+void EnterCriticalSection(int x);
+void LeaveCriticalSection(int x);
+void USER_Lock(void);
+void USER_Unlock(void);
+int GDI_GetObjPtr(int x);
+void GDI_ReleaseObj(int x);
+
+int a, b, c, d, e, z;
+
+void test1(void)
+{
+	b = create_window_handle(a);
+	z = frob();
+
+	if (d = GDI_GetObjPtr(e))
+		GDI_ReleaseObj(e);
+	if (GDI_GetObjPtr(e))
+		GDI_ReleaseObj(e);
+	EnterCriticalSection(c);
+	USER_Lock();
+	if (b) {
+		LeaveCriticalSection(c);
+		WIN_ReleasePtr(b);
+	}
+	WIN_ReleasePtr(b);
+	if (z)
+		return;
+	USER_Unlock();
+	if (!b)
+		LeaveCriticalSection(c);
+}
+/*
+ * check-name: WINE locking
+ * check-command: smatch -p=wine --spammy sm_wine_locking.c
+ *
+ * check-output-start
+sm_wine_locking.c:27 test1() error: double unlock 'create_window_handle:b'
+sm_wine_locking.c:29 test1() warn: 'CriticalSection:c' is sometimes locked here and sometimes unlocked.
+sm_wine_locking.c:32 test1() warn: inconsistent returns 'USER_Lock:'.
+  Locked on:   line 29
+  Unlocked on: line 32
+ * check-output-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/smatch_db_test.sh b/usr/src/tools/smatch/src/validation/smatch_db_test.sh
new file mode 100755
index 0000000000..a72a400524
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/smatch_db_test.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+rm -f smatch_db.sqlite
+
+./build_smatch_db.sh $*
+../smatch $*
+
+rm smatch_db.sqlite
+
diff --git a/usr/src/tools/smatch/src/validation/specifiers1.c b/usr/src/tools/smatch/src/validation/specifiers1.c
new file mode 100644
index 0000000000..1a4e1d57ea
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/specifiers1.c
@@ -0,0 +1,101 @@
+static void OK(void)
+{
+#define TEST(x) { T a; x *b = &a; }
+#define TEST2(x, y) TEST(x y) TEST(y x)
+#define TEST3(x, y, z) TEST(x y z) TEST(x z y) TEST(y x z) \
+		       TEST(y z x) TEST(z x y) TEST(z y x)
+#define TEST4(x, y, z, w) TEST2(x y, z w) TEST2(x y, w z) \
+			  TEST2(y x, z w) TEST2(y x, w z) \
+			  TEST2(x z, y w) TEST2(x z, w y) \
+			  TEST2(z x, y w) TEST2(z x, w y) \
+			  TEST2(x w, y z) TEST2(x w, z y) \
+			  TEST2(w x, y z) TEST2(w x, z y)
+
+
+#define T char
+TEST(char)
+#undef T
+
+#define T signed char
+TEST2(char, signed)
+#undef T
+
+#define T unsigned char
+TEST2(char, unsigned)
+#undef T
+
+#define T short
+TEST(short)
+TEST2(int, short)
+#undef T
+
+#define T int
+TEST(int)
+#undef T
+
+#define T long
+TEST(long)
+TEST2(int, long)
+#undef T
+
+#define T long long
+TEST2(long, long)
+TEST3(int, long, long)
+#undef T
+
+#define T signed short
+TEST2(short, signed)
+TEST3(int, short, signed)
+#undef T
+
+#define T signed
+TEST(signed)
+TEST2(int, signed)
+#undef T
+
+#define T signed long
+TEST2(long, signed)
+TEST3(int, long, signed)
+#undef T
+
+#define T signed long long
+TEST3(long, long, signed)
+TEST4(int, long, long, signed)
+#undef T
+
+#define T unsigned short
+TEST2(short, unsigned)
+TEST3(int, short, unsigned)
+#undef T
+
+#define T unsigned
+TEST(unsigned)
+TEST2(int, unsigned)
+#undef T
+
+#define T unsigned long
+TEST2(long, unsigned)
+TEST3(int, long, unsigned)
+#undef T
+
+#define T unsigned long long
+TEST3(long, long, unsigned)
+TEST4(int, long, long, unsigned)
+#undef T
+
+#define T float
+TEST(float)
+#undef T
+
+#define T double
+TEST(double)
+#undef T
+
+#define T long double
+TEST2(double, long)
+#undef T
+}
+/*
+ * check-name: valid specifier combinations
+ * check-command: sparse $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/specifiers2.c b/usr/src/tools/smatch/src/validation/specifiers2.c
new file mode 100644
index 0000000000..d5be118bd2
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/specifiers2.c
@@ -0,0 +1,152 @@
+typedef int T;
+void BAD(
+char char,
+char int,
+char double,
+char float,
+char long,
+char short,
+int char,
+int int,
+int double,
+int float,
+double char,
+double int,
+double double,
+double float,
+double short,
+double signed,
+double unsigned,
+float char,
+float int,
+float double,
+float float,
+float short,
+float long,
+float signed,
+float unsigned,
+short char,
+short double,
+short float,
+short short,
+short long,
+long char,
+long float,
+long short,
+signed double,
+signed float,
+signed signed,
+signed unsigned,
+unsigned double,
+unsigned float,
+unsigned signed,
+unsigned unsigned,
+unsigned signed,
+long long long,
+long double long,
+long long double,
+double long long,
+T char,
+T int,
+T double,
+T float,
+T short,
+T long,
+T signed,
+T unsigned,
+T void,
+void char,
+void int,
+void double,
+void float,
+void short,
+void long,
+void signed,
+void unsigned,
+char void,
+int void,
+double void,
+float void,
+short void,
+long void,
+signed void,
+unsigned void,
+void void
+);
+/*
+ * check-name: invalid specifier combinations
+ * check-error-start
+specifiers2.c:3:6: error: two or more data types in declaration specifiers
+specifiers2.c:4:6: error: two or more data types in declaration specifiers
+specifiers2.c:5:6: error: two or more data types in declaration specifiers
+specifiers2.c:6:6: error: two or more data types in declaration specifiers
+specifiers2.c:7:6: error: impossible combination of type specifiers: char long
+specifiers2.c:8:6: error: impossible combination of type specifiers: char short
+specifiers2.c:9:5: error: two or more data types in declaration specifiers
+specifiers2.c:10:5: error: two or more data types in declaration specifiers
+specifiers2.c:11:5: error: two or more data types in declaration specifiers
+specifiers2.c:12:5: error: two or more data types in declaration specifiers
+specifiers2.c:13:8: error: two or more data types in declaration specifiers
+specifiers2.c:14:8: error: two or more data types in declaration specifiers
+specifiers2.c:15:8: error: two or more data types in declaration specifiers
+specifiers2.c:16:8: error: two or more data types in declaration specifiers
+specifiers2.c:17:8: error: impossible combination of type specifiers: double short
+specifiers2.c:18:8: error: impossible combination of type specifiers: double signed
+specifiers2.c:19:8: error: impossible combination of type specifiers: double unsigned
+specifiers2.c:20:7: error: two or more data types in declaration specifiers
+specifiers2.c:21:7: error: two or more data types in declaration specifiers
+specifiers2.c:22:7: error: two or more data types in declaration specifiers
+specifiers2.c:23:7: error: two or more data types in declaration specifiers
+specifiers2.c:24:7: error: impossible combination of type specifiers: float short
+specifiers2.c:25:7: error: impossible combination of type specifiers: float long
+specifiers2.c:26:7: error: impossible combination of type specifiers: float signed
+specifiers2.c:27:7: error: impossible combination of type specifiers: float unsigned
+specifiers2.c:28:7: error: impossible combination of type specifiers: short char
+specifiers2.c:29:7: error: impossible combination of type specifiers: short double
+specifiers2.c:30:7: error: impossible combination of type specifiers: short float
+specifiers2.c:31:7: error: impossible combination of type specifiers: short short
+specifiers2.c:32:7: error: impossible combination of type specifiers: short long
+specifiers2.c:33:6: error: impossible combination of type specifiers: long char
+specifiers2.c:34:6: error: impossible combination of type specifiers: long float
+specifiers2.c:35:6: error: impossible combination of type specifiers: long short
+specifiers2.c:36:8: error: impossible combination of type specifiers: signed double
+specifiers2.c:37:8: error: impossible combination of type specifiers: signed float
+specifiers2.c:38:8: error: impossible combination of type specifiers: signed signed
+specifiers2.c:39:8: error: impossible combination of type specifiers: signed unsigned
+specifiers2.c:40:10: error: impossible combination of type specifiers: unsigned double
+specifiers2.c:41:10: error: impossible combination of type specifiers: unsigned float
+specifiers2.c:42:10: error: impossible combination of type specifiers: unsigned signed
+specifiers2.c:43:10: error: impossible combination of type specifiers: unsigned unsigned
+specifiers2.c:44:10: error: impossible combination of type specifiers: unsigned signed
+specifiers2.c:45:11: error: impossible combination of type specifiers: long long long
+specifiers2.c:46:13: error: impossible combination of type specifiers: long long double
+specifiers2.c:47:11: error: impossible combination of type specifiers: long long double
+specifiers2.c:48:13: error: impossible combination of type specifiers: long long double
+specifiers2.c:49:3: error: two or more data types in declaration specifiers
+specifiers2.c:50:3: error: two or more data types in declaration specifiers
+specifiers2.c:51:3: error: two or more data types in declaration specifiers
+specifiers2.c:52:3: error: two or more data types in declaration specifiers
+specifiers2.c:53:3: error: two or more data types in declaration specifiers
+specifiers2.c:54:3: error: two or more data types in declaration specifiers
+specifiers2.c:55:3: error: two or more data types in declaration specifiers
+specifiers2.c:56:3: error: two or more data types in declaration specifiers
+specifiers2.c:57:3: error: two or more data types in declaration specifiers
+specifiers2.c:58:6: error: two or more data types in declaration specifiers
+specifiers2.c:59:6: error: two or more data types in declaration specifiers
+specifiers2.c:60:6: error: two or more data types in declaration specifiers
+specifiers2.c:61:6: error: two or more data types in declaration specifiers
+specifiers2.c:62:6: error: two or more data types in declaration specifiers
+specifiers2.c:63:6: error: two or more data types in declaration specifiers
+specifiers2.c:64:6: error: two or more data types in declaration specifiers
+specifiers2.c:65:6: error: two or more data types in declaration specifiers
+specifiers2.c:66:6: error: two or more data types in declaration specifiers
+specifiers2.c:67:5: error: two or more data types in declaration specifiers
+specifiers2.c:68:8: error: two or more data types in declaration specifiers
+specifiers2.c:69:7: error: two or more data types in declaration specifiers
+specifiers2.c:70:7: error: impossible combination of type specifiers: short void
+specifiers2.c:71:6: error: impossible combination of type specifiers: long void
+specifiers2.c:72:8: error: impossible combination of type specifiers: signed void
+specifiers2.c:73:10: error: impossible combination of type specifiers: unsigned void
+specifiers2.c:74:6: error: two or more data types in declaration specifiers
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/static-forward-decl.c b/usr/src/tools/smatch/src/validation/static-forward-decl.c
new file mode 100644
index 0000000000..daad1ecb11
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/static-forward-decl.c
@@ -0,0 +1,13 @@
+static int f(void);
+
+int f(void)
+{
+	return 0;
+}
+/*
+ * check-name: static forward declaration
+ *
+ * check-error-start
+static-forward-decl.c:3:5: warning: symbol 'f' was not declared. Should it be static?
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/static_assert.c b/usr/src/tools/smatch/src/validation/static_assert.c
new file mode 100644
index 0000000000..d9e96294fd
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/static_assert.c
@@ -0,0 +1,71 @@
+_Static_assert(1, "global ok");
+
+struct foo {
+	_Static_assert(1, "struct ok");
+};
+
+void bar(void)
+{
+	_Static_assert(1, " func1 ok");
+	int i;
+	i = 0;
+	_Static_assert(1, " func2 ok");
+
+	if (1) {
+		_Static_assert(1, " func3 ok");
+	}
+}
+
+_Static_assert(0, "expected assertion failure");
+
+static int f;
+_Static_assert(f, "non-constant expression");
+
+static int *p;
+_Static_assert(p, "non-integer expression");
+
+_Static_assert(0.1, "float expression");
+
+_Static_assert(!0 == 1, "non-trivial expression");
+
+static char array[4];
+_Static_assert(sizeof(array) == 4, "sizeof expression");
+
+static const char non_literal_string[] = "non literal string";
+_Static_assert(0, non_literal_string);
+
+_Static_assert(1 / 0, "invalid expression: should not show up?");
+
+struct s {
+	char arr[16];
+	_Static_assert(1, "inside struct");
+};
+
+union u {
+	char c;
+	int  i;
+	_Static_assert(1, "inside union");
+};
+
+_Static_assert(sizeof(struct s) == 16, "sizeof assertion");
+
+_Static_assert(1, );
+_Static_assert(, "");
+_Static_assert(,);
+
+/*
+ * check-name: static assertion
+ *
+ * check-error-start
+static_assert.c:19:16: error: static assertion failed: "expected assertion failure"
+static_assert.c:22:16: error: bad constant expression
+static_assert.c:25:16: error: bad constant expression
+static_assert.c:27:16: error: bad constant expression
+static_assert.c:35:19: error: bad or missing string literal
+static_assert.c:37:18: error: bad constant expression
+static_assert.c:52:19: error: bad or missing string literal
+static_assert.c:53:16: error: Expected constant expression
+static_assert.c:54:16: error: Expected constant expression
+static_assert.c:54:17: error: bad or missing string literal
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/strict-prototypes0.c b/usr/src/tools/smatch/src/validation/strict-prototypes0.c
new file mode 100644
index 0000000000..e320846b77
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/strict-prototypes0.c
@@ -0,0 +1,7 @@
+extern void func1();
+extern void myfunction(), myfunc2();
+
+/*
+ * check-name: strict-prototypes disabled
+ * check-command: sparse -Wno-strict-prototypes $file
+ */
diff --git a/usr/src/tools/smatch/src/validation/strict-prototypes1.c b/usr/src/tools/smatch/src/validation/strict-prototypes1.c
new file mode 100644
index 0000000000..7e4ce6bbfb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/strict-prototypes1.c
@@ -0,0 +1,14 @@
+extern void func0();
+extern void func1(), func2();
+
+/*
+ * check-name: strict-prototypes enabled
+ * check-command: sparse -Wstrict-prototypes $file
+ * check-known-to-fail
+ *
+ * check-error-start
+strict-prototypes1.c:1:18: warning: non-ANSI function declaration of function 'func0'
+strict-prototypes1.c:2:18: warning: non-ANSI function declaration of function 'func1'
+strict-prototypes1.c:2:27: warning: non-ANSI function declaration of function 'func2'
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/struct-as.c b/usr/src/tools/smatch/src/validation/struct-as.c
new file mode 100644
index 0000000000..f31f7c9664
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/struct-as.c
@@ -0,0 +1,19 @@
+/*
+ * Structure members should get the address
+ * space of their pointer.
+ */
+#define __user __attribute__((address_space(1)))
+
+struct hello {
+	int a;
+};
+
+extern int test(int __user *ip);
+
+static int broken(struct hello __user *sp)
+{
+	test(&sp->a);
+}
+/*
+ * check-name: Address space of a struct member
+ */
diff --git a/usr/src/tools/smatch/src/validation/struct-attribute-placement.c b/usr/src/tools/smatch/src/validation/struct-attribute-placement.c
new file mode 100644
index 0000000000..53c1214356
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/struct-attribute-placement.c
@@ -0,0 +1,6 @@
+struct __attribute__((__aligned__(16))) foo {
+    int a;
+};
+/*
+ * check-name: struct attribute placement
+ */
diff --git a/usr/src/tools/smatch/src/validation/struct-ns1.c b/usr/src/tools/smatch/src/validation/struct-ns1.c
new file mode 100644
index 0000000000..096bb5d904
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/struct-ns1.c
@@ -0,0 +1,20 @@
+// This actually isn't allowed in C99, but sparse and gcc will take it:
+enum Foo;
+
+static void
+f (void)
+{
+  enum Foo *pefoo;         // Pointer to incomplete type
+  struct Foo;              // Forward declaration
+  struct Foo *psfoo;       // Pointer to incomplete type
+  {
+    struct Foo { int foo; }; // Local definition.
+    struct Foo foo;          // variable declaration.
+    foo.foo = 1;
+  }
+}
+
+enum Foo { FOO };
+/*
+ * check-name: struct namespaces #1
+ */
diff --git a/usr/src/tools/smatch/src/validation/struct-ns2.c b/usr/src/tools/smatch/src/validation/struct-ns2.c
new file mode 100644
index 0000000000..c5afbb71aa
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/struct-ns2.c
@@ -0,0 +1,25 @@
+static void
+g (struct Bar { int i; } *x)
+{
+  struct Bar y;
+  y.i = 1;
+}
+
+static void
+h (void)
+{
+  // This is not in scope and should barf loudly.
+  struct Bar y;
+  y.i = 1;
+}
+
+/*
+ * check-name: struct not in scope
+ * check-known-to-fail
+ *
+ * check-error-start
+struct-ns2.c:2:11: warning: bad scope for 'struct Bar'
+struct-ns2.c:12:14: error: incomplete type/unknown size for 'y'
+struct-ns2.c:13:5: error: using member 'i' in incomplete 'struct Bar'
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/struct-size1.c b/usr/src/tools/smatch/src/validation/struct-size1.c
new file mode 100644
index 0000000000..cf956a41ca
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/struct-size1.c
@@ -0,0 +1,21 @@
+struct A;
+struct B {
+  struct A *pA;
+};
+struct C;
+struct E {
+  struct A **pA;
+  struct C *pC;
+};
+static void f(struct E *pE, struct B *pB)
+{
+  pB->pA = pE->pA[0];
+}
+static const struct { int x; } foo[] = {{ 1 }};
+struct C {
+  int bar[(sizeof foo/sizeof foo[0])];
+};
+
+/*
+ * check-name: struct size
+ */
diff --git a/usr/src/tools/smatch/src/validation/tautological-compare.c b/usr/src/tools/smatch/src/validation/tautological-compare.c
new file mode 100644
index 0000000000..55a2b46396
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/tautological-compare.c
@@ -0,0 +1,35 @@
+typedef unsigned int u32;
+
+int seq(int a) { return a == a; }
+int sne(int a) { return a != a; }
+int slt(int a) { return a < a; }
+int sgt(int a) { return a > a; }
+int sle(int a) { return a <= a; }
+int sge(int a) { return a >= a; }
+
+u32 ueq(u32 a) { return a == a; }
+u32 une(u32 a) { return a != a; }
+u32 ult(u32 a) { return a < a; }
+u32 ugt(u32 a) { return a > a; }
+u32 ule(u32 a) { return a <= a; }
+u32 uge(u32 a) { return a >= a; }
+
+/*
+ * check-name: tautological-compare
+ * check-command: sparse -Wno-decl -Wtautological-compare $file
+ *
+ * check-error-start
+tautological-compare.c:3:30: warning: self-comparison always evaluates to true
+tautological-compare.c:4:30: warning: self-comparison always evaluates to false
+tautological-compare.c:5:29: warning: self-comparison always evaluates to false
+tautological-compare.c:6:29: warning: self-comparison always evaluates to false
+tautological-compare.c:7:30: warning: self-comparison always evaluates to true
+tautological-compare.c:8:30: warning: self-comparison always evaluates to true
+tautological-compare.c:10:30: warning: self-comparison always evaluates to true
+tautological-compare.c:11:30: warning: self-comparison always evaluates to false
+tautological-compare.c:12:29: warning: self-comparison always evaluates to false
+tautological-compare.c:13:29: warning: self-comparison always evaluates to false
+tautological-compare.c:14:30: warning: self-comparison always evaluates to true
+tautological-compare.c:15:30: warning: self-comparison always evaluates to true
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/test-be.c b/usr/src/tools/smatch/src/validation/test-be.c
new file mode 100644
index 0000000000..deda3cc14f
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/test-be.c
@@ -0,0 +1,46 @@
+int printf(char *c, ...);
+void exit(int c);
+
+#undef PRINT_OUTPUTS
+
+static void test_func_args(int x, int y)
+{
+	if (x == y)
+		exit(1);
+}
+
+static int binop_s32(int x, int y)
+{
+	int a;
+
+	a = a + x;
+	a = a / y;
+	a = a * x;
+	a = a - y;
+
+	return a;
+}
+
+static void test_binops(void)
+{
+	int tmp_s32 = binop_s32(987123, 234);
+
+#ifdef PRINT_OUTPUTS
+	printf("binop_s32(987123, 234) == %d\n", tmp_s32);
+#else
+	if (tmp_s32 != -1470599007)
+		exit(2);
+#endif
+}
+
+int main (int argc, char *argv[])
+{
+	test_func_args(1, 2);
+	test_binops();
+
+	return 0;
+}
+
+/*
+ * check-name: binary operations
+ */
diff --git a/usr/src/tools/smatch/src/validation/test-suite b/usr/src/tools/smatch/src/validation/test-suite
new file mode 100755
index 0000000000..5e10942750
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/test-suite
@@ -0,0 +1,396 @@
+#!/bin/sh
+
+#set -x
+
+cd $(dirname "$0")
+
+default_path=".."
+default_cmd="sparse \$file"
+tests_list=`find . -name '*.c' | sed -e 's#^\./\(.*\)#\1#' | sort`
+prog_name=`basename $0`
+
+if [ ! -x "$default_path/sparse-llvm" ]; then
+	disabled_cmds="sparsec sparsei sparse-llvm"
+fi
+
+# flags:
+#	- some tests gave an unexpected result
+failed=0
+
+# counts:
+#	- tests that have not been converted to test-suite format
+#	- tests that are disabled
+#	- tests that passed
+#	- tests that failed
+#	- tests that failed but are known to fail
+unhandled_tests=0
+disabled_tests=0
+ok_tests=0
+ko_tests=0
+known_ko_tests=0
+
+# defaults to not verbose
+[ -z "$V" ] && V=0
+[ $V -eq 0 ] && quiet=1 || quiet=0
+
+##
+# get_tag_value(file) - get the 'check-<...>' tags & values
+get_tag_value()
+{
+	check_name=""
+	check_command="$default_cmd"
+	check_exit_value=0
+	check_timeout=0
+	check_known_to_fail=0
+	check_error_ignore=0
+	check_output_ignore=0
+	check_output_contains=0
+	check_output_excludes=0
+	check_output_pattern=0
+
+	lines=$(grep 'check-[a-z-]*' $1 | \
+		sed -e 's/^.*\(check-[a-z-]*:*\) *\(.*\)$/\1 \2/')
+
+	while read tag val; do
+		#echo "-> tag: '$tag'"
+		#echo "-> val: '$val'"
+		case $tag in
+		check-name:)		check_name="$val" ;;
+		check-command:)		check_command="$val" ;;
+		check-exit-value:)	check_exit_value="$val" ;;
+		check-timeout:)		[ -z "$val" ] && val=1
+					check_timeout="$val" ;;
+		check-known-to-fail)	check_known_to_fail=1 ;;
+		check-error-ignore)	check_error_ignore=1 ;;
+		check-output-ignore)	check_output_ignore=1 ;;
+		check-output-contains:)	check_output_contains=1 ;;
+		check-output-excludes:)	check_output_excludes=1 ;;
+		check-output-pattern-)	check_output_pattern=1 ;;
+		esac
+	done << EOT
+	$lines
+EOT
+}
+
+##
+# helper for has_(each|none)_patterns()
+has_patterns()
+{
+	ifile="$1"
+	patt="$2"
+	ofile="$3"
+	cmp="$4"
+	grep "$patt:" "$ifile" | \
+	sed -e "s/^.*$patt: *\(.*\)$/\1/" | \
+	while read val; do
+		grep -s -q "$val" "$ofile"
+		if [ "$?" $cmp 0 ]; then
+			return 1
+		fi
+	done
+
+	return $?
+}
+
+##
+# has_each_patterns(ifile tag ofile) - does ofile contains some
+#                        of the patterns given by ifile's tags?
+#
+# returns 0 if all present, 1 otherwise
+has_each_patterns()
+{
+	has_patterns "$1" "$2" "$3" -ne
+}
+
+##
+# has_none_patterns(ifile tag ofile) - does ofile contains some
+#                        of the patterns given by ifile's tags?
+#
+# returns 1 if any present, 0 otherwise
+has_none_patterns()
+{
+	has_patterns "$1" "$2" "$3" -eq
+}
+
+##
+# nbr_patterns(ifile tag ofile) - does ofile contains the
+#                        the patterns given by ifile's tags
+#                        the right number of time?
+nbr_patterns()
+{
+	ifile="$1"
+	patt="$2"
+	ofile="$3"
+	grep "$patt-[0-9][0-9]*-times:" "$ifile" | \
+	sed -e "s/^.*$patt-\([0-9][0-9]*\)-times: *\(.*\)/\1 \2/" | \
+	while read nbr pat; do
+		n=$(grep -s "$pat" "$ofile" | wc -l)
+		if [ "$n" -ne "$nbr" ]; then
+			return 1
+		fi
+	done
+
+	return $?
+}
+
+##
+# verbose(string) - prints string if we are in verbose mode
+verbose()
+{
+	[ "$V" -eq "1" ] && echo "        $1"
+	return 0
+}
+
+##
+# error(string[, die]) - prints an error and exits with value die if given
+error()
+{
+	[ "$quiet" -ne 1 ] && echo "error: $1"
+	[ -n "$2" ] && exit $2
+	return 0
+}
+
+do_usage()
+{
+echo "$prog_name - a tiny automatic testing script"
+echo "Usage: $prog_name [command] [command arguments]"
+echo
+echo "commands:"
+echo "    none                       runs the whole test suite"
+echo "    single file                runs the test in 'file'"
+echo "    format file [name [cmd]]   helps writing a new test case using cmd"
+echo
+echo "    help                       prints usage"
+}
+
+##
+# do_test(file) - tries to validate a test case
+#
+# it "parses" file, looking for check-* tags and tries to validate
+# the test against an expected result
+# returns:
+#	- 0 if the test passed,
+#	- 1 if it failed,
+#	- 2 if it is not a "test-suite" test.
+#	- 3 if the test is disabled.
+do_test()
+{
+	test_failed=0
+	file="$1"
+
+	get_tag_value $file
+
+	# can this test be handled by test-suite ?
+	# (it has to have a check-name key in it)
+	if [ "$check_name" = "" ]; then
+		echo "warning: test '$file' unhandled"
+		unhandled_tests=$(($unhandled_tests + 1))
+		return 2
+	fi
+	test_name="$check_name"
+
+	# does the test provide a specific command ?
+	if [ "$check_command" = "" ]; then
+		check_command="$defaut_command"
+	fi
+
+	# check for disabled commands
+	set -- $check_command
+	base_cmd=$1
+	for i in $disabled_cmds; do
+		if [ "$i" = "$base_cmd" ] ; then
+			disabled_tests=$(($disabled_tests + 1))
+			echo "     DISABLE $test_name ($file)"
+			return 3
+		fi
+	done
+
+	cmd=`eval echo $default_path/$check_command`
+
+	echo "     TEST    $test_name ($file)"
+
+	verbose "Using command       : $cmd"
+
+	# grab the expected exit value
+	expected_exit_value=$check_exit_value
+	verbose "Expecting exit value: $expected_exit_value"
+
+	# do we want a timeout?
+	if [ $check_timeout -ne 0 ]; then
+		cmd="timeout -k 1s $check_timeout $cmd"
+	fi
+
+	# grab the actual output & exit value
+	$cmd 1> $file.output.got 2> $file.error.got
+	actual_exit_value=$?
+
+	must_fail=$check_known_to_fail
+	quiet=0
+	[ $must_fail -eq 1 ] && [ $V -eq 0 ] && quiet=1
+	known_ko_tests=$(($known_ko_tests + $must_fail))
+
+	for stream in output error; do
+		eval ignore=\$check_${stream}_ignore
+		[ $ignore -eq 1 ] && continue
+
+		# grab the expected output
+		sed -n "/check-$stream-start/,/check-$stream-end/p" $file \
+		| grep -v check-$stream > "$file".$stream.expected
+
+		diff -u "$file".$stream.expected "$file".$stream.got > "$file".$stream.diff
+		if [ "$?" -ne "0" ]; then
+			error "actual $stream text does not match expected $stream text."
+			error  "see $file.$stream.* for further investigation."
+			[ $quiet -ne 1 ] && cat "$file".$stream.diff
+			test_failed=1
+		fi
+	done
+
+	if [ "$actual_exit_value" -ne "$expected_exit_value" ]; then
+		error "Actual exit value does not match the expected one."
+		error "expected $expected_exit_value, got $actual_exit_value."
+		test_failed=1
+	fi
+
+	# verify the 'check-output-contains/excludes' tags
+	if [ $check_output_contains -eq 1 ]; then
+		has_each_patterns "$file" 'check-output-contains' $file.output.got
+		if [ "$?" -ne "0" ]; then
+			error "Actual output doesn't contain some of the expected patterns."
+			test_failed=1
+		fi
+	fi
+	if [ $check_output_excludes -eq 1 ]; then
+		has_none_patterns "$file" 'check-output-excludes' $file.output.got
+		if [ "$?" -ne "0" ]; then
+			error "Actual output contains some patterns which are not expected."
+			test_failed=1
+		fi
+	fi
+	if [ $check_output_pattern -eq 1 ]; then
+		# verify the 'check-output-pattern-X-times' tags
+		nbr_patterns "$file" 'check-output-pattern' $file.output.got
+		if [ "$?" -ne "0" ]; then
+			error "Actual output doesn't contain the pattern the expected number."
+			test_failed=1
+		fi
+	fi
+
+	[ "$test_failed" -eq "$must_fail" ] || failed=1
+
+	if [ "$must_fail" -eq "1" ]; then
+		if [ "$test_failed" -eq "1" ]; then
+			echo "info: test '$file' is known to fail"
+		else
+			echo "error: test '$file' is known to fail but succeed!"
+			test_failed=1
+		fi
+	fi
+
+	if [ "$test_failed" -eq "1" ]; then
+		ko_tests=$(($ko_tests + 1))
+	else
+		ok_tests=$(($ok_tests + 1))
+		rm -f $file.{error,output}.{expected,got,diff}
+	fi
+	return $test_failed
+}
+
+do_test_suite()
+{
+	for i in $tests_list; do
+		do_test "$i"
+	done
+
+	# prints some numbers
+	tests_nr=$(($ok_tests + $ko_tests))
+	echo -n "Out of $tests_nr tests, $ok_tests passed, $ko_tests failed"
+	echo " ($known_ko_tests of them are known to fail)"
+	if [ "$unhandled_tests" -ne "0" ]; then
+		echo "$unhandled_tests tests could not be handled by $prog_name"
+	fi
+	if [ "$disabled_tests" -ne "0" ]; then
+		echo "$disabled_tests tests were disabled"
+	fi
+}
+
+##
+# do_format(file[, name[, cmd]]) - helps a test writer to format test-suite tags
+do_format()
+{
+	if [ -z "$2" ]; then
+		fname="$1"
+		fcmd=$default_cmd
+	elif [ -z "$3" ]; then
+		fname="$2"
+		fcmd=$default_cmd
+	else
+		fname="$2"
+		fcmd="$3"
+	fi
+	file="$1"
+	cmd=`eval echo $default_path/$fcmd`
+	$cmd 1> $file.output.got 2> $file.error.got
+	fexit_value=$?
+	cat <<_EOF
+/*
+ * check-name: $fname
+_EOF
+	if [ "$fcmd" != "$default_cmd" ]; then
+		echo " * check-command: $fcmd"
+	fi
+	if [ "$fexit_value" -ne "0" ]; then
+		echo " * check-exit-value: $fexit_value"
+	fi
+	for stream in output error; do
+		if [ -s "$file.$stream.got" ]; then
+			echo " *"
+			echo " * check-$stream-start"
+			cat "$file.$stream.got"
+			echo " * check-$stream-end"
+		fi
+	done
+	echo " */"
+	return 0
+}
+
+##
+# arg_file(filename) - checks if filename exists
+arg_file()
+{
+	[ -z "$1" ] && {
+		do_usage
+		exit 1
+	}
+	[ -e "$1" ] || {
+		error "Can't open file $1"
+		exit 1
+	}
+	return 0
+}
+
+case "$1" in
+	'')
+		do_test_suite
+		;;
+	single)
+		arg_file "$2"
+		do_test "$2"
+		case "$?" in
+			0) echo "$2 passed !";;
+			1) echo "$2 failed !";;
+			2) echo "$2 can't be handled by $prog_name";;
+		esac
+		;;
+	format)
+		arg_file "$2"
+		do_format "$2" "$3" "$4"
+		;;
+	help | *)
+		do_usage
+		exit 1
+		;;
+esac
+
+exit $failed
+
diff --git a/usr/src/tools/smatch/src/validation/testsuite-selfcheck1.c b/usr/src/tools/smatch/src/validation/testsuite-selfcheck1.c
new file mode 100644
index 0000000000..d927f9961e
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/testsuite-selfcheck1.c
@@ -0,0 +1,10 @@
+good
+
+/*
+ * check-name: selfcheck1
+ * check-command: sparse -E $file
+ * check-output-ignore
+ *
+ * check-output-contains: good
+ * check-output-excludes: evil
+ */
diff --git a/usr/src/tools/smatch/src/validation/testsuite-selfcheck2.c b/usr/src/tools/smatch/src/validation/testsuite-selfcheck2.c
new file mode 100644
index 0000000000..5309e32f37
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/testsuite-selfcheck2.c
@@ -0,0 +1,10 @@
+evil
+
+/*
+ * check-name: selfcheck2
+ * check-command: sparse -E $file
+ * check-output-ignore
+ * check-known-to-fail
+ *
+ * check-output-contains: good
+ */
diff --git a/usr/src/tools/smatch/src/validation/testsuite-selfcheck3.c b/usr/src/tools/smatch/src/validation/testsuite-selfcheck3.c
new file mode 100644
index 0000000000..6d834e68d6
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/testsuite-selfcheck3.c
@@ -0,0 +1,10 @@
+evil
+
+/*
+ * check-name: selfcheck3
+ * check-command: sparse -E $file
+ * check-output-ignore
+ * check-known-to-fail
+ *
+ * check-output-excludes: evil
+ */
diff --git a/usr/src/tools/smatch/src/validation/transparent-union.c b/usr/src/tools/smatch/src/validation/transparent-union.c
new file mode 100644
index 0000000000..149c7d9476
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/transparent-union.c
@@ -0,0 +1,25 @@
+struct a {
+	int field;
+};
+struct b {
+	int field;
+};
+
+typedef union {
+	struct a *a;
+	struct b *b;
+} transparent_arg __attribute__((__transparent_union__));
+
+static void foo(transparent_arg arg)
+{
+}
+
+static void bar(void)
+{
+	struct b arg = { 0 };
+	foo((struct a *) &arg);
+}
+
+/*
+ * check-name: Transparent union attribute.
+ */
diff --git a/usr/src/tools/smatch/src/validation/type-attribute-align.c b/usr/src/tools/smatch/src/validation/type-attribute-align.c
new file mode 100644
index 0000000000..473177c562
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/type-attribute-align.c
@@ -0,0 +1,19 @@
+#define	__aligned(N)	__attribute__((aligned(N)))
+#define alignof(X)	__alignof__(X)
+
+struct s {
+	short a, b, c;
+} __aligned(2*sizeof(short));
+
+static int fs(void) { return  sizeof(struct s); }
+static int fa(void) { return alignof(struct s); }
+
+void main(void)
+{
+	_Static_assert( sizeof(struct s) == 4 * sizeof(short), "size");
+	_Static_assert(alignof(struct s) == 2 * sizeof(short), "alignment");
+}
+
+/*
+ * check-name: type-attribute-align
+ */
diff --git a/usr/src/tools/smatch/src/validation/type-attribute-as.c b/usr/src/tools/smatch/src/validation/type-attribute-as.c
new file mode 100644
index 0000000000..43021e49cd
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/type-attribute-as.c
@@ -0,0 +1,33 @@
+#define	__user		__attribute__((address_space(1)))
+
+struct s {
+	int i;
+} __user;
+
+
+extern void use0(void *);
+extern void use1(void __user *);
+
+void main(void)
+{
+	struct s s;
+	int i;
+
+	use0(&s);	// KO
+	use0(&i);	// OK
+	use1(&s);	// OK
+	use1(&i);	// KO
+}
+
+/*
+ * check-name: type-attribute-as
+ *
+ * check-error-start
+type-attribute-as.c:16:15: warning: incorrect type in argument 1 (different address spaces)
+type-attribute-as.c:16:15:    expected void *<noident>
+type-attribute-as.c:16:15:    got struct s <asn:1>*<noident>
+type-attribute-as.c:19:15: warning: incorrect type in argument 1 (different address spaces)
+type-attribute-as.c:19:15:    expected void <asn:1>*<noident>
+type-attribute-as.c:19:15:    got int *<noident>
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/type-attribute-mod.c b/usr/src/tools/smatch/src/validation/type-attribute-mod.c
new file mode 100644
index 0000000000..d55011dfa0
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/type-attribute-mod.c
@@ -0,0 +1,21 @@
+#define	__noderef	__attribute__((noderef))
+
+struct s {
+	int i;
+} __noderef;
+
+
+void main(void)
+{
+	struct s s;
+
+	s.i = 0;
+}
+
+/*
+ * check-name: type-attribute-mod
+ *
+ * check-error-start
+type-attribute-mod.c:12:9: warning: dereference of noderef expression
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/type1.c b/usr/src/tools/smatch/src/validation/type1.c
new file mode 100644
index 0000000000..2a55f2a91c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/type1.c
@@ -0,0 +1,27 @@
+/*
+ * Sparse used to get this wrong.
+ *
+ * When evaluating the argument to the inline function for the array, Sparse
+ * didn't properly demote the "char []" to a "char *", but instead it would
+ * follow the dereference and get a "struct hello".
+ *
+ * Which made no sense at all.
+ */
+
+static inline int deref(const char *s)
+{
+	return *s;
+}
+
+struct hello {
+	char array[10];
+};
+
+static int test(struct hello *arg)
+{
+	return deref(arg->array);
+}
+
+/*
+ * check-name: "char []" to "char *" demotion
+ */
diff --git a/usr/src/tools/smatch/src/validation/typedef_shadow.c b/usr/src/tools/smatch/src/validation/typedef_shadow.c
new file mode 100644
index 0000000000..e52de80f27
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/typedef_shadow.c
@@ -0,0 +1,13 @@
+typedef int T;
+static void f(int T)
+{
+	static T a;
+}
+/*
+ * check-name: typedef shadowing
+ * check-error-start:
+typedef_shadow.c:4:16: warning: 'T' has implicit type
+typedef_shadow.c:4:18: error: Expected ; at end of declaration
+typedef_shadow.c:4:18: error: got a
+ * check-error-end:
+ */
diff --git a/usr/src/tools/smatch/src/validation/typeof-addresspace.c b/usr/src/tools/smatch/src/validation/typeof-addresspace.c
new file mode 100644
index 0000000000..a94f77a3b7
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/typeof-addresspace.c
@@ -0,0 +1,20 @@
+#define	__as		__attribute__((address_space(1)))
+
+static void test_as(void)
+{
+	int __as obj, *ptr;
+	typeof(obj) var = obj;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) var2 = obj;
+	typeof(*ptr) *ptr3 = ptr;	/* check-should-pass */
+	typeof(obj) *ptr4 = ptr;	/* check-should-pass */
+	obj = obj;
+	ptr = ptr;
+	ptr = &obj;
+	obj = *ptr;
+}
+
+/*
+ * check-name: typeof-addresspace.c
+ * check-known-to-fail
+ */
diff --git a/usr/src/tools/smatch/src/validation/typeof-attribute.c b/usr/src/tools/smatch/src/validation/typeof-attribute.c
new file mode 100644
index 0000000000..f79a61c4eb
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/typeof-attribute.c
@@ -0,0 +1,16 @@
+#define __percpu __attribute__((noderef, address_space(3)))
+
+/* Turn v back into a normal var. */
+#define convert(v) \
+       (*(typeof(v) __attribute__((address_space(0), force)) *)(&v))
+
+int main(int argc, char *argv)
+{
+       unsigned int __percpu x;
+
+       convert(x) = 0;
+       return 0;
+}
+/*
+ * check-name: Rusty Russell's typeof attribute casting.
+ */
diff --git a/usr/src/tools/smatch/src/validation/typeof-mods.c b/usr/src/tools/smatch/src/validation/typeof-mods.c
new file mode 100644
index 0000000000..9822e96f6c
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/typeof-mods.c
@@ -0,0 +1,108 @@
+#define	__noderef	__attribute__((noderef))
+#define	__bitwise	__attribute__((bitwise))
+#define	__nocast	__attribute__((nocast))
+#define	__safe		__attribute__((safe))
+
+static void test_spec(void)
+{
+	unsigned int obj, *ptr;
+	typeof(obj) var = obj;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) var2 = obj;
+	typeof(*ptr) *ptr3 = ptr;
+	typeof(obj) *ptr4 = ptr;
+	obj = obj;
+	ptr = ptr;
+	ptr = &obj;
+	obj = *ptr;
+}
+
+static void test_const(void)
+{
+	const int obj, *ptr;
+	typeof(obj) var = obj;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) var2 = obj;
+	typeof(*ptr) *ptr3 = ptr;
+	typeof(obj) *ptr4 = ptr;
+	ptr = ptr;
+	ptr = &obj;
+}
+
+static void test_volatile(void)
+{
+	volatile int obj, *ptr;
+	typeof(obj) var = obj;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) var2 = obj;
+	typeof(*ptr) *ptr3 = ptr;
+	typeof(obj) *ptr4 = ptr;
+	obj = obj;
+	ptr = ptr;
+	ptr = &obj;
+	obj = *ptr;
+}
+
+static void test_bitwise(void)
+{
+	typedef int __bitwise type_t;
+	type_t obj, *ptr;
+	typeof(obj) var = obj;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) var2 = obj;
+	typeof(*ptr) *ptr3 = ptr;
+	typeof(obj) *ptr4 = ptr;
+	obj = obj;
+	ptr = ptr;
+	ptr = &obj;
+	obj = *ptr;
+}
+
+static void test_static(void)
+{
+	static int obj, *ptr;
+	typeof(obj) var = obj;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) var2 = obj;
+	typeof(*ptr) *ptr3 = ptr;
+	typeof(obj) *ptr4 = ptr;
+	obj = obj;
+	ptr = ptr;
+	ptr = &obj;
+	obj = *ptr;
+}
+
+static void test_tls(void)
+{
+	__thread int obj, *ptr;
+	typeof(obj) var = obj;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) var2 = obj;
+	typeof(*ptr) *ptr3 = ptr;
+	typeof(obj) *ptr4 = ptr;
+	obj = obj;
+	ptr = ptr;
+	ptr = &obj;
+	obj = *ptr;
+}
+
+static void test_nocast(void)
+{
+	int __nocast obj, *ptr;
+	typeof(obj) var = obj;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) var2 = obj;
+	typeof(*ptr) *ptr3 = ptr;
+	typeof(obj) *ptr4 = ptr;
+	obj = obj;
+	ptr = ptr;
+	ptr = &obj;
+	obj = *ptr;
+}
+
+/*
+ * check-name: typeof-mods
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/typeof-noderef.c b/usr/src/tools/smatch/src/validation/typeof-noderef.c
new file mode 100644
index 0000000000..e95a53ad46
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/typeof-noderef.c
@@ -0,0 +1,19 @@
+#define	__noderef	__attribute__((noderef))
+
+static void test_noderef(void)
+{
+	int __noderef obj, *ptr;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) *ptr3 = ptr;
+	typeof(obj) *ptr4 = ptr;
+	ptr = ptr;
+	ptr = &obj;
+}
+
+/*
+ * check-name: typeof-noderef
+ * check-known-to-fail
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/typeof-safe.c b/usr/src/tools/smatch/src/validation/typeof-safe.c
new file mode 100644
index 0000000000..614863fba3
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/typeof-safe.c
@@ -0,0 +1,23 @@
+#define	__safe		__attribute__((safe))
+
+static void test_safe(void)
+{
+	int __safe obj, *ptr;
+	typeof(obj) var = obj;
+	typeof(ptr) ptr2 = ptr;
+	typeof(*ptr) var2 = obj;
+	typeof(*ptr) *ptr3 = ptr;
+	typeof(obj) *ptr4 = ptr;
+	obj = obj;
+	ptr = ptr;
+	ptr = &obj;
+	obj = *ptr;
+}
+
+/*
+ * check-name: typeof-safe
+ * check-known-to-fail
+ *
+ * check-error-start
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/typesign.c b/usr/src/tools/smatch/src/validation/typesign.c
new file mode 100644
index 0000000000..e5dc525aff
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/typesign.c
@@ -0,0 +1,61 @@
+static unsigned int * s_to_u_return(signed int *sp)
+{
+	return sp;
+}
+
+static signed int * u_to_s_return(unsigned int *up)
+{
+	return up;
+}
+
+static unsigned int * s_to_u_init(signed int *sp)
+{
+	unsigned int *up = sp;
+	return up;
+}
+
+static signed int * u_to_s_init(unsigned int *up)
+{
+	signed int *sp = up;
+	return sp;
+}
+
+static unsigned int * s_to_u_assign(signed int *sp)
+{
+	unsigned int *up;
+	up = sp;
+	return up;
+}
+
+static signed int * u_to_s_assign(unsigned int *up)
+{
+	signed int *sp;
+	sp = up;
+	return sp;
+}
+
+/*
+ * check-name: -Wtypesign
+ * check-command: sparse -Wtypesign $file
+ *
+ * check-error-start
+typesign.c:3:16: warning: incorrect type in return expression (different signedness)
+typesign.c:3:16:    expected unsigned int *
+typesign.c:3:16:    got signed int *sp
+typesign.c:8:16: warning: incorrect type in return expression (different signedness)
+typesign.c:8:16:    expected signed int *
+typesign.c:8:16:    got unsigned int *up
+typesign.c:13:28: warning: incorrect type in initializer (different signedness)
+typesign.c:13:28:    expected unsigned int *up
+typesign.c:13:28:    got signed int *sp
+typesign.c:19:26: warning: incorrect type in initializer (different signedness)
+typesign.c:19:26:    expected signed int *sp
+typesign.c:19:26:    got unsigned int *up
+typesign.c:26:12: warning: incorrect type in assignment (different signedness)
+typesign.c:26:12:    expected unsigned int *up
+typesign.c:26:12:    got signed int *sp
+typesign.c:33:12: warning: incorrect type in assignment (different signedness)
+typesign.c:33:12:    expected signed int *sp
+typesign.c:33:12:    got unsigned int *up
+ * check-error-end
+ */
diff --git a/usr/src/tools/smatch/src/validation/varargs1.c b/usr/src/tools/smatch/src/validation/varargs1.c
new file mode 100644
index 0000000000..2e3b4295cd
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/varargs1.c
@@ -0,0 +1,8 @@
+extern int foo (const char *, ...);
+static void sparse_error(const char err[])
+{
+  foo("%s\n",err);
+}
+/*
+ * check-name: Varargs bogus warning regression test #1
+ */
diff --git a/usr/src/tools/smatch/src/validation/wide.c b/usr/src/tools/smatch/src/validation/wide.c
new file mode 100644
index 0000000000..847a680f0d
--- /dev/null
+++ b/usr/src/tools/smatch/src/validation/wide.c
@@ -0,0 +1,9 @@
+static char c = L'\x41';
+static int n = 1/(0x41 - L'\x41');
+/*
+ * check-name: wide character constants
+ *
+ * check-error-start
+wide.c:2:17: warning: division by zero
+ * check-error-end
+ */
diff --git a/usr/src/ucbcmd/rusage/Makefile b/usr/src/ucbcmd/rusage/Makefile
index 94907e4de0..23b44d6b90 100644
--- a/usr/src/ucbcmd/rusage/Makefile
+++ b/usr/src/ucbcmd/rusage/Makefile
@@ -22,6 +22,7 @@
 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 PROG= rusage
 
@@ -31,11 +32,14 @@ INC1 = $(SRC)/ucbhead
 
 FILEMODE=	755
 
-LDLIBS +=  -L$(ROOT)/usr/ucblib -R /usr/ucblib -lucb
+LDLIBS +=  -L$(ROOT)/usr/ucblib -R/usr/ucblib -lucb
 
 CPPFLAGS = -I$(INC1) $(CPPFLAGS.master)
 CERRWARN += -_gcc=-Wno-implicit-function-declaration
 
+# missing prototypes
+SMATCH=off
+
 .KEEP_STATE:
 
 all: $(PROG)
diff --git a/usr/src/ucbcmd/tset/Makefile b/usr/src/ucbcmd/tset/Makefile
index 7130f11f5f..36baf6432f 100644
--- a/usr/src/ucbcmd/tset/Makefile
+++ b/usr/src/ucbcmd/tset/Makefile
@@ -22,6 +22,7 @@
 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 PROG= tset
 
@@ -29,7 +30,7 @@ include ../Makefile.ucbcmd
 
 FILEMODE=	755
 
-LDLIBS =  -L$(ROOT)/usr/ucblib -R /usr/ucblib $(LDLIBS.cmd) -lucb -ltermcap
+LDLIBS =  -L$(ROOT)/usr/ucblib -R/usr/ucblib $(LDLIBS.cmd) -lucb -ltermcap
 
 CPPFLAGS = -I$(SRC)/ucbhead $(CPPFLAGS.master)
 CERRWARN += -_gcc=-Wno-implicit-function-declaration
@@ -37,11 +38,14 @@ CERRWARN += -_gcc=-Wno-parentheses
 CERRWARN += -_gcc=-Wno-unused-variable
 CERRWARN += -_gcc=-Wno-uninitialized
 
+# missing prototypes
+SMATCH=off
+
 ROOTSYMLINK= $(ROOTBIN)/reset
 
 .KEEP_STATE:
 
-all: $(PROG) 
+all: $(PROG)
 
 $(PROG):	$(PROG).c
 	$(LINK.c) -o $@ $(PROG).c $(LDLIBS)
diff --git a/usr/src/ucbcmd/vipw/Makefile b/usr/src/ucbcmd/vipw/Makefile
index 53fb35631e..2df968d9b7 100644
--- a/usr/src/ucbcmd/vipw/Makefile
+++ b/usr/src/ucbcmd/vipw/Makefile
@@ -22,6 +22,7 @@
 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
+# Copyright (c) 2019, Joyent, Inc.
 
 PROG= vipw
 
@@ -29,15 +30,18 @@ include ../Makefile.ucbcmd
 
 INC1 = $(SRC)/ucbhead
 
-LDLIBS =  -L$(ROOT)/usr/ucblib -R /usr/ucblib $(LDLIBS.cmd) -lucb
+LDLIBS =  -L$(ROOT)/usr/ucblib -R/usr/ucblib $(LDLIBS.cmd) -lucb
 
 CPPFLAGS = -I$(INC1) $(CPPFLAGS.master)
 CERRWARN += -_gcc=-Wno-implicit-function-declaration
 CERRWARN += -_gcc=-Wno-unused-variable
 
+# missing prototypes
+SMATCH=off
+
 .KEEP_STATE:
 
-all: $(PROG) 
+all: $(PROG)
 
 $(PROG):	$(PROG).c
 	$(LINK.c) -o $@ $(PROG).c $(LDLIBS)
diff --git a/usr/src/uts/Makefile.uts b/usr/src/uts/Makefile.uts
index 704992618b..e1c0fd372b 100644
--- a/usr/src/uts/Makefile.uts
+++ b/usr/src/uts/Makefile.uts
@@ -26,6 +26,7 @@
 # Copyright (c) 2013 Andrew Stormont.  All rights reserved.
 # Copyright 2018 Joyent, Inc.
 # Copyright 2016 Hans Rosenfeld <rosenfeld@grumpf.hope-2000.org>
+# Copyright (c) 2019, Joyent, Inc.
 #
 
 #
@@ -227,6 +228,15 @@ CERRWARN += -_gcc=-Wno-missing-field-initializers
 $(RELEASE_BUILD)CERRWARN += -_gcc=-Wno-unused
 $(RELEASE_BUILD)CERRWARN += -_gcc=-Wno-empty-body
 
+CERRWARN += -_smatch=-p=illumos_kernel
+include $(SRC)/Makefile.smatch
+
+#
+# Unfortunately, _IOWR() is regularly used with a third argument of 0,
+# so we have to disable all these smatch checks.
+#
+SMOFF += sizeof
+
 CSTD = $(CSTD_GNU99)
 
 CFLAGS_uts		=
diff --git a/usr/src/uts/common/Makefile.rules b/usr/src/uts/common/Makefile.rules
index 6c48ec8930..e50aafad98 100644
--- a/usr/src/uts/common/Makefile.rules
+++ b/usr/src/uts/common/Makefile.rules
@@ -90,7 +90,7 @@ $(OBJS_DIR)/%.o:		$(COMMONBASE)/mpi/%.c
 	$(COMPILE.c) -o $@ $<
 	$(CTFCONVERT_O)
 
-$(OBJS_DIR)/%.o: 		$(COMMONBASE)/acl/%.c
+$(OBJS_DIR)/%.o:		$(COMMONBASE)/acl/%.c
 	$(COMPILE.c) -o $@ $<
 	$(CTFCONVERT_O)
 
@@ -295,6 +295,10 @@ $(OBJS_DIR)/%.o:		$(COMMONBASE)/smbsrv/%.c
 	$(COMPILE.c) -o $@ $<
 	$(CTFCONVERT_O)
 
+$(OBJS_DIR)/%.o:		$(COMMONBASE)/vga/%.c
+	$(COMPILE.c) -o $@ $<
+	$(CTFCONVERT_O)
+
 $(OBJS_DIR)/%.o:		$(UTSBASE)/common/fs/smbsrv/%.c
 	$(COMPILE.c) -o $@ $<
 	$(CTFCONVERT_O)
@@ -1974,7 +1978,7 @@ $(LINTS_DIR)/%.ln:		$(UTSBASE)/common/inet/ip/%.c
 $(LINTS_DIR)/%.ln:		$(UTSBASE)/common/inet/ipnet/%.c
 	@($(LHEAD) $(LINT.c) $< $(LTAIL))
 
-$(LINTS_DIR)/%.ln: 	     	$(UTSBASE)/common/inet/iptun/%.c
+$(LINTS_DIR)/%.ln:		$(UTSBASE)/common/inet/iptun/%.c
 	@($(LHEAD) $(LINT.c) $< $(LTAIL))
 
 $(LINTS_DIR)/%.ln:		$(UTSBASE)/common/inet/ipd/%.c
diff --git a/usr/src/uts/common/fs/zfs/vdev_disk.c b/usr/src/uts/common/fs/zfs/vdev_disk.c
index b548bf8e3c..af653c2f28 100644
--- a/usr/src/uts/common/fs/zfs/vdev_disk.c
+++ b/usr/src/uts/common/fs/zfs/vdev_disk.c
@@ -709,7 +709,7 @@ vdev_disk_ldi_physio(ldi_handle_t vd_lh, caddr_t data,
 	return (error);
 }
 
-static void
+static int
 vdev_disk_io_intr(buf_t *bp)
 {
 	vdev_buf_t *vb = (vdev_buf_t *)bp;
@@ -734,6 +734,7 @@ vdev_disk_io_intr(buf_t *bp)
 	kmem_free(vb, sizeof (vdev_buf_t));
 
 	zio_delay_interrupt(zio);
+	return (0);
 }
 
 static void
@@ -853,7 +854,7 @@ vdev_disk_io_start(zio_t *zio)
 
 	bp->b_lblkno = lbtodb(zio->io_offset);
 	bp->b_bufsize = zio->io_size;
-	bp->b_iodone = (int (*)())vdev_disk_io_intr;
+	bp->b_iodone = vdev_disk_io_intr;
 
 	zfs_zone_zio_start(zio);
 
diff --git a/usr/src/uts/common/fs/zfs/vdev_file.c b/usr/src/uts/common/fs/zfs/vdev_file.c
index 96534436bb..23536ac105 100644
--- a/usr/src/uts/common/fs/zfs/vdev_file.c
+++ b/usr/src/uts/common/fs/zfs/vdev_file.c
@@ -148,7 +148,7 @@ vdev_file_close(vdev_t *vd)
  * interrupt taskqs. For consistency, the code structure mimics disk vdev
  * types.
  */
-static void
+static int
 vdev_file_io_intr(buf_t *bp)
 {
 	vdev_buf_t *vb = (vdev_buf_t *)bp;
@@ -166,6 +166,7 @@ vdev_file_io_intr(buf_t *bp)
 
 	kmem_free(vb, sizeof (vdev_buf_t));
 	zio_delay_interrupt(zio);
+	return (0);
 }
 
 static void
@@ -241,7 +242,7 @@ vdev_file_io_start(zio_t *zio)
 	bp->b_lblkno = lbtodb(zio->io_offset);
 	bp->b_bufsize = zio->io_size;
 	bp->b_private = vf->vf_vnode;
-	bp->b_iodone = (int (*)())vdev_file_io_intr;
+	bp->b_iodone = vdev_file_io_intr;
 
 	VERIFY3U(taskq_dispatch(system_taskq, vdev_file_io_strategy, bp,
 	    TQ_SLEEP), !=, 0);
diff --git a/usr/src/uts/common/inet/ip.h b/usr/src/uts/common/inet/ip.h
index 4f0b4a1be8..a0ae38d4dd 100644
--- a/usr/src/uts/common/inet/ip.h
+++ b/usr/src/uts/common/inet/ip.h
@@ -784,7 +784,7 @@ typedef	struct ipsec_selector {
  */
 #define	CONN_INBOUND_POLICY_PRESENT(connp, ipss)	\
 	((connp)->conn_in_enforce_policy ||		\
-	(!((connp)->conn_policy_cached) && 		\
+	(!((connp)->conn_policy_cached) &&		\
 	(ipss)->ipsec_inbound_v4_policy_present))
 
 #define	CONN_INBOUND_POLICY_PRESENT_V6(connp, ipss)	\
@@ -1114,15 +1114,15 @@ typedef enum { IPVL_UNICAST_UP, IPVL_UNICAST_DOWN, IPVL_MCAST, IPVL_BCAST,
  *	ipsq_xop_switch_mp	ipsq_lock		ipsq_lock
  *	ipsq_phyint		write once		write once
  *	ipsq_next		RW_READER ill_g_lock	RW_WRITER ill_g_lock
- *	ipsq_xop 		ipsq_lock or ipsq	ipsq_lock + ipsq
+ *	ipsq_xop		ipsq_lock or ipsq	ipsq_lock + ipsq
  *	ipsq_swxop		ipsq			ipsq
- * 	ipsq_ownxop		see ipxop_t		see ipxop_t
+ *	ipsq_ownxop		see ipxop_t		see ipxop_t
  *	ipsq_ipst		write once		write once
  *
  * ipxop_t synchronization:     read			write
  *
- *	ipx_writer  		ipx_lock		ipx_lock
- *	ipx_xop_queued		ipx_lock 		ipx_lock
+ *	ipx_writer		ipx_lock		ipx_lock
+ *	ipx_xop_queued		ipx_lock		ipx_lock
  *	ipx_mphead		ipx_lock		ipx_lock
  *	ipx_mptail		ipx_lock		ipx_lock
  *	ipx_ipsq		write once		write once
@@ -1140,7 +1140,7 @@ typedef enum { IPVL_UNICAST_UP, IPVL_UNICAST_DOWN, IPVL_MCAST, IPVL_BCAST,
  */
 typedef struct ipxop_s {
 	kmutex_t	ipx_lock;	/* see above */
-	kthread_t	*ipx_writer;  	/* current owner */
+	kthread_t	*ipx_writer;	/* current owner */
 	mblk_t		*ipx_mphead;	/* messages tied to this op */
 	mblk_t		*ipx_mptail;
 	struct ipsq_s	*ipx_ipsq;	/* associated ipsq */
@@ -1151,8 +1151,8 @@ typedef struct ipxop_s {
 	int		ipx_current_ioctl; /* current ioctl, or 0 if no ioctl */
 	ipif_t		*ipx_current_ipif; /* ipif for current op */
 	ipif_t		*ipx_pending_ipif; /* ipif for ipx_pending_mp */
-	mblk_t 		*ipx_pending_mp;   /* current ioctl mp while waiting */
-	boolean_t	ipx_forced; 			/* debugging aid */
+	mblk_t		*ipx_pending_mp; /* current ioctl mp while waiting */
+	boolean_t	ipx_forced;			/* debugging aid */
 #ifdef DEBUG
 	int		ipx_depth;			/* debugging aid */
 #define	IPX_STACK_DEPTH	15
@@ -1345,7 +1345,7 @@ typedef int (*pfirepostfrag_t)(mblk_t *, nce_t *, iaflags_t, uint_t, uint32_t,
 /*
  * unpadded ill_if structure
  */
-struct 	_ill_if_s_ {
+struct	_ill_if_s_ {
 	union ill_if_u	*illif_next;
 	union ill_if_u	*illif_prev;
 	avl_tree_t	illif_avl_by_ppa;	/* AVL tree sorted on ppa */
@@ -1357,9 +1357,9 @@ struct 	_ill_if_s_ {
 };
 
 /* cache aligned ill_if structure */
-typedef union 	ill_if_u {
-	struct  _ill_if_s_ ill_if_s;
-	char 	illif_filler[CACHE_ALIGN(_ill_if_s_)];
+typedef union	ill_if_u {
+	struct	_ill_if_s_ ill_if_s;
+	char	illif_filler[CACHE_ALIGN(_ill_if_s_)];
 } ill_if_t;
 
 #define	illif_next		ill_if_s.illif_next
@@ -1513,7 +1513,7 @@ typedef struct ill_lso_capab_s ill_lso_capab_t;
  *	ig_mc_mtu		ipsq			ipsq
  */
 typedef struct ipmp_illgrp_s {
-	list_t		ig_if; 		/* list of all interfaces */
+	list_t		ig_if;		/* list of all interfaces */
 	list_t		ig_actif;	/* list of active interfaces */
 	uint_t		ig_nactif;	/* number of active interfaces */
 	struct ill_s	*ig_next_ill;	/* next active interface to use */
@@ -1553,13 +1553,13 @@ typedef struct ipmp_grp_s {
 	t_uscalar_t	gr_mactype;	/* DLPI mactype of group */
 	phyint_t	*gr_phyint;	/* IPMP group phyint */
 	uint_t		gr_nif;		/* number of interfaces in group */
-	uint_t		gr_nactif; 	/* number of active interfaces */
+	uint_t		gr_nactif;	/* number of active interfaces */
 	ipmp_illgrp_t	*gr_v4;		/* V4 group information */
 	ipmp_illgrp_t	*gr_v6;		/* V6 group information */
 	uint_t		gr_nv4;		/* number of ills in V4 group */
 	uint_t		gr_nv6;		/* number of ills in V6 group */
-	uint_t		gr_pendv4; 	/* number of pending ills in V4 group */
-	uint_t		gr_pendv6; 	/* number of pending ills in V6 group */
+	uint_t		gr_pendv4;	/* number of pending ills in V4 group */
+	uint_t		gr_pendv6;	/* number of pending ills in V6 group */
 	mblk_t		*gr_linkdownmp;	/* message used to bring link down */
 	kstat_t		*gr_ksp;	/* group kstat pointer */
 	uint64_t	gr_kstats0[IPMP_KSTAT_MAX]; /* baseline group kstats */
@@ -1570,10 +1570,10 @@ typedef struct ipmp_grp_s {
  * ARP up-to-date as the active set of interfaces in the group changes.
  */
 typedef struct ipmp_arpent_s {
-	ipaddr_t	ia_ipaddr; 	/* IP address for this entry */
-	boolean_t	ia_proxyarp; 	/* proxy ARP entry? */
-	boolean_t	ia_notified; 	/* ARP notified about this entry? */
-	list_node_t	ia_node; 	/* next ARP entry in list */
+	ipaddr_t	ia_ipaddr;	/* IP address for this entry */
+	boolean_t	ia_proxyarp;	/* proxy ARP entry? */
+	boolean_t	ia_notified;	/* ARP notified about this entry? */
+	list_node_t	ia_node;	/* next ARP entry in list */
 	uint16_t	ia_flags;	/* nce_flags for the address */
 	size_t		ia_lladdr_len;
 	uchar_t		*ia_lladdr;
@@ -1817,7 +1817,7 @@ typedef struct ill_s {
 	 * IPMP fields.
 	 */
 	ipmp_illgrp_t	*ill_grp;	/* IPMP group information */
-	list_node_t	ill_actnode; 	/* next active ill in group */
+	list_node_t	ill_actnode;	/* next active ill in group */
 	list_node_t	ill_grpnode;	/* next ill in group */
 	ipif_t		*ill_src_ipif;	/* source address selection rotor */
 	ipif_t		*ill_move_ipif;	/* ipif awaiting move to new ill */
@@ -2155,9 +2155,9 @@ struct ip_xmit_attr_s {
 	 * IXAF_IPSEC_SECURE is set. Otherwise they contain garbage.
 	 */
 	ipsec_latch_t	*ixa_ipsec_latch;	/* Just the ids */
-	struct ipsa_s 	*ixa_ipsec_ah_sa;	/* Hard reference SA for AH */
-	struct ipsa_s 	*ixa_ipsec_esp_sa;	/* Hard reference SA for ESP */
-	struct ipsec_policy_s 	*ixa_ipsec_policy; /* why are we here? */
+	struct ipsa_s	*ixa_ipsec_ah_sa;	/* Hard reference SA for AH */
+	struct ipsa_s	*ixa_ipsec_esp_sa;	/* Hard reference SA for ESP */
+	struct ipsec_policy_s	*ixa_ipsec_policy; /* why are we here? */
 	struct ipsec_action_s	*ixa_ipsec_action; /* For reflected packets */
 	ipsa_ref_t	ixa_ipsec_ref[2];	/* Soft reference to SA */
 						/* 0: ESP, 1: AH */
@@ -2360,8 +2360,8 @@ struct ip_recv_attr_s {
 	 * IRAF_IPSEC_SECURE is set. Otherwise they contain garbage.
 	 */
 	struct ipsec_action_s *ira_ipsec_action; /* how we made it in.. */
-	struct ipsa_s 	*ira_ipsec_ah_sa;	/* SA for AH */
-	struct ipsa_s 	*ira_ipsec_esp_sa;	/* SA for ESP */
+	struct ipsa_s	*ira_ipsec_ah_sa;	/* SA for AH */
+	struct ipsa_s	*ira_ipsec_esp_sa;	/* SA for ESP */
 
 	ipaddr_t	ira_mroute_tunnel;	/* IRAF_MROUTE_TUNNEL_SET */
 
@@ -3014,7 +3014,7 @@ extern vmem_t *ip_minor_arena_la;
 /* Misc IP configuration knobs */
 #define	ips_ip_policy_mask		ips_propinfo_tbl[44].prop_cur_uval
 #define	ips_ip_ecmp_behavior		ips_propinfo_tbl[45].prop_cur_uval
-#define	ips_ip_multirt_ttl  		ips_propinfo_tbl[46].prop_cur_uval
+#define	ips_ip_multirt_ttl		ips_propinfo_tbl[46].prop_cur_uval
 #define	ips_ip_ire_badcnt_lifetime	ips_propinfo_tbl[47].prop_cur_uval
 #define	ips_ip_max_temp_idle		ips_propinfo_tbl[48].prop_cur_uval
 #define	ips_ip_max_temp_defend		ips_propinfo_tbl[49].prop_cur_uval
@@ -3218,7 +3218,7 @@ extern mblk_t	*ip_dlnotify_alloc(uint_t, uint_t);
 extern mblk_t	*ip_dlnotify_alloc2(uint_t, uint_t, uint_t);
 extern char	*ip_dot_addr(ipaddr_t, char *);
 extern const char *mac_colon_addr(const uint8_t *, size_t, char *, size_t);
-extern void	ip_lwput(queue_t *, mblk_t *);
+extern int	ip_lwput(queue_t *, mblk_t *);
 extern boolean_t icmp_err_rate_limit(ip_stack_t *);
 extern void	icmp_frag_needed(mblk_t *, int, ip_recv_attr_t *);
 extern mblk_t	*icmp_inbound_v4(mblk_t *, ip_recv_attr_t *);
@@ -3255,7 +3255,7 @@ extern int	ip_openv6(queue_t *q, dev_t *devp, int flag, int sflag,
 		    cred_t *credp);
 extern int	ip_reassemble(mblk_t *, ipf_t *, uint_t, boolean_t, ill_t *,
     size_t);
-extern void	ip_rput(queue_t *, mblk_t *);
+extern int	ip_rput(queue_t *, mblk_t *);
 extern void	ip_input(ill_t *, ill_rx_ring_t *, mblk_t *,
     struct mac_header_info_s *);
 extern void	ip_input_v6(ill_t *, ill_rx_ring_t *, mblk_t *,
@@ -3376,8 +3376,8 @@ extern boolean_t conn_wantpacket(conn_t *, ip_recv_attr_t *, ipha_t *);
 extern uint_t	ip_type_v4(ipaddr_t, ip_stack_t *);
 extern uint_t	ip_type_v6(const in6_addr_t *, ip_stack_t *);
 
-extern void	ip_wput_nondata(queue_t *, mblk_t *);
-extern void	ip_wsrv(queue_t *);
+extern int	ip_wput_nondata(queue_t *, mblk_t *);
+extern int	ip_wsrv(queue_t *);
 extern char	*ip_nv_lookup(nv_t *, int);
 extern boolean_t ip_local_addr_ok_v6(const in6_addr_t *, const in6_addr_t *);
 extern boolean_t ip_remote_addr_ok_v6(const in6_addr_t *, const in6_addr_t *);
@@ -3576,7 +3576,7 @@ typedef enum {
  * include mac/dls header files here.
  */
 typedef boolean_t		(*ip_mac_intr_disable_t)(void *);
-typedef void			(*ip_mac_intr_enable_t)(void *);
+typedef int			(*ip_mac_intr_enable_t)(void *);
 typedef ip_mac_tx_cookie_t	(*ip_dld_tx_t)(void *, mblk_t *,
     uint64_t, uint16_t);
 typedef	void			(*ip_flow_enable_t)(void *, ip_mac_tx_cookie_t);
@@ -3660,7 +3660,7 @@ struct ill_dld_capab_s {
 /*
  * IP squeues exports
  */
-extern boolean_t 	ip_squeue_fanout;
+extern boolean_t	ip_squeue_fanout;
 
 #define	IP_SQUEUE_GET(hint) ip_squeue_random(hint)
 
@@ -3677,7 +3677,7 @@ extern void ip_squeue_restart_ring(ill_t *, ill_rx_ring_t *);
 extern void ip_squeue_clean_all(ill_t *);
 extern boolean_t	ip_source_routed(ipha_t *, ip_stack_t *);
 
-extern void tcp_wput(queue_t *, mblk_t *);
+extern int tcp_wput(queue_t *, mblk_t *);
 
 extern int	ip_fill_mtuinfo(conn_t *, ip_xmit_attr_t *,
     struct ip6_mtuinfo *);
diff --git a/usr/src/uts/common/inet/ip/icmp.c b/usr/src/uts/common/inet/ip/icmp.c
index ff3f143995..3589779f20 100644
--- a/usr/src/uts/common/inet/ip/icmp.c
+++ b/usr/src/uts/common/inet/ip/icmp.c
@@ -116,7 +116,7 @@ static void	icmp_icmp_error_ipv6(conn_t *connp, mblk_t *mp,
     ip_recv_attr_t *);
 static void	icmp_info_req(queue_t *q, mblk_t *mp);
 static void	icmp_input(void *, mblk_t *, void *, ip_recv_attr_t *);
-static conn_t 	*icmp_open(int family, cred_t *credp, int *err, int flags);
+static conn_t	*icmp_open(int family, cred_t *credp, int *err, int flags);
 static int	icmp_openv4(queue_t *q, dev_t *devp, int flag, int sflag,
 		    cred_t *credp);
 static int	icmp_openv6(queue_t *q, dev_t *devp, int flag, int sflag,
@@ -138,8 +138,8 @@ static int	icmp_snmp_set(queue_t *q, t_scalar_t level, t_scalar_t name,
 		    uchar_t *ptr, int len);
 static void	icmp_ud_err(queue_t *q, mblk_t *mp, t_scalar_t err);
 static void	icmp_tpi_unbind(queue_t *q, mblk_t *mp);
-static void	icmp_wput(queue_t *q, mblk_t *mp);
-static void	icmp_wput_fallback(queue_t *q, mblk_t *mp);
+static int	icmp_wput(queue_t *q, mblk_t *mp);
+static int	icmp_wput_fallback(queue_t *q, mblk_t *mp);
 static void	icmp_wput_other(queue_t *q, mblk_t *mp);
 static void	icmp_wput_iocdata(queue_t *q, mblk_t *mp);
 static void	icmp_wput_restricted(queue_t *q, mblk_t *mp);
@@ -183,12 +183,12 @@ static struct qinit icmprinitv6 = {
 };
 
 static struct qinit icmpwinit = {
-	(pfi_t)icmp_wput, (pfi_t)ip_wsrv, NULL, NULL, NULL, &icmp_mod_info
+	icmp_wput, ip_wsrv, NULL, NULL, NULL, &icmp_mod_info
 };
 
 /* ICMP entry point during fallback */
 static struct qinit icmp_fallback_sock_winit = {
-	(pfi_t)icmp_wput_fallback, NULL, NULL, NULL, NULL, &icmp_mod_info
+	icmp_wput_fallback, NULL, NULL, NULL, NULL, &icmp_mod_info
 };
 
 /* For AF_INET aka /dev/icmp */
@@ -722,7 +722,7 @@ rawip_do_connect(conn_t *connp, const struct sockaddr *sa, socklen_t len,
 	sin_t		*sin;
 	sin6_t		*sin6;
 	int		error;
-	uint16_t 	dstport;
+	uint16_t	dstport;
 	ipaddr_t	v4dst;
 	in6_addr_t	v6dst;
 	uint32_t	flowinfo;
@@ -1967,7 +1967,7 @@ int
 icmp_tpi_opt_get(queue_t *q, int level, int name, uchar_t *ptr)
 {
 	conn_t		*connp = Q_TO_CONN(q);
-	int 		err;
+	int		err;
 
 	err = icmp_opt_get(connp, level, name, ptr);
 	return (err);
@@ -2294,9 +2294,9 @@ icmp_opt_set(conn_t *connp, uint_t optset_context, int level, int name,
 		/*
 		 * Note: Implies T_CHECK semantics for T_OPTCOM_REQ
 		 * inlen != 0 implies value supplied and
-		 * 	we have to "pretend" to set it.
+		 *	we have to "pretend" to set it.
 		 * inlen == 0 implies that there is no
-		 * 	value part in T_CHECK request and just validation
+		 *	value part in T_CHECK request and just validation
 		 * done elsewhere should be enough, we just return here.
 		 */
 		if (inlen == 0) {
@@ -4235,7 +4235,7 @@ icmp_prepend_header_template(conn_t *connp, ip_xmit_attr_t *ixa, mblk_t *mp,
  * consumes the message or passes it downstream; it never queues a
  * a message.
  */
-void
+int
 icmp_wput(queue_t *q, mblk_t *mp)
 {
 	sin6_t		*sin6;
@@ -4262,7 +4262,7 @@ icmp_wput(queue_t *q, mblk_t *mp)
 		/* sockfs never sends down M_DATA */
 		BUMP_MIB(&is->is_rawip_mib, rawipOutErrors);
 		freemsg(mp);
-		return;
+		return (0);
 
 	case M_PROTO:
 	case M_PCPROTO:
@@ -4270,13 +4270,13 @@ icmp_wput(queue_t *q, mblk_t *mp)
 		if (MBLKL(mp) < sizeof (*tudr) ||
 		    ((t_primp_t)mp->b_rptr)->type != T_UNITDATA_REQ) {
 			icmp_wput_other(q, mp);
-			return;
+			return (0);
 		}
 		break;
 
 	default:
 		icmp_wput_other(q, mp);
-		return;
+		return (0);
 	}
 
 	/* Handle valid T_UNITDATA_REQ here */
@@ -4392,7 +4392,7 @@ icmp_wput(queue_t *q, mblk_t *mp)
 		}
 		if (error == 0) {
 			freeb(mp);
-			return;
+			return (0);
 		}
 		break;
 
@@ -4418,7 +4418,7 @@ icmp_wput(queue_t *q, mblk_t *mp)
 			error = icmp_output_hdrincl(connp, data_mp, cr, pid);
 			if (error == 0) {
 				freeb(mp);
-				return;
+				return (0);
 			}
 			/* data_mp consumed above */
 			data_mp = NULL;
@@ -4467,14 +4467,14 @@ icmp_wput(queue_t *q, mblk_t *mp)
 		}
 		if (error == 0) {
 			freeb(mp);
-			return;
+			return (0);
 		}
 		break;
 	}
 	ASSERT(mp != NULL);
 	/* mp is freed by the following routine */
 	icmp_ud_err(q, mp, (t_scalar_t)error);
-	return;
+	return (0);
 
 ud_error2:
 	BUMP_MIB(&is->is_rawip_mib, rawipOutErrors);
@@ -4482,6 +4482,7 @@ ud_error2:
 	ASSERT(mp != NULL);
 	/* mp is freed by the following routine */
 	icmp_ud_err(q, mp, (t_scalar_t)error);
+	return (0);
 }
 
 /*
@@ -4818,13 +4819,14 @@ ud_error:
 }
 
 /* ARGSUSED */
-static void
+static int
 icmp_wput_fallback(queue_t *q, mblk_t *mp)
 {
 #ifdef DEBUG
 	cmn_err(CE_CONT, "icmp_wput_fallback: Message during fallback \n");
 #endif
 	freemsg(mp);
+	return (0);
 }
 
 static void
@@ -5500,7 +5502,7 @@ rawip_activate(sock_lower_handle_t proto_handle,
     sock_upper_handle_t sock_handle, sock_upcalls_t *sock_upcalls, int flags,
     cred_t *cr)
 {
-	conn_t 			*connp = (conn_t *)proto_handle;
+	conn_t *connp = (conn_t *)proto_handle;
 	struct sock_proto_props sopp;
 
 	/* All Solaris components should pass a cred for this operation. */
@@ -5689,7 +5691,7 @@ int
 rawip_ioctl(sock_lower_handle_t proto_handle, int cmd, intptr_t arg,
     int mode, int32_t *rvalp, cred_t *cr)
 {
-	conn_t  	*connp = (conn_t *)proto_handle;
+	conn_t		*connp = (conn_t *)proto_handle;
 	int		error;
 
 	/* All Solaris components should pass a cred for this operation. */
diff --git a/usr/src/uts/common/inet/ip/ip.c b/usr/src/uts/common/inet/ip/ip.c
index 2119a3cdd0..7618add2b8 100644
--- a/usr/src/uts/common/inet/ip/ip.c
+++ b/usr/src/uts/common/inet/ip/ip.c
@@ -667,10 +667,10 @@ mblk_t		*ip_dlpi_alloc(size_t, t_uscalar_t);
 char		*ip_dot_addr(ipaddr_t, char *);
 mblk_t		*ip_carve_mp(mblk_t **, ssize_t);
 static char	*ip_dot_saddr(uchar_t *, char *);
-static void	ip_lrput(queue_t *, mblk_t *);
+static int	ip_lrput(queue_t *, mblk_t *);
 ipaddr_t	ip_net_mask(ipaddr_t);
 char		*ip_nv_lookup(nv_t *, int);
-void	ip_rput(queue_t *, mblk_t *);
+int		ip_rput(queue_t *, mblk_t *);
 static void	ip_rput_dlpi_writer(ipsq_t *dummy_sq, queue_t *q, mblk_t *mp,
 		    void *dummy_arg);
 int		ip_snmp_get(queue_t *, mblk_t *, int, boolean_t);
@@ -706,8 +706,8 @@ static mblk_t	*ip_snmp_get_mib2_ip6_route_media(queue_t *, mblk_t *, int,
 		    ip_stack_t *ipst);
 static void	ip_snmp_get2_v4(ire_t *, iproutedata_t *);
 static void	ip_snmp_get2_v6_route(ire_t *, iproutedata_t *);
-static int	ip_snmp_get2_v4_media(ncec_t *, iproutedata_t *);
-static int	ip_snmp_get2_v6_media(ncec_t *, iproutedata_t *);
+static void	ip_snmp_get2_v4_media(ncec_t *, void *);
+static void	ip_snmp_get2_v6_media(ncec_t *, void *);
 int		ip_snmp_set(queue_t *, int, int, uchar_t *, int);
 
 static mblk_t	*ip_fragment_copyhdr(uchar_t *, int, int, ip_stack_t *,
@@ -1184,28 +1184,23 @@ struct module_info ip_mod_info = {
  * We have separate open functions for the /dev/ip and /dev/ip6 devices.
  */
 static struct qinit iprinitv4 = {
-	(pfi_t)ip_rput, NULL, ip_openv4, ip_close, NULL,
-	&ip_mod_info
+	ip_rput, NULL, ip_openv4, ip_close, NULL, &ip_mod_info
 };
 
 struct qinit iprinitv6 = {
-	(pfi_t)ip_rput_v6, NULL, ip_openv6, ip_close, NULL,
-	&ip_mod_info
+	ip_rput_v6, NULL, ip_openv6, ip_close, NULL, &ip_mod_info
 };
 
 static struct qinit ipwinit = {
-	(pfi_t)ip_wput_nondata, (pfi_t)ip_wsrv, NULL, NULL, NULL,
-	&ip_mod_info
+	ip_wput_nondata, ip_wsrv, NULL, NULL, NULL, &ip_mod_info
 };
 
 static struct qinit iplrinit = {
-	(pfi_t)ip_lrput, NULL, ip_openv4, ip_close, NULL,
-	&ip_mod_info
+	ip_lrput, NULL, ip_openv4, ip_close, NULL, &ip_mod_info
 };
 
 static struct qinit iplwinit = {
-	(pfi_t)ip_lwput, NULL, NULL, NULL, NULL,
-	&ip_mod_info
+	ip_lwput, NULL, NULL, NULL, NULL, &ip_mod_info
 };
 
 /* For AF_INET aka /dev/ip */
@@ -1288,9 +1283,9 @@ icmp_frag_needed(mblk_t *mp, int mtu, ip_recv_attr_t *ira)
  *    while affecting the values in IP and while delivering up to TCP
  *    should be the same.
  *
- * 	There are two cases.
+ *	There are two cases.
  *
- * 	a) If we reject data at the IP layer (ipsec_check_global_policy()
+ *	a) If we reject data at the IP layer (ipsec_check_global_policy()
  *	   failed), we will not deliver it to the ULP, even though they
  *	   are *willing* to accept in *clear*. This is fine as our global
  *	   disposition to icmp messages asks us reject the datagram.
@@ -2628,7 +2623,7 @@ icmp_redirect_v4(mblk_t *mp, ipha_t *ipha, icmph_t *icmph, ip_recv_attr_t *ira)
 {
 	ire_t		*ire, *nire;
 	ire_t		*prev_ire;
-	ipaddr_t  	src, dst, gateway;
+	ipaddr_t	src, dst, gateway;
 	ip_stack_t	*ipst = ira->ira_ill->ill_ipst;
 	ipha_t		*inner_ipha;	/* Inner IP header */
 
@@ -4654,7 +4649,7 @@ ip_stack_init(netstackid_t stackid, netstack_t *ns)
 	ipst->ips_ill_index = 1;
 
 	ipst->ips_saved_ip_forwarding = -1;
-	ipst->ips_reg_vif_num = ALL_VIFS; 	/* Index to Register vif */
+	ipst->ips_reg_vif_num = ALL_VIFS;	/* Index to Register vif */
 
 	arrsz = ip_propinfo_count * sizeof (mod_prop_info_t);
 	ipst->ips_propinfo_tbl = (mod_prop_info_t *)kmem_alloc(arrsz, KM_SLEEP);
@@ -5675,7 +5670,7 @@ ip_type_v6(const in6_addr_t *addr, ip_stack_t *ipst)
  * Nobody should be sending
  * packets up this stream
  */
-static void
+static int
 ip_lrput(queue_t *q, mblk_t *mp)
 {
 	switch (mp->b_datap->db_type) {
@@ -5684,19 +5679,21 @@ ip_lrput(queue_t *q, mblk_t *mp)
 		if (*mp->b_rptr & FLUSHW) {
 			*mp->b_rptr &= ~FLUSHR;
 			qreply(q, mp);
-			return;
+			return (0);
 		}
 		break;
 	}
 	freemsg(mp);
+	return (0);
 }
 
 /* Nobody should be sending packets down this stream */
 /* ARGSUSED */
-void
+int
 ip_lwput(queue_t *q, mblk_t *mp)
 {
 	freemsg(mp);
+	return (0);
 }
 
 /*
@@ -5964,7 +5961,7 @@ int
 ip_open(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp,
     boolean_t isv6)
 {
-	conn_t 		*connp;
+	conn_t		*connp;
 	major_t		maj;
 	zoneid_t	zoneid;
 	netstack_t	*ns;
@@ -7999,7 +7996,7 @@ ip_rput_notdata(ill_t *ill, mblk_t *mp)
 }
 
 /* Read side put procedure.  Packets coming from the wire arrive here. */
-void
+int
 ip_rput(queue_t *q, mblk_t *mp)
 {
 	ill_t	*ill;
@@ -8018,7 +8015,7 @@ ip_rput(queue_t *q, mblk_t *mp)
 		if (DB_TYPE(mp) != M_PCPROTO ||
 		    dl->dl_primitive == DL_UNITDATA_IND) {
 			inet_freemsg(mp);
-			return;
+			return (0);
 		}
 	}
 	if (DB_TYPE(mp) == M_DATA) {
@@ -8029,6 +8026,7 @@ ip_rput(queue_t *q, mblk_t *mp)
 	} else {
 		ip_rput_notdata(ill, mp);
 	}
+	return (0);
 }
 
 /*
@@ -11101,16 +11099,17 @@ ip_snmp_get2_v6_route(ire_t *ire, iproutedata_t *ird)
 /*
  * ncec_walk routine to create ipv6NetToMediaEntryTable
  */
-static int
-ip_snmp_get2_v6_media(ncec_t *ncec, iproutedata_t *ird)
+static void
+ip_snmp_get2_v6_media(ncec_t *ncec, void *ptr)
 {
+	iproutedata_t *ird		= ptr;
 	ill_t				*ill;
 	mib2_ipv6NetToMediaEntry_t	ntme;
 
 	ill = ncec->ncec_ill;
 	/* skip arpce entries, and loopback ncec entries */
 	if (ill->ill_isv6 == B_FALSE || ill->ill_net_type == IRE_LOOPBACK)
-		return (0);
+		return;
 	/*
 	 * Neighbor cache entry attached to IRE with on-link
 	 * destination.
@@ -11149,7 +11148,6 @@ ip_snmp_get2_v6_media(ncec_t *ncec, iproutedata_t *ird)
 		ip1dbg(("ip_snmp_get2_v6_media: failed to allocate %u bytes\n",
 		    (uint_t)sizeof (ntme)));
 	}
-	return (0);
 }
 
 int
@@ -11179,9 +11177,10 @@ nce2ace(ncec_t *ncec)
 /*
  * ncec_walk routine to create ipNetToMediaEntryTable
  */
-static int
-ip_snmp_get2_v4_media(ncec_t *ncec, iproutedata_t *ird)
+static void
+ip_snmp_get2_v4_media(ncec_t *ncec, void *ptr)
 {
+	iproutedata_t *ird		= ptr;
 	ill_t				*ill;
 	mib2_ipNetToMediaEntry_t	ntme;
 	const char			*name = "unknown";
@@ -11190,7 +11189,7 @@ ip_snmp_get2_v4_media(ncec_t *ncec, iproutedata_t *ird)
 	ill = ncec->ncec_ill;
 	if (ill->ill_isv6 || (ncec->ncec_flags & NCE_F_BCAST) ||
 	    ill->ill_net_type == IRE_LOOPBACK)
-		return (0);
+		return;
 
 	/* We report all IPMP groups on ncec_ill which is normally the upper. */
 	name = ill->ill_name;
@@ -11236,7 +11235,6 @@ ip_snmp_get2_v4_media(ncec_t *ncec, iproutedata_t *ird)
 		ip1dbg(("ip_snmp_get2_v4_media: failed to allocate %u bytes\n",
 		    (uint_t)sizeof (ntme)));
 	}
-	return (0);
 }
 
 /*
@@ -12709,7 +12707,7 @@ ip_ioctl_finish(queue_t *q, mblk_t *mp, int err, int mode, ipsq_t *ipsq)
 }
 
 /* Handles all non data messages */
-void
+int
 ip_wput_nondata(queue_t *q, mblk_t *mp)
 {
 	mblk_t		*mp1;
@@ -12731,7 +12729,7 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 		 * will arrange to copy in associated control structures.
 		 */
 		ip_sioctl_copyin_setup(q, mp);
-		return;
+		return (0);
 	case M_IOCDATA:
 		/*
 		 * Ensure that this is associated with one of our trans-
@@ -12746,7 +12744,7 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 			} else {
 				putnext(q, mp);
 			}
-			return;
+			return (0);
 		}
 		if ((q->q_next != NULL) && !(ipip->ipi_flags & IPI_MODOK)) {
 			/*
@@ -12762,7 +12760,7 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 			 * The copy operation failed.  mi_copy_state already
 			 * cleaned up, so we're out of here.
 			 */
-			return;
+			return (0);
 		}
 		/*
 		 * If we just completed a copy in, we become writer and
@@ -12773,7 +12771,7 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 		if (MI_COPY_DIRECTION(mp) == MI_COPY_IN) {
 			if (!(mp1 = mp->b_cont) || !(mp1 = mp1->b_cont)) {
 				mi_copy_done(q, mp, EPROTO);
-				return;
+				return (0);
 			}
 			/*
 			 * Check for cases that need more copying.  A return
@@ -12784,7 +12782,7 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 			if (ipip->ipi_cmd_type == MSFILT_CMD &&
 			    MI_COPY_COUNT(mp) == 1) {
 				if (ip_copyin_msfilter(q, mp) == 0)
-					return;
+					return (0);
 			}
 			/*
 			 * Refhold the conn, till the ioctl completes. This is
@@ -12805,7 +12803,7 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 			} else {
 				if (!(ipip->ipi_flags & IPI_MODOK)) {
 					mi_copy_done(q, mp, EINVAL);
-					return;
+					return (0);
 				}
 			}
 
@@ -12814,7 +12812,7 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 		} else {
 			mi_copyout(q, mp);
 		}
-		return;
+		return (0);
 
 	case M_IOCNAK:
 		/*
@@ -12825,7 +12823,7 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 		    "ip_wput_nondata: unexpected M_IOCNAK, ioc_cmd 0x%x",
 		    ((struct iocblk *)mp->b_rptr)->ioc_cmd);
 		freemsg(mp);
-		return;
+		return (0);
 	case M_IOCACK:
 		/* /dev/ip shouldn't see this */
 		goto nak;
@@ -12834,15 +12832,15 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 			flushq(q, FLUSHALL);
 		if (q->q_next) {
 			putnext(q, mp);
-			return;
+			return (0);
 		}
 		if (*mp->b_rptr & FLUSHR) {
 			*mp->b_rptr &= ~FLUSHW;
 			qreply(q, mp);
-			return;
+			return (0);
 		}
 		freemsg(mp);
-		return;
+		return (0);
 	case M_CTL:
 		break;
 	case M_PROTO:
@@ -12874,19 +12872,19 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 				mp = mi_tpi_err_ack_alloc(mp, TSYSERR, EINVAL);
 				if (mp != NULL)
 					qreply(q, mp);
-				return;
+				return (0);
 			}
 
 			if (!snmpcom_req(q, mp, ip_snmp_set, ip_snmp_get, cr)) {
 				proto_str = "Bad SNMPCOM request?";
 				goto protonak;
 			}
-			return;
+			return (0);
 		default:
 			ip1dbg(("ip_wput_nondata: dropping M_PROTO prim %u\n",
 			    (int)*(uint_t *)mp->b_rptr));
 			freemsg(mp);
-			return;
+			return (0);
 		}
 	default:
 		break;
@@ -12895,19 +12893,20 @@ ip_wput_nondata(queue_t *q, mblk_t *mp)
 		putnext(q, mp);
 	} else
 		freemsg(mp);
-	return;
+	return (0);
 
 nak:
 	iocp->ioc_error = EINVAL;
 	mp->b_datap->db_type = M_IOCNAK;
 	iocp->ioc_count = 0;
 	qreply(q, mp);
-	return;
+	return (0);
 
 protonak:
 	cmn_err(CE_NOTE, "IP doesn't process %s as a module", proto_str);
 	if ((mp = mi_tpi_err_ack_alloc(mp, TPROTO, EINVAL)) != NULL)
 		qreply(q, mp);
+	return (0);
 }
 
 /*
@@ -13293,7 +13292,7 @@ conn_drain(conn_t *connp, boolean_t closing)
  * has backenabled the ill_wq. Send sockfs notification about flow-control on
  * each waiting conn.
  */
-void
+int
 ip_wsrv(queue_t *q)
 {
 	ill_t	*ill;
@@ -13313,6 +13312,7 @@ ip_wsrv(queue_t *q)
 		conn_walk_drain(ipst, &ipst->ips_idl_tx_list[0]);
 		enableok(ill->ill_wq);
 	}
+	return (0);
 }
 
 /*
@@ -13870,9 +13870,9 @@ ip_kstat2_init(netstackid_t stackid, ip_stat_t *ip_statisticsp)
 	kstat_t *ksp;
 
 	ip_stat_t template = {
-		{ "ip_udp_fannorm", 		KSTAT_DATA_UINT64 },
-		{ "ip_udp_fanmb", 		KSTAT_DATA_UINT64 },
-		{ "ip_recv_pullup", 		KSTAT_DATA_UINT64 },
+		{ "ip_udp_fannorm",		KSTAT_DATA_UINT64 },
+		{ "ip_udp_fanmb",		KSTAT_DATA_UINT64 },
+		{ "ip_recv_pullup",		KSTAT_DATA_UINT64 },
 		{ "ip_db_ref",			KSTAT_DATA_UINT64 },
 		{ "ip_notaligned",		KSTAT_DATA_UINT64 },
 		{ "ip_multimblk",		KSTAT_DATA_UINT64 },
diff --git a/usr/src/uts/common/inet/ip/ip2mac.c b/usr/src/uts/common/inet/ip/ip2mac.c
index 7ee7504d28..ac16e45d82 100644
--- a/usr/src/uts/common/inet/ip/ip2mac.c
+++ b/usr/src/uts/common/inet/ip/ip2mac.c
@@ -336,7 +336,7 @@ typedef struct ip2mac_cancel_data_s {
  * to an active nce_cb_t in the ncec's callback list, we want to remove
  * the callback (if there are no walkers) or return EBUSY to the caller
  */
-static int
+static void
 ip2mac_cancel_callback(ncec_t *ncec, void *arg)
 {
 	ip2mac_cancel_data_t *ip2m_wdata = arg;
@@ -344,12 +344,12 @@ ip2mac_cancel_callback(ncec_t *ncec, void *arg)
 	ncec_cb_t *ncec_cb;
 
 	if (ip2m_nce_cb->ncec_cb_id != ncec)
-		return (0);
+		return;
 
 	mutex_enter(&ncec->ncec_lock);
 	if (list_is_empty(&ncec->ncec_cb)) {
 		mutex_exit(&ncec->ncec_lock);
-		return (0);
+		return;
 	}
 	/*
 	 * IP does not hold internal locks like nce_lock across calls to
@@ -375,7 +375,6 @@ ip2mac_cancel_callback(ncec_t *ncec, void *arg)
 		break;
 	}
 	mutex_exit(&ncec->ncec_lock);
-	return (0);
 }
 
 /*
diff --git a/usr/src/uts/common/inet/ip/ip6.c b/usr/src/uts/common/inet/ip/ip6.c
index 7f30aaa81d..e0c6706dd9 100644
--- a/usr/src/uts/common/inet/ip/ip6.c
+++ b/usr/src/uts/common/inet/ip/ip6.c
@@ -3083,7 +3083,7 @@ ip_process_rthdr(mblk_t *mp, ip6_t *ip6h, ip6_rthdr_t *rth,
 /*
  * Read side put procedure for IPv6 module.
  */
-void
+int
 ip_rput_v6(queue_t *q, mblk_t *mp)
 {
 	ill_t		*ill;
@@ -3104,7 +3104,7 @@ ip_rput_v6(queue_t *q, mblk_t *mp)
 		if ((mp->b_datap->db_type != M_PCPROTO) ||
 		    (dl->dl_primitive == DL_UNITDATA_IND)) {
 			inet_freemsg(mp);
-			return;
+			return (0);
 		}
 	}
 	if (DB_TYPE(mp) == M_DATA) {
@@ -3115,6 +3115,7 @@ ip_rput_v6(queue_t *q, mblk_t *mp)
 	} else {
 		ip_rput_notdata(ill, mp);
 	}
+	return (0);
 }
 
 /*
@@ -4828,9 +4829,9 @@ void
 	kstat_t *ksp;
 
 	ip6_stat_t template = {
-		{ "ip6_udp_fannorm", 	KSTAT_DATA_UINT64 },
-		{ "ip6_udp_fanmb", 	KSTAT_DATA_UINT64 },
-		{ "ip6_recv_pullup", 		KSTAT_DATA_UINT64 },
+		{ "ip6_udp_fannorm",	KSTAT_DATA_UINT64 },
+		{ "ip6_udp_fanmb",	KSTAT_DATA_UINT64 },
+		{ "ip6_recv_pullup",		KSTAT_DATA_UINT64 },
 		{ "ip6_db_ref",			KSTAT_DATA_UINT64 },
 		{ "ip6_notaligned",		KSTAT_DATA_UINT64 },
 		{ "ip6_multimblk",		KSTAT_DATA_UINT64 },
diff --git a/usr/src/uts/common/inet/ip/ip_arp.c b/usr/src/uts/common/inet/ip/ip_arp.c
index ab7a1ab209..b271bf33d1 100644
--- a/usr/src/uts/common/inet/ip/ip_arp.c
+++ b/usr/src/uts/common/inet/ip/ip_arp.c
@@ -59,8 +59,8 @@ typedef struct arp_m_s {
 } arp_m_t;
 
 static int arp_close(queue_t *, int, cred_t *);
-static void arp_rput(queue_t *, mblk_t *);
-static void arp_wput(queue_t *, mblk_t *);
+static int arp_rput(queue_t *, mblk_t *);
+static int arp_wput(queue_t *, mblk_t *);
 static arp_m_t	*arp_m_lookup(t_uscalar_t mac_type);
 static void arp_notify(ipaddr_t, mblk_t *, uint32_t, ip_recv_attr_t *,
 	ncec_t *);
@@ -101,11 +101,10 @@ struct module_info arp_mod_info = {
 	IP_MOD_ID, "arp", 1, INFPSZ, 65536, 1024
 };
 static struct qinit rinit_arp = {
-	(pfi_t)arp_rput, NULL, arp_open, arp_close, NULL, &arp_mod_info
+	arp_rput, NULL, arp_open, arp_close, NULL, &arp_mod_info
 };
 static struct qinit winit_arp = {
-	(pfi_t)arp_wput, NULL, arp_open, arp_close, NULL,
-	&arp_mod_info
+	arp_wput, NULL, arp_open, arp_close, NULL, &arp_mod_info
 };
 struct streamtab arpinfo = {
 	&rinit_arp, &winit_arp
@@ -118,52 +117,52 @@ struct streamtab arpinfo = {
  */
 #define	ARP_HOOK_IN(_hook, _event, _ilp, _hdr, _fm, _m, ipst)		\
 									\
-	if ((_hook).he_interested) {                       		\
-		hook_pkt_event_t info;                          	\
+	if ((_hook).he_interested) {					\
+		hook_pkt_event_t info;					\
 									\
 		info.hpe_protocol = ipst->ips_arp_net_data;		\
-		info.hpe_ifp = _ilp;                       		\
-		info.hpe_ofp = 0;                       		\
-		info.hpe_hdr = _hdr;                            	\
-		info.hpe_mp = &(_fm);                           	\
-		info.hpe_mb = _m;                               	\
+		info.hpe_ifp = _ilp;					\
+		info.hpe_ofp = 0;					\
+		info.hpe_hdr = _hdr;					\
+		info.hpe_mp = &(_fm);					\
+		info.hpe_mb = _m;					\
 		if (hook_run(ipst->ips_arp_net_data->netd_hooks,	\
 		    _event, (hook_data_t)&info) != 0) {			\
-			if (_fm != NULL) {                      	\
-				freemsg(_fm);                   	\
-				_fm = NULL;                     	\
-			}                                       	\
-			_hdr = NULL;                            	\
-			_m = NULL;                              	\
-		} else {                                        	\
-			_hdr = info.hpe_hdr;                    	\
-			_m = info.hpe_mb;                       	\
-		}                                               	\
+			if (_fm != NULL) {				\
+				freemsg(_fm);				\
+				_fm = NULL;				\
+			}						\
+			_hdr = NULL;					\
+			_m = NULL;					\
+		} else {						\
+			_hdr = info.hpe_hdr;				\
+			_m = info.hpe_mb;				\
+		}							\
 	}
 
 #define	ARP_HOOK_OUT(_hook, _event, _olp, _hdr, _fm, _m, ipst)		\
 									\
-	if ((_hook).he_interested) {                       		\
-		hook_pkt_event_t info;                          	\
+	if ((_hook).he_interested) {					\
+		hook_pkt_event_t info;					\
 									\
 		info.hpe_protocol = ipst->ips_arp_net_data;		\
-		info.hpe_ifp = 0;                       		\
-		info.hpe_ofp = _olp;                       		\
-		info.hpe_hdr = _hdr;                            	\
-		info.hpe_mp = &(_fm);                           	\
-		info.hpe_mb = _m;                               	\
+		info.hpe_ifp = 0;					\
+		info.hpe_ofp = _olp;					\
+		info.hpe_hdr = _hdr;					\
+		info.hpe_mp = &(_fm);					\
+		info.hpe_mb = _m;					\
 		if (hook_run(ipst->ips_arp_net_data->netd_hooks,	\
 		    _event, (hook_data_t)&info) != 0) {			\
-			if (_fm != NULL) {                      	\
-				freemsg(_fm);                   	\
-				_fm = NULL;                     	\
-			}                                       	\
-			_hdr = NULL;                            	\
-			_m = NULL;                              	\
-		} else {                                        	\
-			_hdr = info.hpe_hdr;                    	\
-			_m = info.hpe_mb;                       	\
-		}                                               	\
+			if (_fm != NULL) {				\
+				freemsg(_fm);				\
+				_fm = NULL;				\
+			}						\
+			_hdr = NULL;					\
+			_m = NULL;					\
+		} else {						\
+			_hdr = info.hpe_hdr;				\
+			_m = info.hpe_mb;				\
+		}							\
 	}
 
 static arp_m_t	arp_m_tbl[] = {
@@ -451,7 +450,7 @@ arp_ll_set_defaults(arl_t *arl, mblk_t *mp)
 	arl_defaults_common(arl, mp);
 }
 
-static void
+static int
 arp_wput(queue_t *q, mblk_t *mp)
 {
 	int err = EINVAL;
@@ -468,7 +467,7 @@ arp_wput(queue_t *q, mblk_t *mp)
 			    char *, "<some ioctl>", char *, "-",
 			    arl_t *, (arl_t *)q->q_ptr);
 			putnext(q, mp);
-			return;
+			break;
 		}
 		if ((mp1 = mp->b_cont) == 0)
 			err = EINVAL;
@@ -480,14 +479,15 @@ arp_wput(queue_t *q, mblk_t *mp)
 			miocack(q, mp, 0, 0);
 		else
 			miocnak(q, mp, 0, err);
-		return;
+		break;
 	default:
 		DTRACE_PROBE4(arl__dlpi, char *, "arp_wput default",
 		    char *, "default mblk", char *, "-",
 		    arl_t *, (arl_t *)q->q_ptr);
 		putnext(q, mp);
-		return;
+		break;
 	}
+	return (0);
 }
 
 /*
@@ -740,7 +740,7 @@ arp_rput_dlpi_writer(ipsq_t *ipsq, queue_t *q, mblk_t *mp, void *dummy_arg)
 	freemsg(mp);
 }
 
-void
+int
 arp_rput(queue_t *q, mblk_t *mp)
 {
 	arl_t		*arl = q->q_ptr;
@@ -756,7 +756,7 @@ arp_rput(queue_t *q, mblk_t *mp)
 		if (DB_TYPE(mp) != M_PCPROTO) {
 			mutex_exit(&arl->arl_lock);
 			freemsg(mp);
-			return;
+			return (0);
 		}
 	} else {
 		arl_refhold_locked(arl);
@@ -806,12 +806,13 @@ arp_rput(queue_t *q, mblk_t *mp)
 	}
 	if (need_refrele)
 		arl_refrele(arl);
+	return (0);
 }
 
 static void
 arp_process_packet(ill_t *ill, mblk_t *mp)
 {
-	mblk_t 		*mp1;
+	mblk_t		*mp1;
 	arh_t		*arh;
 	in_addr_t	src_paddr, dst_paddr;
 	uint32_t	hlen, plen;
@@ -1384,7 +1385,7 @@ arp_ll_up(ill_t *ill)
 	mblk_t	*attach_mp = NULL;
 	mblk_t	*bind_mp = NULL;
 	mblk_t	*unbind_mp = NULL;
-	arl_t 	*arl;
+	arl_t	*arl;
 
 	ASSERT(IAM_WRITER_ILL(ill));
 	arl = ill_to_arl(ill);
@@ -1506,7 +1507,7 @@ arp_notify(in_addr_t src, mblk_t *mp, uint32_t arcn_code,
 		hwm.hwm_hwaddr = (uchar_t *)(arh + 1);
 		hwm.hwm_flags = 0;
 		ncec_walk_common(ipst->ips_ndp4, NULL,
-		    (pfi_t)nce_update_hw_changed, &hwm, B_TRUE);
+		    nce_update_hw_changed, &hwm, B_TRUE);
 		freemsg(mp);
 		break;
 	}
@@ -1773,7 +1774,7 @@ arl_unbind(arl_t *arl)
 int
 arp_ll_down(ill_t *ill)
 {
-	arl_t 	*arl;
+	arl_t	*arl;
 	mblk_t *unbind_mp;
 	int err = 0;
 	boolean_t replumb = (ill->ill_replumbing == 1);
diff --git a/usr/src/uts/common/inet/ip/ip_dummy.c b/usr/src/uts/common/inet/ip/ip_dummy.c
index c304d23f82..0cdb3b1304 100644
--- a/usr/src/uts/common/inet/ip/ip_dummy.c
+++ b/usr/src/uts/common/inet/ip/ip_dummy.c
@@ -37,6 +37,7 @@
  * MIB information comes from IP.
  */
 
+static int	dummy_wput(queue_t *, mblk_t *);
 static int	dummy_modclose(queue_t *, int, cred_t *);
 static int	dummy_modopen(queue_t *q, dev_t *devp, int flag,
 		    int sflag, cred_t *credp);
@@ -52,12 +53,12 @@ struct module_info dummy_mod_info = {
 
 
 static struct qinit dummyrmodinit = {
-	(pfi_t)putnext, NULL, dummy_modopen, dummy_modclose, NULL,
+	dummy_wput, NULL, dummy_modopen, dummy_modclose, NULL,
 	&dummy_mod_info
 };
 
 static struct qinit dummywmodinit = {
-	(pfi_t)putnext, NULL, NULL, NULL, NULL, &dummy_mod_info
+	dummy_wput, NULL, NULL, NULL, NULL, &dummy_mod_info
 };
 
 struct streamtab dummymodinfo = {
@@ -66,6 +67,13 @@ struct streamtab dummymodinfo = {
 
 /* ARGSUSED */
 static int
+dummy_wput(queue_t *q, mblk_t *m)
+{
+	putnext(q, m);
+	return (0);
+}
+
+static int
 dummy_modclose(queue_t *q, int flags __unused, cred_t *credp __unused)
 {
 	qprocsoff(q);
diff --git a/usr/src/uts/common/inet/ip/ip_helper_stream.c b/usr/src/uts/common/inet/ip/ip_helper_stream.c
index 9f40c09acf..06d61d116e 100644
--- a/usr/src/uts/common/inet/ip/ip_helper_stream.c
+++ b/usr/src/uts/common/inet/ip/ip_helper_stream.c
@@ -40,7 +40,7 @@
 #include <sys/vmem.h>
 #include <sys/disp.h>
 
-void ip_helper_wput(queue_t *q, mblk_t *mp);
+int ip_helper_wput(queue_t *q, mblk_t *mp);
 
 static int ip_helper_stream_close(queue_t *, int, cred_t *);
 
@@ -54,7 +54,7 @@ static struct qinit ip_helper_stream_rinit = {
 };
 
 static struct qinit ip_helper_stream_winit = {
-	(pfi_t)ip_helper_wput, (pfi_t)ip_wsrv, NULL, NULL, NULL,
+	ip_helper_wput, ip_wsrv, NULL, NULL, NULL,
 	&ip_helper_stream_info, NULL, NULL, NULL, STRUIOT_NONE
 };
 
@@ -84,7 +84,7 @@ ip_helper_share_conn(queue_t *q, mblk_t *mp, cred_t *crp)
 	miocack(q, mp, 0, 0);
 }
 
-void
+int
 ip_helper_wput(queue_t *q, mblk_t *mp)
 {
 	struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
@@ -96,6 +96,7 @@ ip_helper_wput(queue_t *q, mblk_t *mp)
 		ASSERT(DB_TYPE(mp) != M_DATA);
 		ip_wput_nondata(q, mp);
 	}
+	return (0);
 }
 
 /* ARGSUSED3 */
diff --git a/usr/src/uts/common/inet/ip/ip_if.c b/usr/src/uts/common/inet/ip/ip_if.c
index 60a9035176..1659198968 100644
--- a/usr/src/uts/common/inet/ip/ip_if.c
+++ b/usr/src/uts/common/inet/ip/ip_if.c
@@ -194,8 +194,8 @@ static ip_v6mapinfo_func_t ip_ether_v6_mapping;
 static ip_v4mapinfo_func_t ip_ib_v4_mapping;
 static ip_v6mapinfo_func_t ip_ib_v6_mapping;
 static ip_v4mapinfo_func_t ip_mbcast_mapping;
-static void 	ip_cgtp_bcast_add(ire_t *, ip_stack_t *);
-static void 	ip_cgtp_bcast_delete(ire_t *, ip_stack_t *);
+static void	ip_cgtp_bcast_add(ire_t *, ip_stack_t *);
+static void	ip_cgtp_bcast_delete(ire_t *, ip_stack_t *);
 static void	phyint_free(phyint_t *);
 
 static void ill_capability_dispatch(ill_t *, mblk_t *, dl_capability_sub_t *);
@@ -2290,7 +2290,7 @@ ill_capability_dld_disable(ill_t *ill)
  *
  * state		next state		event, action
  *
- * IDCS_UNKNOWN 	IDCS_PROBE_SENT		ill_capability_probe
+ * IDCS_UNKNOWN		IDCS_PROBE_SENT		ill_capability_probe
  * IDCS_PROBE_SENT	IDCS_OK			ill_capability_ack
  * IDCS_PROBE_SENT	IDCS_FAILED		ip_rput_dlpi_writer (nack)
  * IDCS_OK		IDCS_RENEG		Receipt of DL_NOTE_CAPAB_RENEG
@@ -2310,7 +2310,7 @@ void
 ill_taskq_dispatch(ip_stack_t *ipst)
 {
 	callb_cpr_t cprinfo;
-	char 	name[64];
+	char	name[64];
 	mblk_t	*mp;
 
 	(void) snprintf(name, sizeof (name), "ill_taskq_dispatch_%d",
@@ -3223,10 +3223,10 @@ ill_alloc_ppa(ill_if_t *ifp, ill_t *ill)
 			ill->ill_ppa = --ppa;
 		} else {
 			ppa = (int)(uintptr_t)vmem_xalloc(ifp->illif_ppa_arena,
-			    1, 		/* size */
-			    1, 		/* align/quantum */
-			    0, 		/* phase */
-			    0, 		/* nocross */
+			    1,		/* size */
+			    1,		/* align/quantum */
+			    0,		/* phase */
+			    0,		/* nocross */
 			    (void *)(uintptr_t)(ill->ill_ppa + 1), /* minaddr */
 			    (void *)(uintptr_t)(ill->ill_ppa + 2), /* maxaddr */
 			    VM_NOSLEEP|VM_FIRSTFIT);
@@ -4494,13 +4494,13 @@ ipif_comp_multi(ipif_t *old_ipif, ipif_t *new_ipif, boolean_t isv6)
  * condemned, not an underlying interface in an IPMP group, and
  * not a VNI interface.  Order of preference:
  *
- * 	1a. normal
- * 	1b. normal, but deprecated
- * 	2a. point to point
- * 	2b. point to point, but deprecated
- * 	3a. link local
- * 	3b. link local, but deprecated
- * 	4. loopback.
+ *	1a. normal
+ *	1b. normal, but deprecated
+ *	2a. point to point
+ *	2b. point to point, but deprecated
+ *	3a. link local
+ *	3b. link local, but deprecated
+ *	4. loopback.
  */
 static ipif_t *
 ipif_lookup_multicast(ip_stack_t *ipst, zoneid_t zoneid, boolean_t isv6)
@@ -5029,7 +5029,7 @@ ipif_ill_refrele_tail(ill_t *ill)
 	ASSERT(ipx->ipx_pending_mp != NULL && ipx->ipx_pending_ipif != NULL);
 
 	ipif = ipx->ipx_pending_ipif;
-	if (ipif->ipif_ill != ill) 	/* wait is for another ill; bail */
+	if (ipif->ipif_ill != ill)	/* wait is for another ill; bail */
 		goto unlock;
 
 	switch (ipx->ipx_waitfor) {
@@ -5468,7 +5468,7 @@ ip_mcast_mapping(ill_t *ill, uchar_t *addr, uchar_t *hwaddr)
  *
  * The netmask can be verified to be contiguous with 32 shifts and or
  * operations. Take the contiguous mask (in host byte order) and compute
- * 	mask | mask << 1 | mask << 2 | ... | mask << 31
+ *	mask | mask << 1 | mask << 2 | ... | mask << 31
  * the result will be the same as the 'mask' for contiguous mask.
  */
 static boolean_t
@@ -7953,7 +7953,7 @@ ip_sioctl_ip6addrpolicy(queue_t *q, mblk_t *mp)
 static void
 ip_sioctl_dstinfo(queue_t *q, mblk_t *mp)
 {
-	mblk_t 		*data_mp;
+	mblk_t		*data_mp;
 	struct dstinforeq	*dir;
 	uint8_t		*end, *cur;
 	in6_addr_t	*daddr, *saddr;
@@ -8704,7 +8704,7 @@ ip_sioctl_plink_ipmod(ipsq_t *ipsq, queue_t *q, mblk_t *mp, int ioccmd,
     struct linkblk *li)
 {
 	int		err = 0;
-	ill_t  		*ill;
+	ill_t		*ill;
 	queue_t		*ipwq, *dwq;
 	const char	*name;
 	struct qinit	*qinfo;
@@ -8723,12 +8723,12 @@ ip_sioctl_plink_ipmod(ipsq_t *ipsq, queue_t *q, mblk_t *mp, int ioccmd,
 		qinfo = ipwq->q_qinfo;
 		name = qinfo->qi_minfo->mi_idname;
 		if (name != NULL && strcmp(name, ip_mod_info.mi_idname) == 0 &&
-		    qinfo->qi_putp != (pfi_t)ip_lwput && ipwq->q_next != NULL) {
+		    qinfo->qi_putp != ip_lwput && ipwq->q_next != NULL) {
 			is_ip = B_TRUE;
 			break;
 		}
 		if (name != NULL && strcmp(name, arp_mod_info.mi_idname) == 0 &&
-		    qinfo->qi_putp != (pfi_t)ip_lwput && ipwq->q_next != NULL) {
+		    qinfo->qi_putp != ip_lwput && ipwq->q_next != NULL) {
 			break;
 		}
 	}
@@ -9372,7 +9372,7 @@ ip_sioctl_addif(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
 	struct lifreq *lifr;
 	boolean_t	isv6;
 	boolean_t	exists;
-	char 	*name;
+	char	*name;
 	char	*endp;
 	char	*cp;
 	int	namelen;
@@ -10260,7 +10260,7 @@ ip_sioctl_flags_onoff(ipif_t *ipif, uint64_t flags, uint64_t *onp,
     uint64_t *offp)
 {
 	ill_t		*ill = ipif->ipif_ill;
-	phyint_t 	*phyi = ill->ill_phyint;
+	phyint_t	*phyi = ill->ill_phyint;
 	uint64_t	cantchange_flags, intf_flags;
 	uint64_t	turn_on, turn_off;
 
@@ -12244,7 +12244,7 @@ ipif_arp_down(ipif_t *ipif)
  * basic DAD related initialization for IPv6. Honors ILLF_NOARP.
  *
  * The enumerated value res_act tunes the behavior:
- * 	* Res_act_initial: set up all the resolver structures for a new
+ *	* Res_act_initial: set up all the resolver structures for a new
  *	  IP address.
  *	* Res_act_defend: tell ARP that it needs to send a single gratuitous
  *	  ARP message in defense of the address.
@@ -14418,7 +14418,7 @@ int
 ipif_up(ipif_t *ipif, queue_t *q, mblk_t *mp)
 {
 	ill_t		*ill = ipif->ipif_ill;
-	boolean_t 	isv6 = ipif->ipif_isv6;
+	boolean_t	isv6 = ipif->ipif_isv6;
 	int		err = 0;
 	boolean_t	success;
 	uint_t		ipif_orig_id;
@@ -15374,8 +15374,8 @@ ipif_good_addr(ill_t *ill, zoneid_t zoneid)
  */
 typedef enum {
 	IPIF_NONE,
-	IPIF_DIFFNET_DEPRECATED, 	/* deprecated and different subnet */
-	IPIF_SAMENET_DEPRECATED, 	/* deprecated and same subnet */
+	IPIF_DIFFNET_DEPRECATED,	/* deprecated and different subnet */
+	IPIF_SAMENET_DEPRECATED,	/* deprecated and same subnet */
 	IPIF_DIFFNET_ALLZONES,		/* allzones and different subnet */
 	IPIF_SAMENET_ALLZONES,		/* allzones and same subnet */
 	IPIF_DIFFNET,			/* normal and different subnet */
@@ -15700,7 +15700,7 @@ if_unitsel(ipif_t *dummy_ipif, sin_t *dummy_sin, queue_t *q, mblk_t *mp,
     ip_ioctl_cmd_t *ipip, void *dummy_ifreq)
 {
 	queue_t		*q1 = q;
-	char 		*cp;
+	char		*cp;
 	char		interf_name[LIFNAMSIZ];
 	uint_t		ppa = *(uint_t *)mp->b_cont->b_cont->b_rptr;
 
@@ -17484,7 +17484,7 @@ ip_ipmp_v6intfid(ill_t *ill, in6_addr_t *v6addr)
 	zone_t		*zp;
 	uint8_t		*addr;
 	uchar_t		hash[16];
-	ulong_t 	hostid;
+	ulong_t		hostid;
 	MD5_CTX		ctx;
 	ipmp_ifcookie_t	ic = { 0 };
 
@@ -18584,8 +18584,8 @@ arp_up_done:
 int
 ipif_arp_up(ipif_t *ipif, enum ip_resolver_action res_act, boolean_t was_dup)
 {
-	int 		err = 0;
-	ill_t 		*ill = ipif->ipif_ill;
+	int		err = 0;
+	ill_t		*ill = ipif->ipif_ill;
 	boolean_t	first_interface, wait_for_dlpi = B_FALSE;
 
 	DTRACE_PROBE3(ipif__downup, char *, "ipif_arp_up",
@@ -19082,8 +19082,7 @@ ipif_nce_down(ipif_t *ipif)
 	 * is going away.
 	 */
 	if (ill->ill_ipif_up_count == 0) {
-		ncec_walk(ill, (pfi_t)ncec_delete_per_ill,
-		    (uchar_t *)ill, ill->ill_ipst);
+		ncec_walk(ill, ncec_delete_per_ill, ill, ill->ill_ipst);
 		if (IS_UNDER_IPMP(ill))
 			nce_flush(ill, B_TRUE);
 	}
diff --git a/usr/src/uts/common/inet/ip/ip_ndp.c b/usr/src/uts/common/inet/ip/ip_ndp.c
index 2cb91f8c41..eabe8949ae 100644
--- a/usr/src/uts/common/inet/ip/ip_ndp.c
+++ b/usr/src/uts/common/inet/ip/ip_ndp.c
@@ -107,7 +107,7 @@
  */
 
 static	void	nce_cleanup_list(ncec_t *ncec);
-static	void 	nce_set_ll(ncec_t *ncec, uchar_t *ll_addr);
+static	void	nce_set_ll(ncec_t *ncec, uchar_t *ll_addr);
 static	ncec_t	*ncec_lookup_illgrp(ill_t *, const in6_addr_t *,
     ncec_t *);
 static	nce_t	*nce_lookup_addr(ill_t *, const in6_addr_t *);
@@ -126,7 +126,7 @@ static	int	nce_add_common(ill_t *, uchar_t *, uint_t, const in6_addr_t *,
 static nce_t *nce_add_impl(ill_t *, ncec_t *, nce_t *, mblk_t *);
 static nce_t *nce_add(ill_t *, ncec_t *);
 static void nce_inactive(nce_t *);
-extern nce_t 	*nce_lookup(ill_t *, const in6_addr_t *);
+extern nce_t	*nce_lookup(ill_t *, const in6_addr_t *);
 static nce_t *nce_ill_lookup_then_add(ill_t *, ncec_t *);
 static int	nce_add_v6(ill_t *, uchar_t *, uint_t, const in6_addr_t *,
     uint16_t, uint16_t, nce_t **);
@@ -596,9 +596,9 @@ ncec_inactive(ncec_t *ncec)
  * that is going away.  Always called as a writer.
  */
 void
-ncec_delete_per_ill(ncec_t *ncec, uchar_t *arg)
+ncec_delete_per_ill(ncec_t *ncec, void *arg)
 {
-	if ((ncec != NULL) && ncec->ncec_ill == (ill_t *)arg) {
+	if ((ncec != NULL) && ncec->ncec_ill == arg) {
 		ncec_delete(ncec);
 	}
 }
@@ -934,13 +934,13 @@ nce_process(ncec_t *ncec, uchar_t *hw_addr, uint32_t flag, boolean_t is_adv)
 }
 
 /*
- * Pass arg1 to the pfi supplied, along with each ncec in existence.
+ * Pass arg1 to the cbf supplied, along with each ncec in existence.
  * ncec_walk() places a REFHOLD on the ncec and drops the lock when
  * walking the hash list.
  */
 void
-ncec_walk_common(ndp_g_t *ndp, ill_t *ill, pfi_t pfi, void *arg1,
-    boolean_t trace)
+ncec_walk_common(ndp_g_t *ndp, ill_t *ill, ncec_walk_cb_t cbf,
+    void *arg1, boolean_t trace)
 {
 	ncec_t	*ncec;
 	ncec_t	*ncec1;
@@ -958,11 +958,11 @@ ncec_walk_common(ndp_g_t *ndp, ill_t *ill, pfi_t pfi, void *arg1,
 			if (ill == NULL || ncec->ncec_ill == ill) {
 				if (trace) {
 					ncec_refhold(ncec);
-					(*pfi)(ncec, arg1);
+					(*cbf)(ncec, arg1);
 					ncec_refrele(ncec);
 				} else {
 					ncec_refhold_notr(ncec);
-					(*pfi)(ncec, arg1);
+					(*cbf)(ncec, arg1);
 					ncec_refrele_notr(ncec);
 				}
 			}
@@ -994,10 +994,10 @@ ncec_walk_common(ndp_g_t *ndp, ill_t *ill, pfi_t pfi, void *arg1,
  * Note that ill can be NULL hence can't derive the ipst from it.
  */
 void
-ncec_walk(ill_t *ill, pfi_t pfi, void *arg1, ip_stack_t *ipst)
+ncec_walk(ill_t *ill, ncec_walk_cb_t cbf, void *arg1, ip_stack_t *ipst)
 {
-	ncec_walk_common(ipst->ips_ndp4, ill, pfi, arg1, B_TRUE);
-	ncec_walk_common(ipst->ips_ndp6, ill, pfi, arg1, B_TRUE);
+	ncec_walk_common(ipst->ips_ndp4, ill, cbf, arg1, B_TRUE);
+	ncec_walk_common(ipst->ips_ndp6, ill, cbf, arg1, B_TRUE);
 }
 
 /*
@@ -2124,7 +2124,7 @@ ndp_xmit(ill_t *ill, uint32_t operation, uint8_t *hw_addr, uint_t hw_addr_len,
     const in6_addr_t *sender, const in6_addr_t *target, int flag)
 {
 	uint32_t	len;
-	icmp6_t 	*icmp6;
+	icmp6_t		*icmp6;
 	mblk_t		*mp;
 	ip6_t		*ip6h;
 	nd_opt_hdr_t	*opt;
@@ -3405,7 +3405,7 @@ ndp_verify_optlen(nd_opt_hdr_t *opt, int optlen)
  * order of ncec_last and/or maintain state)
  */
 static void
-ncec_cache_reclaim(ncec_t *ncec, char *arg)
+ncec_cache_reclaim(ncec_t *ncec, void *arg)
 {
 	ip_stack_t	*ipst = ncec->ncec_ipst;
 	uint_t		fraction = *(uint_t *)arg;
@@ -3436,7 +3436,7 @@ ip_nce_reclaim_stack(ip_stack_t *ipst)
 
 	IP_STAT(ipst, ip_nce_reclaim_calls);
 
-	ncec_walk(NULL, (pfi_t)ncec_cache_reclaim, (uchar_t *)&fraction, ipst);
+	ncec_walk(NULL, ncec_cache_reclaim, &fraction, ipst);
 
 	/*
 	 * Walk all CONNs that can have a reference on an ire, ncec or dce.
@@ -4363,7 +4363,7 @@ ip_nce_lookup_and_update(ipaddr_t *addr, ipif_t *ipif, ip_stack_t *ipst,
 		hwm.hwm_flags = flags;
 
 		ncec_walk_common(ipst->ips_ndp4, NULL,
-		    (pfi_t)nce_update_hw_changed, (uchar_t *)&hwm, B_TRUE);
+		    nce_update_hw_changed, &hwm, B_TRUE);
 	}
 }
 
diff --git a/usr/src/uts/common/inet/ip/ip_squeue.c b/usr/src/uts/common/inet/ip/ip_squeue.c
index 3fb27abfbe..b6565d9c1f 100644
--- a/usr/src/uts/common/inet/ip/ip_squeue.c
+++ b/usr/src/uts/common/inet/ip/ip_squeue.c
@@ -498,7 +498,7 @@ ip_squeue_add_ring(ill_t *ill, void *mrp)
 	}
 
 	bzero(rx_ring, sizeof (ill_rx_ring_t));
-	rx_ring->rr_rx = (ip_mac_rx_t)mrfp->mrf_receive;
+	rx_ring->rr_rx = mrfp->mrf_receive;
 	/* XXX: Hard code it to tcp accept for now */
 	rx_ring->rr_ip_accept = (ip_accept_t)ip_accept_tcp;
 
@@ -673,7 +673,7 @@ ip_squeue_clean_all(ill_t *ill)
 squeue_t *
 ip_squeue_get(ill_rx_ring_t *ill_rx_ring)
 {
-	squeue_t 	*sqp;
+	squeue_t	*sqp;
 
 	if ((ill_rx_ring == NULL) || ((sqp = ill_rx_ring->rr_sqp) == NULL))
 		return (IP_SQUEUE_GET(CPU_PSEUDO_RANDOM()));
diff --git a/usr/src/uts/common/inet/ip/ipmp.c b/usr/src/uts/common/inet/ip/ipmp.c
index 3be5bb7c75..912b489c40 100644
--- a/usr/src/uts/common/inet/ip/ipmp.c
+++ b/usr/src/uts/common/inet/ip/ipmp.c
@@ -90,7 +90,7 @@ static void	ipmp_ill_bind_ipif(ill_t *, ipif_t *, enum ip_resolver_action);
 static ipif_t	*ipmp_ill_unbind_ipif(ill_t *, ipif_t *, boolean_t);
 static void	ipmp_phyint_get_kstats(phyint_t *, uint64_t *);
 static boolean_t ipmp_ipif_is_up_dataaddr(const ipif_t *);
-static void	ipmp_ncec_delete_nonlocal(ncec_t *, uchar_t *);
+static void	ipmp_ncec_delete_nonlocal(ncec_t *, void *);
 
 /*
  * Initialize IPMP state for IP stack `ipst'; called from ip_stack_init().
@@ -800,7 +800,7 @@ ipmp_illgrp_set_cast(ipmp_illgrp_t *illg, ill_t *castill)
 		 * last since ill_leave_multicast() may trigger IREs to be
 		 * built using ig_cast_ill.
 		 */
-		ncec_walk(ocastill, (pfi_t)ipmp_ncec_delete_nonlocal, ocastill,
+		ncec_walk(ocastill, ipmp_ncec_delete_nonlocal, ocastill,
 		    ocastill->ill_ipst);
 	}
 
@@ -1592,7 +1592,7 @@ ipmp_ill_deactivate(ill_t *ill)
 	 * any NCECs associated with the group and mark the group link down.
 	 */
 	if (--grp->gr_nactif == 0) {
-		ncec_walk(ipmp_ill, (pfi_t)ncec_delete_per_ill, ipmp_ill, ipst);
+		ncec_walk(ipmp_ill, ncec_delete_per_ill, ipmp_ill, ipst);
 		mp = grp->gr_linkdownmp;
 		grp->gr_linkdownmp = NULL;
 		ASSERT(mp != NULL);
@@ -2182,7 +2182,7 @@ ipmp_packet_is_probe(mblk_t *mp, ill_t *ill)
  * is not one of our local addresses.  Caller must be inside the IPSQ.
  */
 static void
-ipmp_ncec_delete_nonlocal(ncec_t *ncec, uchar_t *ill_arg)
+ipmp_ncec_delete_nonlocal(ncec_t *ncec, void *ill_arg)
 {
 	if (!NCE_MYADDR(ncec) && ncec->ncec_ill == (ill_t *)ill_arg)
 		ncec_delete(ncec);
diff --git a/usr/src/uts/common/inet/ip/rts.c b/usr/src/uts/common/inet/ip/rts.c
index ee092ef18e..ba3d2391df 100644
--- a/usr/src/uts/common/inet/ip/rts.c
+++ b/usr/src/uts/common/inet/ip/rts.c
@@ -120,10 +120,10 @@ static int	rts_param_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *cr);
 static boolean_t rts_param_register(IDP *ndp, rtsparam_t *rtspa, int cnt);
 static int	rts_param_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp,
     cred_t *cr);
-static void	rts_rsrv(queue_t *q);
+static int	rts_rsrv(queue_t *q);
 static void	*rts_stack_init(netstackid_t stackid, netstack_t *ns);
 static void	rts_stack_fini(netstackid_t stackid, void *arg);
-static void	rts_wput(queue_t *q, mblk_t *mp);
+static int	rts_wput(queue_t *q, mblk_t *mp);
 static void	rts_wput_iocdata(queue_t *q, mblk_t *mp);
 static void	rts_wput_other(queue_t *q, mblk_t *mp);
 static int	rts_wrw(queue_t *q, struiod_t *dp);
@@ -141,13 +141,13 @@ static struct module_info rts_mod_info = {
 };
 
 static struct qinit rtsrinit = {
-	NULL, (pfi_t)rts_rsrv, rts_stream_open, rts_stream_close, NULL,
+	NULL, rts_rsrv, rts_stream_open, rts_stream_close, NULL,
 	&rts_mod_info
 };
 
 static struct qinit rtswinit = {
-	(pfi_t)rts_wput, NULL, NULL, NULL, NULL, &rts_mod_info,
-	NULL, (pfi_t)rts_wrw, NULL, STRUIOT_STANDARD
+	rts_wput, NULL, NULL, NULL, NULL, &rts_mod_info,
+	NULL, rts_wrw, NULL, STRUIOT_STANDARD
 };
 
 struct streamtab rtsinfo = {
@@ -817,9 +817,10 @@ rts_param_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp, cred_t *cr)
  * of a thread in qwait.
  */
 /*ARGSUSED*/
-static void
+static int
 rts_rsrv(queue_t *q)
 {
+	return (0);
 }
 
 /*
@@ -919,7 +920,7 @@ err_ret:
  * a message. The data messages that go down are wrapped in an IOCTL
  * message.
  */
-static void
+static int
 rts_wput(queue_t *q, mblk_t *mp)
 {
 	uchar_t	*rptr = mp->b_rptr;
@@ -938,7 +939,7 @@ rts_wput(queue_t *q, mblk_t *mp)
 				mp1 = mp->b_cont;
 				freeb(mp);
 				if (mp1 == NULL)
-					return;
+					return (0);
 				mp = mp1;
 				break;
 			}
@@ -946,7 +947,7 @@ rts_wput(queue_t *q, mblk_t *mp)
 		/* FALLTHRU */
 	default:
 		rts_wput_other(q, mp);
-		return;
+		return (0);
 	}
 
 
@@ -960,9 +961,10 @@ rts_wput(queue_t *q, mblk_t *mp)
 			rts->rts_error = ENOMEM;
 			rts->rts_flag &= ~RTS_WPUT_PENDING;
 		}
-		return;
+		return (0);
 	}
 	ip_wput_nondata(q, mp1);
+	return (0);
 }
 
 
diff --git a/usr/src/uts/common/inet/ip6.h b/usr/src/uts/common/inet/ip6.h
index b7954a9a4d..4f5b81c12f 100644
--- a/usr/src/uts/common/inet/ip6.h
+++ b/usr/src/uts/common/inet/ip6.h
@@ -154,7 +154,7 @@ typedef enum {
 				(a).s6_addr32[0] == 0)
 
 #else
-#define	V6_OR_V4_INADDR_ANY(a)	((a).s6_addr32[3] == 0 && 		\
+#define	V6_OR_V4_INADDR_ANY(a)	((a).s6_addr32[3] == 0 &&		\
 				((a).s6_addr32[2] == 0xffff0000U ||	\
 				(a).s6_addr32[2] == 0) &&		\
 				(a).s6_addr32[1] == 0 &&		\
@@ -207,7 +207,7 @@ typedef enum {
 	(d).s6_addr32[3] = (s).s6_addr32[3] & (m).s6_addr32[3])
 
 #define	ILL_FRAG_HASH_V6(v6addr, i)					\
-	((ntohl((v6addr).s6_addr32[3]) ^ (i ^ (i >> 8))) % 		\
+	((ntohl((v6addr).s6_addr32[3]) ^ (i ^ (i >> 8))) %		\
 						ILL_FRAG_HASH_TBL_COUNT)
 
 
@@ -272,7 +272,7 @@ extern mblk_t	*ipsec_early_ah_v6(mblk_t *, ip_recv_attr_t *);
 extern int	ipsec_ah_get_hdr_size_v6(mblk_t *, boolean_t);
 extern void	ip_send_potential_redirect_v6(mblk_t *, ip6_t *, ire_t *,
     ip_recv_attr_t *);
-extern void	ip_rput_v6(queue_t *, mblk_t *);
+extern int	ip_rput_v6(queue_t *, mblk_t *);
 extern mblk_t	*mld_input(mblk_t *, ip_recv_attr_t *);
 extern void	mld_joingroup(ilm_t *);
 extern void	mld_leavegroup(ilm_t *);
diff --git a/usr/src/uts/common/inet/ip_ndp.h b/usr/src/uts/common/inet/ip_ndp.h
index 21c907f3f3..ae9463720c 100644
--- a/usr/src/uts/common/inet/ip_ndp.h
+++ b/usr/src/uts/common/inet/ip_ndp.h
@@ -67,7 +67,7 @@ typedef struct ncec_cb_s {
 struct ncec_s {
 	struct	ncec_s	*ncec_next;	/* Hash chain next pointer */
 	struct	ncec_s	**ncec_ptpn;	/* Pointer to previous next */
-	struct 	ill_s	*ncec_ill;	/* Associated ill */
+	struct	ill_s	*ncec_ill;	/* Associated ill */
 	uint16_t	ncec_flags;	/* See below */
 	uint16_t	ncec_state;	/* See reachability states in if.h */
 	int16_t		ncec_pcnt;	/* Probe counter */
@@ -273,9 +273,11 @@ typedef struct {
 /* NDP Cache Entry Hash Table */
 #define	NCE_TABLE_SIZE	256
 
+typedef void (*ncec_walk_cb_t)(ncec_t *, void *);
+
 extern	void	ip_nce_reclaim(void *);
 extern	void	ncec_delete(ncec_t *);
-extern	void	ncec_delete_per_ill(ncec_t *, uchar_t *);
+extern	void	ncec_delete_per_ill(ncec_t *, void *);
 extern	void	nce_fastpath_update(ill_t *, mblk_t  *);
 extern	nd_opt_hdr_t *ndp_get_option(nd_opt_hdr_t *, int, int);
 extern	void	ncec_inactive(ncec_t *);
@@ -293,8 +295,8 @@ extern	int	ndp_query(ill_t *, lif_nd_req_t *);
 extern	int	ndp_sioc_update(ill_t *, lif_nd_req_t *);
 extern	boolean_t	ndp_verify_optlen(nd_opt_hdr_t *, int);
 extern	void	nce_timer(void *);
-extern	void	ncec_walk(ill_t *, pfi_t, void *, ip_stack_t *);
-extern	void	ncec_walk_common(ndp_g_t *, ill_t *, pfi_t,
+extern	void	ncec_walk(ill_t *, ncec_walk_cb_t, void *, ip_stack_t *);
+extern	void	ncec_walk_common(ndp_g_t *, ill_t *, ncec_walk_cb_t,
     void *, boolean_t);
 extern	boolean_t	nce_restart_dad(ncec_t *);
 extern	void	ndp_resolv_failed(ncec_t *);
diff --git a/usr/src/uts/common/inet/tcp/tcp.c b/usr/src/uts/common/inet/tcp/tcp.c
index d86680c4b5..79c9478558 100644
--- a/usr/src/uts/common/inet/tcp/tcp.c
+++ b/usr/src/uts/common/inet/tcp/tcp.c
@@ -286,7 +286,7 @@ static void	tcp_iss_init(tcp_t *tcp);
 static void	tcp_reinit(tcp_t *tcp);
 static void	tcp_reinit_values(tcp_t *tcp);
 
-static void	tcp_wsrv(queue_t *q);
+static int	tcp_wsrv(queue_t *q);
 static void	tcp_update_lso(tcp_t *tcp, ip_xmit_attr_t *ixa);
 static void	tcp_update_zcopy(tcp_t *tcp);
 static void	tcp_notify(void *, ip_xmit_attr_t *, ixa_notify_type_t,
@@ -316,25 +316,25 @@ static struct module_info tcp_winfo =  {
  * We have separate open functions for the /dev/tcp and /dev/tcp6 devices.
  */
 struct qinit tcp_rinitv4 = {
-	NULL, (pfi_t)tcp_rsrv, tcp_openv4, tcp_tpi_close, NULL, &tcp_rinfo
+	NULL, tcp_rsrv, tcp_openv4, tcp_tpi_close, NULL, &tcp_rinfo
 };
 
 struct qinit tcp_rinitv6 = {
-	NULL, (pfi_t)tcp_rsrv, tcp_openv6, tcp_tpi_close, NULL, &tcp_rinfo
+	NULL, tcp_rsrv, tcp_openv6, tcp_tpi_close, NULL, &tcp_rinfo
 };
 
 struct qinit tcp_winit = {
-	(pfi_t)tcp_wput, (pfi_t)tcp_wsrv, NULL, NULL, NULL, &tcp_winfo
+	tcp_wput, tcp_wsrv, NULL, NULL, NULL, &tcp_winfo
 };
 
 /* Initial entry point for TCP in socket mode. */
 struct qinit tcp_sock_winit = {
-	(pfi_t)tcp_wput_sock, (pfi_t)tcp_wsrv, NULL, NULL, NULL, &tcp_winfo
+	tcp_wput_sock, tcp_wsrv, NULL, NULL, NULL, &tcp_winfo
 };
 
 /* TCP entry point during fallback */
 struct qinit tcp_fallback_sock_winit = {
-	(pfi_t)tcp_wput_fallback, NULL, NULL, NULL, NULL, &tcp_winfo
+	tcp_wput_fallback, NULL, NULL, NULL, NULL, &tcp_winfo
 };
 
 /*
@@ -343,11 +343,11 @@ struct qinit tcp_fallback_sock_winit = {
  * been created.
  */
 struct qinit tcp_acceptor_rinit = {
-	NULL, (pfi_t)tcp_rsrv, NULL, tcp_tpi_close_accept, NULL, &tcp_winfo
+	NULL, tcp_rsrv, NULL, tcp_tpi_close_accept, NULL, &tcp_winfo
 };
 
 struct qinit tcp_acceptor_winit = {
-	(pfi_t)tcp_tpi_accept, NULL, NULL, NULL, NULL, &tcp_winfo
+	tcp_tpi_accept, NULL, NULL, NULL, NULL, &tcp_winfo
 };
 
 /* For AF_INET aka /dev/tcp */
@@ -1036,7 +1036,7 @@ void
 tcp_close_common(conn_t *connp, int flags)
 {
 	tcp_t		*tcp = connp->conn_tcp;
-	mblk_t 		*mp = &tcp->tcp_closemp;
+	mblk_t		*mp = &tcp->tcp_closemp;
 	boolean_t	conn_ioctl_cleanup_reqd = B_FALSE;
 	mblk_t		*bp;
 
@@ -1488,7 +1488,7 @@ tcp_get_conn(void *arg, tcp_stack_t *tcps)
 	tcp_t			*tcp = NULL;
 	conn_t			*connp = NULL;
 	squeue_t		*sqp = (squeue_t *)arg;
-	tcp_squeue_priv_t 	*tcp_time_wait;
+	tcp_squeue_priv_t	*tcp_time_wait;
 	netstack_t		*ns;
 	mblk_t			*tcp_rsrv_mp = NULL;
 
@@ -1568,8 +1568,8 @@ static int
 tcp_connect_ipv4(tcp_t *tcp, ipaddr_t *dstaddrp, in_port_t dstport,
     uint_t srcid)
 {
-	ipaddr_t 	dstaddr = *dstaddrp;
-	uint16_t 	lport;
+	ipaddr_t	dstaddr = *dstaddrp;
+	uint16_t	lport;
 	conn_t		*connp = tcp->tcp_connp;
 	tcp_stack_t	*tcps = tcp->tcp_tcps;
 	int		error;
@@ -1657,7 +1657,7 @@ static int
 tcp_connect_ipv6(tcp_t *tcp, in6_addr_t *dstaddrp, in_port_t dstport,
     uint32_t flowinfo, uint_t srcid, uint32_t scope_id)
 {
-	uint16_t 	lport;
+	uint16_t	lport;
 	conn_t		*connp = tcp->tcp_connp;
 	tcp_stack_t	*tcps = tcp->tcp_tcps;
 	int		error;
@@ -3431,12 +3431,13 @@ tcp_notify(void *arg, ip_xmit_attr_t *ixa, ixa_notify_type_t ntype,
  * The TCP write service routine should never be called...
  */
 /* ARGSUSED */
-static void
+static int
 tcp_wsrv(queue_t *q)
 {
 	tcp_stack_t	*tcps = Q_TO_TCP(q)->tcp_tcps;
 
 	TCP_STAT(tcps, tcp_wsrv_called);
+	return (0);
 }
 
 /*
diff --git a/usr/src/uts/common/inet/tcp/tcp_input.c b/usr/src/uts/common/inet/tcp/tcp_input.c
index 1157023ab2..1b8dc0dcec 100644
--- a/usr/src/uts/common/inet/tcp/tcp_input.c
+++ b/usr/src/uts/common/inet/tcp/tcp_input.c
@@ -784,12 +784,12 @@ static mblk_t *
 tcp_conn_create_v6(conn_t *lconnp, conn_t *connp, mblk_t *mp,
     ip_recv_attr_t *ira)
 {
-	tcp_t 		*ltcp = lconnp->conn_tcp;
+	tcp_t		*ltcp = lconnp->conn_tcp;
 	tcp_t		*tcp = connp->conn_tcp;
 	mblk_t		*tpi_mp;
 	ipha_t		*ipha;
 	ip6_t		*ip6h;
-	sin6_t 		sin6;
+	sin6_t		sin6;
 	uint_t		ifindex = ira->ira_ruifindex;
 	tcp_stack_t	*tcps = tcp->tcp_tcps;
 
@@ -881,7 +881,7 @@ static mblk_t *
 tcp_conn_create_v4(conn_t *lconnp, conn_t *connp, mblk_t *mp,
     ip_recv_attr_t *ira)
 {
-	tcp_t 		*ltcp = lconnp->conn_tcp;
+	tcp_t		*ltcp = lconnp->conn_tcp;
 	tcp_t		*tcp = connp->conn_tcp;
 	sin_t		sin;
 	mblk_t		*tpi_mp = NULL;
@@ -987,7 +987,7 @@ boolean_t
 tcp_eager_blowoff(tcp_t	*listener, t_scalar_t seqnum)
 {
 	tcp_t	*eager;
-	mblk_t 	*mp;
+	mblk_t	*mp;
 
 	eager = listener;
 	mutex_enter(&listener->tcp_eager_lock);
@@ -1157,7 +1157,7 @@ tcp_eager_unlink(tcp_t *tcp)
  *
  * incoming SYN (listener perimeter)	-> tcp_input_listener()
  *
- * incoming SYN-ACK-ACK (eager perim) 	-> tcp_input_data()
+ * incoming SYN-ACK-ACK (eager perim)	-> tcp_input_data()
  * send T_CONN_IND (listener perim)	-> tcp_send_conn_ind()
  *
  * Sockfs ACCEPT Path:
@@ -1268,7 +1268,7 @@ tcp_input_listener(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *ira)
 	conn_t		*econnp = NULL;
 	squeue_t	*new_sqp;
 	mblk_t		*mp1;
-	uint_t 		ip_hdr_len;
+	uint_t		ip_hdr_len;
 	conn_t		*lconnp = (conn_t *)arg;
 	tcp_t		*listener = lconnp->conn_tcp;
 	tcp_stack_t	*tcps = listener->tcp_tcps;
@@ -5456,7 +5456,7 @@ tcp_rsrv_input(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
  * TCP, we have no data to send out of here.  What we do is clear the receive
  * window, and send out a window update.
  */
-void
+int
 tcp_rsrv(queue_t *q)
 {
 	conn_t		*connp = Q_TO_CONN(q);
@@ -5473,7 +5473,7 @@ tcp_rsrv(queue_t *q)
 	mutex_enter(&tcp->tcp_rsrv_mp_lock);
 	if ((mp = tcp->tcp_rsrv_mp) == NULL) {
 		mutex_exit(&tcp->tcp_rsrv_mp_lock);
-		return;
+		return (0);
 	}
 	tcp->tcp_rsrv_mp = NULL;
 	mutex_exit(&tcp->tcp_rsrv_mp_lock);
@@ -5481,6 +5481,7 @@ tcp_rsrv(queue_t *q)
 	CONN_INC_REF(connp);
 	SQUEUE_ENTER_ONE(connp->conn_sqp, mp, tcp_rsrv_input, connp,
 	    NULL, SQ_PROCESS, SQTAG_TCP_RSRV);
+	return (0);
 }
 
 /* At minimum we need 8 bytes in the TCP header for the lookup */
diff --git a/usr/src/uts/common/inet/tcp/tcp_output.c b/usr/src/uts/common/inet/tcp/tcp_output.c
index fedff0b962..60840a3d54 100644
--- a/usr/src/uts/common/inet/tcp/tcp_output.c
+++ b/usr/src/uts/common/inet/tcp/tcp_output.c
@@ -80,7 +80,7 @@ static void	tcp_wput_proto(void *, mblk_t *, void *, ip_recv_attr_t *);
  */
 static int tcp_tx_pull_len = 16;
 
-void
+int
 tcp_wput(queue_t *q, mblk_t *mp)
 {
 	conn_t	*connp = Q_TO_CONN(q);
@@ -110,11 +110,11 @@ tcp_wput(queue_t *q, mblk_t *mp)
 		CONN_INC_REF(connp);
 		SQUEUE_ENTER_ONE(connp->conn_sqp, mp, tcp_output, connp,
 		    NULL, tcp_squeue_flag, SQTAG_TCP_OUTPUT);
-		return;
+		return (0);
 
 	case M_CMD:
 		tcp_wput_cmdblk(q, mp);
-		return;
+		return (0);
 
 	case M_PROTO:
 	case M_PCPROTO:
@@ -132,7 +132,7 @@ tcp_wput(queue_t *q, mblk_t *mp)
 				    "tcp_wput_proto, dropping one...");
 			}
 			freemsg(mp);
-			return;
+			return (0);
 		}
 		if (type == T_SVR4_OPTMGMT_REQ) {
 			/*
@@ -147,14 +147,14 @@ tcp_wput(queue_t *q, mblk_t *mp)
 			ASSERT(cr != NULL);
 			if (cr == NULL) {
 				tcp_err_ack(tcp, mp, TSYSERR, EINVAL);
-				return;
+				return (0);
 			}
 			if (snmpcom_req(q, mp, tcp_snmp_set, ip_snmp_get,
 			    cr)) {
 				/*
 				 * This was a SNMP request
 				 */
-				return;
+				return (0);
 			} else {
 				output_proc = tcp_wput_proto;
 			}
@@ -175,12 +175,12 @@ tcp_wput(queue_t *q, mblk_t *mp)
 		switch (iocp->ioc_cmd) {
 		case TCP_IOC_ABORT_CONN:
 			tcp_ioctl_abort_conn(q, mp);
-			return;
+			return (0);
 		case TI_GETPEERNAME:
 		case TI_GETMYNAME:
 			mi_copyin(q, mp, NULL,
 			    SIZEOF_STRUCT(strbuf, iocp->ioc_flag));
-			return;
+			return (0);
 
 		default:
 			output_proc = tcp_wput_ioctl;
@@ -195,6 +195,7 @@ tcp_wput(queue_t *q, mblk_t *mp)
 	CONN_INC_REF(connp);
 	SQUEUE_ENTER_ONE(connp->conn_sqp, mp, output_proc, connp,
 	    NULL, tcp_squeue_flag, SQTAG_TCP_WPUT_OTHER);
+	return (0);
 }
 
 /*
@@ -572,7 +573,7 @@ done:;
  * All further messages will also be handled by tcp_wput() because we cannot
  * be sure that the above short cut is safe later.
  */
-void
+int
 tcp_wput_sock(queue_t *wq, mblk_t *mp)
 {
 	conn_t			*connp = Q_TO_CONN(wq);
@@ -589,20 +590,22 @@ tcp_wput_sock(queue_t *wq, mblk_t *mp)
 	    MBLKL(mp) == sizeof (struct T_capability_req) &&
 	    car->PRIM_type == T_CAPABILITY_REQ) {
 		tcp_capability_req(tcp, mp);
-		return;
+		return (0);
 	}
 
 	tcp_wput(wq, mp);
+	return (0);
 }
 
 /* ARGSUSED */
-void
+int
 tcp_wput_fallback(queue_t *wq, mblk_t *mp)
 {
 #ifdef DEBUG
 	cmn_err(CE_CONT, "tcp_wput_fallback: Message during fallback \n");
 #endif
 	freemsg(mp);
+	return (0);
 }
 
 /*
@@ -718,7 +721,7 @@ tcp_wput_iocdata(tcp_t *tcp, mblk_t *mp)
 	STRUCT_HANDLE(strbuf, sb);
 	uint_t		addrlen;
 	conn_t		*connp = tcp->tcp_connp;
-	queue_t 	*q = connp->conn_wq;
+	queue_t		*q = connp->conn_wq;
 
 	/* Make sure it is one of ours. */
 	switch (iocp->ioc_cmd) {
@@ -819,7 +822,7 @@ tcp_wput_iocdata(tcp_t *tcp, mblk_t *mp)
 static void
 tcp_wput_ioctl(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
 {
-	conn_t 		*connp = (conn_t *)arg;
+	conn_t		*connp = (conn_t *)arg;
 	tcp_t		*tcp = connp->conn_tcp;
 	queue_t		*q = connp->conn_wq;
 	struct iocblk	*iocp;
@@ -1680,7 +1683,7 @@ finish:
 void
 tcp_shutdown_output(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
 {
-	conn_t 	*connp = (conn_t *)arg;
+	conn_t	*connp = (conn_t *)arg;
 	tcp_t	*tcp = connp->conn_tcp;
 
 	freemsg(mp);
@@ -2686,8 +2689,8 @@ tcp_xmit_listeners_reset(mblk_t *mp, ip_recv_attr_t *ira, ip_stack_t *ipst,
 	uint32_t	seg_seq;
 	uint32_t	seg_ack;
 	uint_t		flags;
-	ipha_t 		*ipha;
-	ip6_t 		*ip6h;
+	ipha_t		*ipha;
+	ip6_t		*ip6h;
 	boolean_t	policy_present;
 	netstack_t	*ns = ipst->ips_netstack;
 	tcp_stack_t	*tcps = ns->netstack_tcp;
diff --git a/usr/src/uts/common/inet/tcp/tcp_tpi.c b/usr/src/uts/common/inet/tcp/tcp_tpi.c
index 2ce72e7daa..dbdc5b8dc7 100644
--- a/usr/src/uts/common/inet/tcp/tcp_tpi.c
+++ b/usr/src/uts/common/inet/tcp/tcp_tpi.c
@@ -1054,7 +1054,7 @@ tcp_accept_finish(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
 	tcp_t			*tcp = connp->conn_tcp;
 	queue_t			*q = connp->conn_rq;
 	tcp_stack_t		*tcps = tcp->tcp_tcps;
-	struct stroptions 	*stropt;
+	struct stroptions	*stropt;
 	struct sock_proto_props sopp;
 
 	/* Should never be called for non-STREAMS sockets */
@@ -1685,7 +1685,7 @@ finish:
  * Acceptor STREAM when  sockfs listener does accept processing.
  * Read the block comment on top of tcp_input_listener().
  */
-void
+int
 tcp_tpi_accept(queue_t *q, mblk_t *mp)
 {
 	queue_t *rq = RD(q);
@@ -1713,7 +1713,7 @@ tcp_tpi_accept(queue_t *q, mblk_t *mp)
 		mp = mi_tpi_err_ack_alloc(mp, TSYSERR, EINVAL);
 		if (mp != NULL)
 			putnext(rq, mp);
-		return;
+		return (0);
 	}
 	conn_res = (struct T_conn_res *)mp->b_rptr;
 	ASSERT((uintptr_t)(mp->b_wptr - mp->b_rptr) <= (uintptr_t)INT_MAX);
@@ -1721,7 +1721,7 @@ tcp_tpi_accept(queue_t *q, mblk_t *mp)
 		mp = mi_tpi_err_ack_alloc(mp, TPROTO, 0);
 		if (mp != NULL)
 			putnext(rq, mp);
-		return;
+		return (0);
 	}
 	switch (conn_res->PRIM_type) {
 	case O_T_CONN_RES:
@@ -1766,7 +1766,7 @@ tcp_tpi_accept(queue_t *q, mblk_t *mp)
 			mp = mi_tpi_err_ack_alloc(mp, TPROTO, 0);
 			if (mp != NULL)
 				putnext(rq, mp);
-			return;
+			return (0);
 		}
 
 		eager->tcp_issocket = B_TRUE;
@@ -1854,13 +1854,14 @@ tcp_tpi_accept(queue_t *q, mblk_t *mp)
 		}
 
 		putnext(rq, mp);
-		return;
+		break;
 	default:
 		mp = mi_tpi_err_ack_alloc(mp, TNOTSUPPORT, 0);
 		if (mp != NULL)
 			putnext(rq, mp);
-		return;
+		break;
 	}
+	return (0);
 }
 
 /*
@@ -1908,7 +1909,7 @@ tcp_send_conn_ind(void *arg, mblk_t *mp, void *arg2)
 	tcp_t			*listener = lconnp->conn_tcp;
 	tcp_t			*tcp;
 	struct T_conn_ind	*conn_ind;
-	ipaddr_t 		*addr_cache;
+	ipaddr_t		*addr_cache;
 	boolean_t		need_send_conn_ind = B_FALSE;
 	tcp_stack_t		*tcps = listener->tcp_tcps;
 
diff --git a/usr/src/uts/common/inet/tcp_impl.h b/usr/src/uts/common/inet/tcp_impl.h
index 3611d7c73a..4d0abd0acf 100644
--- a/usr/src/uts/common/inet/tcp_impl.h
+++ b/usr/src/uts/common/inet/tcp_impl.h
@@ -108,7 +108,7 @@ extern sock_downcalls_t sock_tcp_downcalls;
 /* TCP timers related data structures.  Refer to tcp_timers.c. */
 typedef struct tcp_timer_s {
 	conn_t	*connp;
-	void 	(*tcpt_proc)(void *);
+	void	(*tcpt_proc)(void *);
 	callout_id_t   tcpt_tid;
 } tcp_timer_t;
 
@@ -642,7 +642,7 @@ extern void	tcp_ipsec_cleanup(tcp_t *);
 extern int	tcp_maxpsz_set(tcp_t *, boolean_t);
 extern void	tcp_mss_set(tcp_t *, uint32_t);
 extern void	tcp_reinput(conn_t *, mblk_t *, ip_recv_attr_t *, ip_stack_t *);
-extern void	tcp_rsrv(queue_t *);
+extern int	tcp_rsrv(queue_t *);
 extern uint_t	tcp_rwnd_reopen(tcp_t *);
 extern int	tcp_rwnd_set(tcp_t *, uint32_t);
 extern int	tcp_set_destination(tcp_t *);
@@ -696,10 +696,10 @@ extern void	tcp_send_synack(void *, mblk_t *, void *, ip_recv_attr_t *);
 extern void	tcp_shutdown_output(void *, mblk_t *, void *, ip_recv_attr_t *);
 extern void	tcp_ss_rexmit(tcp_t *);
 extern void	tcp_update_xmit_tail(tcp_t *, uint32_t);
-extern void	tcp_wput(queue_t *, mblk_t *);
+extern int	tcp_wput(queue_t *, mblk_t *);
 extern void	tcp_wput_data(tcp_t *, mblk_t *, boolean_t);
-extern void	tcp_wput_sock(queue_t *, mblk_t *);
-extern void	tcp_wput_fallback(queue_t *, mblk_t *);
+extern int	tcp_wput_sock(queue_t *, mblk_t *);
+extern int	tcp_wput_fallback(queue_t *, mblk_t *);
 extern void	tcp_xmit_ctl(char *, tcp_t *, uint32_t, uint32_t, int);
 extern void	tcp_xmit_listeners_reset(mblk_t *, ip_recv_attr_t *,
 		    ip_stack_t *i, conn_t *);
@@ -754,7 +754,7 @@ extern void	tcp_err_ack_prim(tcp_t *, mblk_t *, int, int, int);
 extern void	tcp_info_req(tcp_t *, mblk_t *);
 extern void	tcp_send_conn_ind(void *, mblk_t *, void *);
 extern void	tcp_send_pending(void *, mblk_t *, void *, ip_recv_attr_t *);
-extern void	tcp_tpi_accept(queue_t *, mblk_t *);
+extern int	tcp_tpi_accept(queue_t *, mblk_t *);
 extern void	tcp_tpi_bind(tcp_t *, mblk_t *);
 extern int	tcp_tpi_close(queue_t *, int, cred_t *);
 extern int	tcp_tpi_close_accept(queue_t *, int, cred_t *);
diff --git a/usr/src/uts/common/inet/udp/udp.c b/usr/src/uts/common/inet/udp/udp.c
index 636bfde3ef..d847b9b6ce 100644
--- a/usr/src/uts/common/inet/udp/udp.c
+++ b/usr/src/uts/common/inet/udp/udp.c
@@ -146,8 +146,8 @@ static void	udp_icmp_error_ipv6(conn_t *connp, mblk_t *mp,
     ip_recv_attr_t *ira);
 static void	udp_info_req(queue_t *q, mblk_t *mp);
 static void	udp_input(void *, mblk_t *, void *, ip_recv_attr_t *);
-static void	udp_lrput(queue_t *, mblk_t *);
-static void	udp_lwput(queue_t *, mblk_t *);
+static int	udp_lrput(queue_t *, mblk_t *);
+static int	udp_lwput(queue_t *, mblk_t *);
 static int	udp_open(queue_t *q, dev_t *devp, int flag, int sflag,
 		    cred_t *credp, boolean_t isv6);
 static int	udp_openv4(queue_t *q, dev_t *devp, int flag, int sflag,
@@ -180,7 +180,7 @@ static in_port_t udp_update_next_port(udp_t *udp, in_port_t port,
     boolean_t random);
 static void	udp_wput_other(queue_t *q, mblk_t *mp);
 static void	udp_wput_iocdata(queue_t *q, mblk_t *mp);
-static void	udp_wput_fallback(queue_t *q, mblk_t *mp);
+static int	udp_wput_fallback(queue_t *q, mblk_t *mp);
 static size_t	udp_set_rcv_hiwat(udp_t *udp, size_t size);
 
 static void	*udp_stack_init(netstackid_t stackid, netstack_t *ns);
@@ -260,12 +260,12 @@ static struct qinit udp_rinitv6 = {
 };
 
 static struct qinit udp_winit = {
-	(pfi_t)udp_wput, (pfi_t)ip_wsrv, NULL, NULL, NULL, &udp_mod_info
+	udp_wput, ip_wsrv, NULL, NULL, NULL, &udp_mod_info
 };
 
 /* UDP entry point during fallback */
 struct qinit udp_fallback_sock_winit = {
-	(pfi_t)udp_wput_fallback, NULL, NULL, NULL, NULL, &udp_mod_info
+	udp_wput_fallback, NULL, NULL, NULL, NULL, &udp_mod_info
 };
 
 /*
@@ -273,11 +273,11 @@ struct qinit udp_fallback_sock_winit = {
  * likes to use it as a place to hang the various streams.
  */
 static struct qinit udp_lrinit = {
-	(pfi_t)udp_lrput, NULL, udp_openv4, udp_tpi_close, NULL, &udp_mod_info
+	udp_lrput, NULL, udp_openv4, udp_tpi_close, NULL, &udp_mod_info
 };
 
 static struct qinit udp_lwinit = {
-	(pfi_t)udp_lwput, NULL, udp_openv4, udp_tpi_close, NULL, &udp_mod_info
+	udp_lwput, NULL, udp_openv4, udp_tpi_close, NULL, &udp_mod_info
 };
 
 /* For AF_INET aka /dev/udp */
@@ -1709,7 +1709,7 @@ udp_do_opt_set(conn_opt_arg_t *coa, int level, int name,
 	udp_t		*udp = connp->conn_udp;
 	udp_stack_t	*us = udp->udp_us;
 	int		*i1 = (int *)invalp;
-	boolean_t 	onoff = (*i1 == 0) ? 0 : 1;
+	boolean_t	onoff = (*i1 == 0) ? 0 : 1;
 	int		error;
 
 	ASSERT(MUTEX_NOT_HELD(&coa->coa_connp->conn_lock));
@@ -1863,9 +1863,9 @@ udp_opt_set(conn_t *connp, uint_t optset_context, int level,
 		/*
 		 * Note: Implies T_CHECK semantics for T_OPTCOM_REQ
 		 * inlen != 0 implies value supplied and
-		 * 	we have to "pretend" to set it.
+		 *	we have to "pretend" to set it.
 		 * inlen == 0 implies that there is no
-		 * 	value part in T_CHECK request and just validation
+		 *	value part in T_CHECK request and just validation
 		 * done elsewhere should be enough, we just return here.
 		 */
 		if (inlen == 0) {
@@ -3512,7 +3512,7 @@ udp_ud_err_connected(conn_t *connp, t_scalar_t error)
  * structure without the cumbersome T_UNITDATA_REQ interface for the case of
  * connected endpoints.
  */
-void
+int
 udp_wput(queue_t *q, mblk_t *mp)
 {
 	sin6_t		*sin6;
@@ -3543,7 +3543,7 @@ udp_wput(queue_t *q, mblk_t *mp)
 			UDP_DBGSTAT(us, udp_data_notconn);
 			UDP_STAT(us, udp_out_err_notconn);
 			freemsg(mp);
-			return;
+			return (0);
 		}
 		/*
 		 * All Solaris components should pass a db_credp
@@ -3556,7 +3556,7 @@ udp_wput(queue_t *q, mblk_t *mp)
 		if (cr == NULL) {
 			UDPS_BUMP_MIB(us, udpOutErrors);
 			freemsg(mp);
-			return;
+			return (0);
 		}
 		ASSERT(udp->udp_issocket);
 		UDP_DBGSTAT(us, udp_data_conn);
@@ -3569,7 +3569,7 @@ udp_wput(queue_t *q, mblk_t *mp)
 			printf("udp_output_connected returned %d\n", error);
 #endif
 		}
-		return;
+		return (0);
 
 	case M_PROTO:
 	case M_PCPROTO:
@@ -3577,13 +3577,13 @@ udp_wput(queue_t *q, mblk_t *mp)
 		if (MBLKL(mp) < sizeof (*tudr) ||
 		    ((t_primp_t)mp->b_rptr)->type != T_UNITDATA_REQ) {
 			udp_wput_other(q, mp);
-			return;
+			return (0);
 		}
 		break;
 
 	default:
 		udp_wput_other(q, mp);
-		return;
+		return (0);
 	}
 
 	/* Handle valid T_UNITDATA_REQ here */
@@ -3733,7 +3733,7 @@ udp_wput(queue_t *q, mblk_t *mp)
 		}
 		if (error == 0) {
 			freeb(mp);
-			return;
+			return (0);
 		}
 		break;
 
@@ -3795,7 +3795,7 @@ udp_wput(queue_t *q, mblk_t *mp)
 		}
 		if (error == 0) {
 			freeb(mp);
-			return;
+			return (0);
 		}
 		break;
 	}
@@ -3803,7 +3803,7 @@ udp_wput(queue_t *q, mblk_t *mp)
 	ASSERT(mp != NULL);
 	/* mp is freed by the following routine */
 	udp_ud_err(q, mp, (t_scalar_t)error);
-	return;
+	return (0);
 
 ud_error2:
 	UDPS_BUMP_MIB(us, udpOutErrors);
@@ -3812,6 +3812,7 @@ ud_error2:
 	ASSERT(mp != NULL);
 	/* mp is freed by the following routine */
 	udp_ud_err(q, mp, (t_scalar_t)error);
+	return (0);
 }
 
 /*
@@ -4147,13 +4148,14 @@ ud_error:
 }
 
 /* ARGSUSED */
-static void
+static int
 udp_wput_fallback(queue_t *wq, mblk_t *mp)
 {
 #ifdef DEBUG
 	cmn_err(CE_CONT, "udp_wput_fallback: Message in fallback \n");
 #endif
 	freemsg(mp);
+	return (0);
 }
 
 
@@ -4629,7 +4631,7 @@ udp_set_rcv_hiwat(udp_t *udp, size_t size)
  * Nobody should be sending
  * packets up this stream
  */
-static void
+static int
 udp_lrput(queue_t *q, mblk_t *mp)
 {
 	switch (mp->b_datap->db_type) {
@@ -4638,11 +4640,12 @@ udp_lrput(queue_t *q, mblk_t *mp)
 		if (*mp->b_rptr & FLUSHW) {
 			*mp->b_rptr &= ~FLUSHR;
 			qreply(q, mp);
-			return;
+			return (0);
 		}
 		break;
 	}
 	freemsg(mp);
+	return (0);
 }
 
 /*
@@ -4650,10 +4653,11 @@ udp_lrput(queue_t *q, mblk_t *mp)
  * Nobody should be sending packets down this stream.
  */
 /* ARGSUSED */
-void
+int
 udp_lwput(queue_t *q, mblk_t *mp)
 {
 	freemsg(mp);
+	return (0);
 }
 
 /*
@@ -4684,9 +4688,9 @@ udp_do_open(cred_t *credp, boolean_t isv6, int flags, int *errorp)
 {
 	udp_t		*udp;
 	conn_t		*connp;
-	zoneid_t 	zoneid;
-	netstack_t 	*ns;
-	udp_stack_t 	*us;
+	zoneid_t	zoneid;
+	netstack_t	*ns;
+	udp_stack_t	*us;
 	int		len;
 
 	ASSERT(errorp != NULL);
@@ -4856,7 +4860,7 @@ void
 udp_activate(sock_lower_handle_t proto_handle, sock_upper_handle_t sock_handle,
     sock_upcalls_t *sock_upcalls, int flags, cred_t *cr)
 {
-	conn_t 		*connp = (conn_t *)proto_handle;
+	conn_t		*connp = (conn_t *)proto_handle;
 	struct sock_proto_props sopp;
 
 	/* All Solaris components should pass a cred for this operation. */
@@ -5610,7 +5614,7 @@ udp_implicit_bind(conn_t *connp, cred_t *cr)
 static int
 udp_do_unbind(conn_t *connp)
 {
-	udp_t 		*udp = connp->conn_udp;
+	udp_t		*udp = connp->conn_udp;
 	udp_fanout_t	*udpf;
 	udp_stack_t	*us = udp->udp_us;
 
@@ -5674,10 +5678,10 @@ udp_do_connect(conn_t *connp, const struct sockaddr *sa, socklen_t len,
 {
 	sin6_t		*sin6;
 	sin_t		*sin;
-	in6_addr_t 	v6dst;
-	ipaddr_t 	v4dst;
-	uint16_t 	dstport;
-	uint32_t 	flowinfo;
+	in6_addr_t	v6dst;
+	ipaddr_t	v4dst;
+	uint16_t	dstport;
+	uint32_t	flowinfo;
 	udp_fanout_t	*udpf;
 	udp_t		*udp, *udp1;
 	ushort_t	ipversion;
@@ -6290,7 +6294,7 @@ udp_fallback(sock_lower_handle_t proto_handle, queue_t *q,
     boolean_t issocket, so_proto_quiesced_cb_t quiesced_cb,
     sock_quiesce_arg_t *arg)
 {
-	conn_t 	*connp = (conn_t *)proto_handle;
+	conn_t	*connp = (conn_t *)proto_handle;
 	udp_t	*udp;
 	struct T_capability_ack tca;
 	struct sockaddr_in6 laddr, faddr;
@@ -6535,7 +6539,7 @@ int
 udp_ioctl(sock_lower_handle_t proto_handle, int cmd, intptr_t arg,
     int mode, int32_t *rvalp, cred_t *cr)
 {
-	conn_t  	*connp = (conn_t *)proto_handle;
+	conn_t		*connp = (conn_t *)proto_handle;
 	int		error;
 
 	/* All Solaris components should pass a cred for this operation. */
diff --git a/usr/src/uts/common/inet/udp_impl.h b/usr/src/uts/common/inet/udp_impl.h
index ebba10c0f7..ef11973707 100644
--- a/usr/src/uts/common/inet/udp_impl.h
+++ b/usr/src/uts/common/inet/udp_impl.h
@@ -247,7 +247,7 @@ extern void	udp_ddi_g_init(void);
 extern void	udp_ddi_g_destroy(void);
 extern void	udp_output(conn_t *connp, mblk_t *mp, struct sockaddr *addr,
 		    socklen_t addrlen);
-extern void	udp_wput(queue_t *, mblk_t *);
+extern int	udp_wput(queue_t *, mblk_t *);
 
 extern void	*udp_kstat_init(netstackid_t stackid);
 extern void	udp_kstat_fini(netstackid_t stackid, kstat_t *ksp);
diff --git a/usr/src/uts/common/io/kb8042/kb8042.c b/usr/src/uts/common/io/kb8042/kb8042.c
index ba7746eae4..0b1480bf1f 100644
--- a/usr/src/uts/common/io/kb8042/kb8042.c
+++ b/usr/src/uts/common/io/kb8042/kb8042.c
@@ -159,22 +159,46 @@ static int kb8042_close(queue_t *qp, int flag, cred_t *credp);
 static int kb8042_wsrv();
 
 struct module_info kb8042_sinfo = {
-	42,		/* Module ID */
-	module_name,
-	0, 32,		/* Minimum and maximum packet sizes */
-	256, 128	/* High and low water marks */
+	.mi_idnum = 42,			/* Module ID */
+	.mi_idname = module_name,	/* Module name */
+	.mi_minpsz = 0,			/* Minimum packet size */
+	.mi_maxpsz = 32,		/* Maximum packet size */
+	.mi_hiwat = 256,		/* High water mark */
+	.mi_lowat = 128			/* Low water mark */
 };
 
 static struct qinit kb8042_rinit = {
-	NULL, NULL, kb8042_open, kb8042_close, NULL, &kb8042_sinfo, NULL
+	.qi_putp = NULL,
+	.qi_srvp = NULL,
+	.qi_qopen = kb8042_open,
+	.qi_qclose = kb8042_close,
+	.qi_qadmin = NULL,
+	.qi_minfo = &kb8042_sinfo,
+	.qi_mstat = NULL,
+	.qi_rwp = NULL,
+	.qi_infop = NULL,
+	.qi_struiot = 0
 };
 
 static struct qinit kb8042_winit = {
-	putq, kb8042_wsrv, kb8042_open, kb8042_close, NULL, &kb8042_sinfo, NULL
+	.qi_putp = putq,
+	.qi_srvp = kb8042_wsrv,
+	.qi_qopen = kb8042_open,
+	.qi_qclose = kb8042_close,
+	.qi_qadmin = NULL,
+	.qi_minfo = &kb8042_sinfo,
+	.qi_mstat = NULL,
+	.qi_rwp = NULL,
+	.qi_infop = NULL,
+	.qi_struiot = 0
 };
 
-struct streamtab
-	kb8042_str_info = { &kb8042_rinit, &kb8042_winit, NULL, NULL };
+struct streamtab kb8042_str_info = {
+	.st_rdinit = &kb8042_rinit,
+	.st_wrinit = &kb8042_winit,
+	.st_muxrinit = NULL,
+	.st_muxwinit = NULL
+};
 
 struct kb8042	Kdws = {0};
 static dev_info_t *kb8042_dip = NULL;
@@ -185,36 +209,39 @@ static int kb8042_attach(dev_info_t *, ddi_attach_cmd_t);
 static int kb8042_detach(dev_info_t *, ddi_detach_cmd_t);
 
 static 	struct cb_ops cb_kb8042_ops = {
-	nulldev,		/* cb_open */
-	nulldev,		/* cb_close */
-	nodev,			/* cb_strategy */
-	nodev,			/* cb_print */
-	nodev,			/* cb_dump */
-	nodev,			/* cb_read */
-	nodev,			/* cb_write */
-	nodev,			/* cb_ioctl */
-	nodev,			/* cb_devmap */
-	nodev,			/* cb_mmap */
-	nodev,			/* cb_segmap */
-	nochpoll,		/* cb_chpoll */
-	ddi_prop_op,		/* cb_prop_op */
-	&kb8042_str_info,	/* cb_stream */
-	D_MP
+	.cb_open = nulldev,
+	.cb_close = nulldev,
+	.cb_strategy = nodev,
+	.cb_print = nodev,
+	.cb_dump = nodev,
+	.cb_read = nodev,
+	.cb_write = nodev,
+	.cb_ioctl = nodev,
+	.cb_devmap = nodev,
+	.cb_mmap = nodev,
+	.cb_segmap = nodev,
+	.cb_chpoll = nochpoll,
+	.cb_prop_op = ddi_prop_op,
+	.cb_str = &kb8042_str_info,
+	.cb_flag = D_MP,
+	.cb_rev = CB_REV,
+	.cb_aread = nodev,
+	.cb_awrite = nodev
 };
 
 struct dev_ops kb8042_ops = {
-	DEVO_REV,		/* devo_rev */
-	0,			/* devo_refcnt */
-	kb8042_getinfo,		/* devo_getinfo */
-	nulldev,		/* devo_identify */
-	nulldev,		/* devo_probe */
-	kb8042_attach,		/* devo_attach */
-	kb8042_detach,		/* devo_detach */
-	nodev,			/* devo_reset */
-	&cb_kb8042_ops,		/* devo_cb_ops */
-	(struct bus_ops *)NULL,	/* devo_bus_ops */
-	NULL,			/* devo_power */
-	ddi_quiesce_not_needed,	/* devo_quiesce */
+	.devo_rev = DEVO_REV,
+	.devo_refcnt = 0,
+	.devo_getinfo = kb8042_getinfo,
+	.devo_identify = nulldev,
+	.devo_probe = nulldev,
+	.devo_attach = kb8042_attach,
+	.devo_detach = kb8042_detach,
+	.devo_reset = nodev,
+	.devo_cb_ops = &cb_kb8042_ops,
+	.devo_bus_ops = NULL,
+	.devo_power = NULL,
+	.devo_quiesce = ddi_quiesce_not_needed
 };
 
 
@@ -227,15 +254,14 @@ struct dev_ops kb8042_ops = {
  * Module linkage information for the kernel.
  */
 static struct modldrv modldrv = {
-	&mod_driverops, /* Type of module.  This one is a driver */
-	"PS/2 keyboard driver",
-	&kb8042_ops,	/* driver ops */
+	.drv_modops = &mod_driverops,	/* Type of module. */
+	.drv_linkinfo = "PS/2 keyboard driver",
+	.drv_dev_ops = &kb8042_ops,	/* driver ops */
 };
 
 static struct modlinkage modlinkage = {
-	MODREV_1,
-	(void *) &modldrv,
-	NULL
+	.ml_rev = MODREV_1,
+	.ml_linkage = { &modldrv, NULL }
 };
 
 int
diff --git a/usr/src/uts/common/io/kbtrans/kbtrans.c b/usr/src/uts/common/io/kbtrans/kbtrans.c
index f01d4b8f06..2091a18162 100644
--- a/usr/src/uts/common/io/kbtrans/kbtrans.c
+++ b/usr/src/uts/common/io/kbtrans/kbtrans.c
@@ -24,8 +24,6 @@
  * Use is subject to license terms.
  */
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 /*
  * Generic keyboard support: translation
  *
@@ -63,11 +61,11 @@
 /*
  * Internal Function Prototypes
  */
-static boolean_t	kbtrans_do_compose(struct kbtrans_lower *, ushort_t,
-			    ushort_t, ushort_t *);
-static void		kbtrans_translate(struct kbtrans_lower *,
-				struct keyboard_callback *, kbtrans_key_t,
-				enum keystate);
+static boolean_t kbtrans_do_compose(struct kbtrans_lower *, keymap_entry_t,
+    keymap_entry_t, keymap_entry_t *);
+static void kbtrans_translate(struct kbtrans_lower *,
+    struct keyboard_callback *, kbtrans_key_t, enum keystate);
+
 /*
  * kbtrans_processkey:
  *
@@ -83,12 +81,10 @@ static void		kbtrans_translate(struct kbtrans_lower *,
  */
 void
 kbtrans_processkey(struct kbtrans_lower *lower,
-	struct keyboard_callback	*cb,
-	kbtrans_key_t 			key,
-	enum keystate 			state)
+    struct keyboard_callback *cb, kbtrans_key_t key, enum keystate state)
 {
 	DPRINTF(PRINT_L0, PRINT_MASK_ALL, (lower, "kbtrans_processkey: "
-		"newstate=%d key=%d", state, key));
+	    "newstate=%d key=%d", state, key));
 
 	/*
 	 * If there is a raw routine, then call it and return.
@@ -126,21 +122,19 @@ kbtrans_processkey(struct kbtrans_lower *lower,
  * for the character when it is done translating it.
  */
 static void
-kbtrans_translate(struct kbtrans_lower	*lower,
-	struct keyboard_callback	*cb,
-	kbtrans_key_t 			key,
-	enum keystate 			newstate)
+kbtrans_translate(struct kbtrans_lower *lower, struct keyboard_callback *cb,
+    kbtrans_key_t key, enum keystate newstate)
 {
 	unsigned		shiftmask;
-	register ushort_t	entry;
-	register ushort_t	entrytype;
-	ushort_t		result_iso;
-	unsigned short		*ke;
+	register keymap_entry_t	entry;
+	register unsigned	entrytype;
+	keymap_entry_t		result;
+	keymap_entry_t		*ke;
 	int			i;
 	boolean_t		good_compose;
 
 	DPRINTF(PRINT_L0, PRINT_MASK_ALL, (lower, "KEY TRANSLATE "
-		"newstate=0x%x key=0x%x\n", newstate, key));
+	    "newstate=0x%x key=0x%x\n", newstate, key));
 
 	if (lower->kbtrans_keyboard == NULL) {
 		/*
@@ -188,8 +182,7 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 		 * ask for the table we would have gotten had Num Lock not been
 		 * down, and translate using that table.
 		 */
-		ke = kbtrans_find_entry(lower, shiftmask & ~NUMLOCKMASK,
-			key);
+		ke = kbtrans_find_entry(lower, shiftmask & ~NUMLOCKMASK, key);
 
 		if (ke == NULL) {
 			/*
@@ -212,7 +205,7 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 	 * Categories include shift keys, function keys, and numeric keypad
 	 * keys.
 	 */
-	entrytype = (ushort_t)(entry & 0xFF00);
+	entrytype = KEYFLAGS(entry);
 
 	if (entrytype == SHIFTKEYS) {
 		/*
@@ -222,8 +215,7 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 		 */
 		if ((1 << (entry & 0x0F)) &
 		    lower->kbtrans_keyboard->k_toggleshifts) {
-			if ((1 << (entry & 0x0F)) &
-				lower->kbtrans_togglemask) {
+			if ((1 << (entry & 0x0F)) & lower->kbtrans_togglemask) {
 				newstate = KEY_RELEASED; /* toggling off */
 			} else {
 				newstate = KEY_PRESSED;	/* toggling on */
@@ -236,7 +228,6 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 		switch (lower->kbtrans_state) {
 		case COMPOSE1:
 			if (newstate == KEY_RELEASED)
-
 				return;
 
 			if (entry < ASCII_SET_SIZE) {
@@ -265,28 +256,22 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 			cb->kc_setled(lower->kbtrans_upper);
 
 			good_compose = kbtrans_do_compose(lower,
-				lower->kbtrans_compose_key, entry,
-				&result_iso);
+			    lower->kbtrans_compose_key, entry, &result);
 			if (good_compose) {
-				if (lower->kbtrans_compat)
-					result_iso += ISO_FIRST;
-				else
-					result_iso += EUC_FIRST;
 				cb->kc_keypressed(lower->kbtrans_upper,
-				    entrytype, key, result_iso);
+				    entrytype, key, result);
 			}
 			return;
 
 		case FLTACCENT:
 			if (newstate == KEY_RELEASED)
-
 				return;
 
 			/* next state is "normal" */
 			lower->kbtrans_state = NORMAL;
 			for (i = 0;
-			    (lower->kbtrans_fltaccent_table[i].fa_entry
-				!= lower->kbtrans_fltaccent_entry) ||
+			    (lower->kbtrans_fltaccent_table[i].fa_entry !=
+			    lower->kbtrans_fltaccent_entry) ||
 			    (lower->kbtrans_fltaccent_table[i].ascii != entry);
 			    i++) {
 				if (lower->kbtrans_fltaccent_table[i].fa_entry
@@ -297,10 +282,8 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 				}
 			}
 
-			cb->kc_keypressed(lower->kbtrans_upper, entrytype,
-					key, (lower->kbtrans_compat ?
-						ISO_FIRST : EUC_FIRST) +
-					lower->kbtrans_fltaccent_table[i].iso);
+			cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
+			    lower->kbtrans_fltaccent_table[i].utf8);
 
 			return;
 		}
@@ -321,7 +304,7 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 		if (lower->kbtrans_repeatkey != key) {
 			cb->kc_cancel_repeat(lower->kbtrans_upper);
 			cb->kc_setup_repeat(lower->kbtrans_upper, entrytype,
-				key);
+			    key);
 		}
 		/* key going up */
 	} else if (key == lower->kbtrans_repeatkey) {
@@ -342,7 +325,7 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 
 	case 0x0:		/* regular key */
 		cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
-			entry | lower->kbtrans_buckybits);
+		    SPECIAL(lower->kbtrans_buckybits, entry));
 		break;
 
 	case SHIFTKEYS: {
@@ -353,13 +336,13 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 			if (newstate == KEY_RELEASED) {
 				if (shiftbit == CAPSMASK) {
 					lower->kbtrans_led_state &=
-						~LED_CAPS_LOCK;
+					    ~LED_CAPS_LOCK;
 
 					cb->kc_setled(lower->kbtrans_upper);
 
 				} else if (shiftbit == NUMLOCKMASK) {
 					lower->kbtrans_led_state &=
-						    ~LED_NUM_LOCK;
+					    ~LED_NUM_LOCK;
 
 					cb->kc_setled(lower->kbtrans_upper);
 				}
@@ -367,12 +350,12 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 			} else {
 				if (shiftbit == CAPSMASK) {
 					lower->kbtrans_led_state |=
-						LED_CAPS_LOCK;
+					    LED_CAPS_LOCK;
 
 					cb->kc_setled(lower->kbtrans_upper);
 				} else if (shiftbit == NUMLOCKMASK) {
 					lower->kbtrans_led_state |=
-						LED_NUM_LOCK;
+					    LED_NUM_LOCK;
 
 					cb->kc_setled(lower->kbtrans_upper);
 				}
@@ -387,18 +370,18 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 
 		if (newstate == KEY_PRESSED) {
 			cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
-				entry);
+			    entry);
 		}
 
 		break;
 		}
 
 	case BUCKYBITS:
-		lower->kbtrans_buckybits ^= 1 << (7 + (entry & 0x0F));
+		lower->kbtrans_buckybits ^= 1 << (entry & 0x0F);
 
 		if (newstate == KEY_PRESSED) {
 			cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
-				entry);
+			    entry);
 		}
 
 		break;
@@ -414,18 +397,18 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 		case RESET:
 		case ERROR:
 			lower->kbtrans_shiftmask &=
-				lower->kbtrans_keyboard->k_idleshifts;
+			    lower->kbtrans_keyboard->k_idleshifts;
 
 			lower->kbtrans_shiftmask |=
-					lower->kbtrans_togglemask;
+			    lower->kbtrans_togglemask;
 
 			lower->kbtrans_buckybits &=
-				lower->kbtrans_keyboard->k_idlebuckys;
+			    lower->kbtrans_keyboard->k_idlebuckys;
 
 			cb->kc_cancel_repeat(lower->kbtrans_upper);
 
 			cb->kc_keypressed(lower->kbtrans_upper, entrytype, key,
-				entry);
+			    entry);
 
 			break;
 
@@ -480,16 +463,14 @@ kbtrans_translate(struct kbtrans_lower	*lower,
 /*
  * kbtrans_do_compose:
  *	Given a two key compose sequence, lookup the iso equivalent and put
- * 	the result in the result_iso_ptr.
+ *	the result in the result_ptr.
  */
 static boolean_t
-kbtrans_do_compose(struct kbtrans_lower *lower,
-		ushort_t	first_entry,
-		ushort_t	second_entry,
-		ushort_t	*result_iso_ptr)
+kbtrans_do_compose(struct kbtrans_lower *lower, keymap_entry_t first_entry,
+    keymap_entry_t second_entry, keymap_entry_t *result_ptr)
 {
 	struct compose_sequence_t *ptr;
-	ushort_t	tmp;
+	keymap_entry_t tmp;
 
 	/*
 	 * Validate the second keystroke.
@@ -510,11 +491,11 @@ kbtrans_do_compose(struct kbtrans_lower *lower,
 	}
 
 	ptr = lower->kbtrans_compose_table +
-		    lower->kbtrans_compose_map[first_entry];
+	    lower->kbtrans_compose_map[first_entry];
 
 	while (ptr->first == first_entry) {
 		if (ptr->second == second_entry) {
-			*result_iso_ptr = ptr->iso;
+			*result_ptr = ptr->utf8;
 
 			return (B_TRUE);
 		}
@@ -529,10 +510,9 @@ kbtrans_do_compose(struct kbtrans_lower *lower,
  * 	This routine finds the entry corresponding to the current shift
  * 	state and keycode.
  */
-unsigned short *
-kbtrans_find_entry(struct kbtrans_lower *lower,
-	register uint_t			mask,
-	kbtrans_key_t			key_station)
+keymap_entry_t *
+kbtrans_find_entry(struct kbtrans_lower *lower, uint_t mask,
+    kbtrans_key_t key_station)
 {
 	register struct keyboard *kp;
 	keymap_entry_t *km;
diff --git a/usr/src/uts/common/io/kbtrans/kbtrans_keytables.c b/usr/src/uts/common/io/kbtrans/kbtrans_keytables.c
index 197a412e6e..7755c14aad 100644
--- a/usr/src/uts/common/io/kbtrans/kbtrans_keytables.c
+++ b/usr/src/uts/common/io/kbtrans/kbtrans_keytables.c
@@ -24,8 +24,6 @@
  * All rights reserved.
  */
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 /*
  * This file contains generic keytable information across all
  * keyboard hardware.
@@ -217,7 +215,7 @@ signed char kb_compose_map[ASCII_SET_SIZE] = {
  *	    (top to bottom).
  */
 
-/* COMPOSE + first character + second character => ISO character */
+/* COMPOSE + first character + second character => UTF-8 character */
 
 struct compose_sequence_t kb_compose_table[] = {
 
@@ -341,9 +339,10 @@ struct compose_sequence_t kb_compose_table[] = {
  * Floating Accent Sequence Table
  */
 
-/* FA + ASCII character => ISO character */
+/* FA + ASCII character => UTF-8 character */
 struct fltaccent_sequence_t kb_fltaccent_table[] = {
 
+	{FA_UMLAUT, ' ', 0xA8},		/* umlaut/diaresis */
 	{FA_UMLAUT, 'A', 0xC4},		/* A with umlaut */
 	{FA_UMLAUT, 'E', 0xCB},		/* E with umlaut */
 	{FA_UMLAUT, 'I', 0xCF},		/* I with umlaut */
@@ -367,6 +366,7 @@ struct fltaccent_sequence_t kb_fltaccent_table[] = {
 	{FA_CFLEX, 'o', 0xF4},		/* o with circumflex */
 	{FA_CFLEX, 'u', 0xFB},		/* u with circumflex */
 
+	{FA_TILDE, ' ', '~'},		/* tilde */
 	{FA_TILDE, 'A', 0xC3},		/* A with tilde */
 	{FA_TILDE, 'N', 0xD1},		/* N with tilde */
 	{FA_TILDE, 'O', 0xD5},		/* O with tilde */
@@ -374,9 +374,11 @@ struct fltaccent_sequence_t kb_fltaccent_table[] = {
 	{FA_TILDE, 'n', 0xF1},		/* n with tilde */
 	{FA_TILDE, 'o', 0xF5},		/* o with tilde */
 
+	{FA_CEDILLA, ' ', 0xB8},	/* cedilla */
 	{FA_CEDILLA, 'C', 0xC7},	/* C with cedilla */
 	{FA_CEDILLA, 'c', 0xE7},	/* c with cedilla */
 
+	{FA_ACUTE, ' ', '\''},		/* apostrophe */
 	{FA_ACUTE, 'A', 0xC1},		/* A with acute accent */
 	{FA_ACUTE, 'E', 0xC9},		/* E with acute accent */
 	{FA_ACUTE, 'I', 0xCD},		/* I with acute accent */
@@ -389,6 +391,7 @@ struct fltaccent_sequence_t kb_fltaccent_table[] = {
 	{FA_ACUTE, 'u', 0xFA},		/* u with acute accent */
 	{FA_ACUTE, 'y', 0xFD},		/* y with acute accent */
 
+	{FA_GRAVE, ' ', '`'},		/* grave accent */
 	{FA_GRAVE, 'A', 0xC0},		/* A with grave accent */
 	{FA_GRAVE, 'E', 0xC8},		/* E with grave accent */
 	{FA_GRAVE, 'I', 0xCC},		/* I with grave accent */
@@ -400,6 +403,30 @@ struct fltaccent_sequence_t kb_fltaccent_table[] = {
 	{FA_GRAVE, 'o', 0xF2},		/* o with grave accent */
 	{FA_GRAVE, 'u', 0xF9},		/* u with grave accent */
 
+	{FA_MACRON, ' ', 0xAF},		/* macron */
+
+	{FA_BREVE, ' ', 0x306},		/* combining breve */
+
+	{FA_DOT, ' ', 0x307},		/* combining dot above */
+
+	{FA_SLASH, 0, 0},		/* slash, invalid entry */
+
+	{FA_RING, ' ', 0x30A},		/* combining ring above */
+
+	{FA_APOSTROPHE, ' ', '\''},	/* apostrophe */
+
+	{FA_DACUTE, ' ', 0x30B},	/* combining double acute */
+
+	{FA_OGONEK, ' ', 0x328},	/* combining ogonek */
+
+	{FA_CARON, ' ', 0x2C7},		/* caron */
+	{FA_CARON, 'C', 0x10C},		/* C with caron */
+	{FA_CARON, 'S', 0x160},		/* S with caron */
+	{FA_CARON, 'Z', 0x17D},		/* Z with caron */
+	{FA_CARON, 'c', 0x10D},		/* c with caron */
+	{FA_CARON, 's', 0x161},		/* s with caron */
+	{FA_CARON, 'z', 0x17E},		/* z with caron */
+
 	{0, 0, 0},			/* end of table */
 };
 
diff --git a/usr/src/uts/common/io/kbtrans/kbtrans_lower.h b/usr/src/uts/common/io/kbtrans/kbtrans_lower.h
index 14157a7816..7836292f0c 100644
--- a/usr/src/uts/common/io/kbtrans/kbtrans_lower.h
+++ b/usr/src/uts/common/io/kbtrans/kbtrans_lower.h
@@ -27,8 +27,6 @@
 #ifndef _KBTRANS_LOWER_H
 #define	_KBTRANS_LOWER_H
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -56,8 +54,8 @@ struct kbtrans_lower {
 	uchar_t  kbtrans_state;		/* compose state */
 	uint_t   kbtrans_buckybits;	/* current buckybits */
 	uint_t   kbtrans_togglemask;   	/* Toggle shifts state */
-	ushort_t kbtrans_compose_key;	/* first compose key */
-	ushort_t kbtrans_fltaccent_entry; /* floating accent keymap entry */
+	kbtrans_key_t kbtrans_compose_key;	/* first compose key */
+	kbtrans_key_t kbtrans_fltaccent_entry; /* floating accent entry */
 
 	/*
 	 * Various mapping tables.
@@ -127,24 +125,15 @@ struct keyboard_callback {
  * Process a scancode.  This routine will call the functions in
  * keyboard_callback to handle the translated key.
  */
-void
-kbtrans_processkey(
-	struct kbtrans_lower *lower,
-	struct keyboard_callback *cb,
-	kbtrans_key_t key,
-	enum keystate state
-);
+void kbtrans_processkey(struct kbtrans_lower *, struct keyboard_callback *,
+    kbtrans_key_t, enum keystate);
 
 /*
  * This routine finds the entry for the specified keycode based on the
  * specified shift mask.
  */
-unsigned short *
-kbtrans_find_entry(
-	struct kbtrans_lower	*lower,
-	uint_t mask,
-	kbtrans_key_t
-);
+keymap_entry_t *kbtrans_find_entry(struct kbtrans_lower *, uint_t,
+    kbtrans_key_t);
 
 /*
  * Debug printing
diff --git a/usr/src/uts/common/io/kbtrans/kbtrans_streams.c b/usr/src/uts/common/io/kbtrans/kbtrans_streams.c
index d285b5c23b..a468cb7d01 100644
--- a/usr/src/uts/common/io/kbtrans/kbtrans_streams.c
+++ b/usr/src/uts/common/io/kbtrans/kbtrans_streams.c
@@ -1265,7 +1265,7 @@ kbtrans_strsetwithdecimal(char *buf, uint_t val, uint_t maxdigs)
  */
 static void
 kbtrans_keypressed(struct kbtrans *upper, uchar_t key_station,
-		    Firm_event *fe, ushort_t base)
+    Firm_event *fe, ushort_t base)
 {
 
 	register short	id_addr;
@@ -1278,7 +1278,7 @@ kbtrans_keypressed(struct kbtrans *upper, uchar_t key_station,
 		 * not been CTRLed.
 		 */
 		if (lower->kbtrans_shiftmask & (CTRLMASK | CTLSMASK)) {
-			unsigned short *ke;
+			keymap_entry_t *ke;
 			unsigned int mask;
 
 			mask = lower->kbtrans_shiftmask &
@@ -1327,7 +1327,7 @@ send:
  */
 static void
 kbtrans_queuepress(struct kbtrans *upper,
-		    uchar_t key_station, Firm_event *fe)
+    uchar_t key_station, Firm_event *fe)
 {
 	register struct key_event *ke, *ke_free;
 	register int i;
@@ -1439,9 +1439,24 @@ kbtrans_putcode(register struct kbtrans *upper, uint_t code)
 
 	/*
 	 * We will strip out any high order information here.
+	 * Convert to UTF-8.
 	 */
-	/* NOTE the implicit cast here */
-	*bp->b_wptr++ = (uchar_t)code;
+	code = KEYCHAR(code);
+	if (code < 0x80) {
+		*bp->b_wptr++ = (char)code;
+	} else if (code < 0x800) {
+		*bp->b_wptr++ = 0xc0 | (code >> 6);
+		*bp->b_wptr++ = 0x80 | (code & 0x3f);
+	} else if (code < 0x10000) {
+		*bp->b_wptr++ = 0xe0 | (code >> 12);
+		*bp->b_wptr++ = 0x80 | ((code >> 6) & 0x3f);
+		*bp->b_wptr++ = 0x80 | (code & 0x3f);
+	} else {
+		*bp->b_wptr++ = 0xf0 | (code >> 18);
+		*bp->b_wptr++ = 0x80 | ((code >> 12) & 0x3f);
+		*bp->b_wptr++ = 0x80 | ((code >> 6) & 0x3f);
+		*bp->b_wptr++ = 0x80 | (code & 0x3f);
+	}
 
 	/*
 	 * Send the message up.
@@ -1788,7 +1803,7 @@ kbtrans_ascii_keypressed(
 	}
 
 	/*
-	 * Send the byte upstream.
+	 * Send the char upstream.
 	 */
 	kbtrans_putcode(upper, entry);
 
@@ -2089,7 +2104,7 @@ kbtrans_trans_event_setup_repeat(
  * Map old special codes to new ones.
  * Indexed by ((old special code) >> 4) & 0x07; add (old special code) & 0x0F.
  */
-static ushort_t  special_old_to_new[] = {
+static keymap_entry_t  special_old_to_new[] = {
 	SHIFTKEYS,
 	BUCKYBITS,
 	FUNNY,
@@ -2109,15 +2124,14 @@ static int
 kbtrans_setkey(struct kbtrans_lower *lower, struct kiockey *key, cred_t *cr)
 {
 	int	strtabindex, i;
-	unsigned short	*ke;
+	keymap_entry_t	*ke;
 	register int tablemask;
-	register ushort_t entry;
+	register keymap_entry_t entry;
 	register struct keyboard *kp;
 
 	kp = lower->kbtrans_keyboard;
 
 	if (key->kio_station >= kp->k_keymap_size)
-
 		return (EINVAL);
 
 	if (lower->kbtrans_keyboard == NULL)
@@ -2208,8 +2222,8 @@ static int
 kbtrans_getkey(struct kbtrans_lower *lower, struct kiockey *key)
 {
 	int	strtabindex;
-	unsigned short	*ke;
-	register ushort_t entry;
+	keymap_entry_t	*ke;
+	register keymap_entry_t entry;
 	struct keyboard *kp;
 
 	kp = lower->kbtrans_keyboard;
@@ -2267,7 +2281,7 @@ static int
 kbtrans_skey(struct kbtrans_lower *lower, struct kiockeymap *key, cred_t *cr)
 {
 	int	strtabindex, i;
-	unsigned short *ke;
+	keymap_entry_t *ke;
 	struct keyboard *kp;
 
 	kp = lower->kbtrans_keyboard;
@@ -2308,7 +2322,7 @@ kbtrans_skey(struct kbtrans_lower *lower, struct kiockeymap *key, cred_t *cr)
 		return (EINVAL);
 
 	if (key->kio_entry >= STRING &&
-	    key->kio_entry <= (ushort_t)(STRING + 15)) {
+	    key->kio_entry <= (STRING + 15)) {
 		strtabindex = key->kio_entry-STRING;
 		bcopy(key->kio_string,
 		    lower->kbtrans_keystringtab[strtabindex], KTAB_STRLEN);
@@ -2326,10 +2340,10 @@ kbtrans_skey(struct kbtrans_lower *lower, struct kiockeymap *key, cred_t *cr)
  *	Get individual keystation translation as new-style entry.
  */
 static int
-kbtrans_gkey(struct kbtrans_lower *lower, struct	kiockeymap *key)
+kbtrans_gkey(struct kbtrans_lower *lower, struct kiockeymap *key)
 {
 	int	strtabindex;
-	unsigned short *ke;
+	keymap_entry_t *ke;
 	struct keyboard *kp;
 
 	kp = lower->kbtrans_keyboard;
@@ -2360,7 +2374,7 @@ kbtrans_gkey(struct kbtrans_lower *lower, struct	kiockeymap *key)
 	key->kio_entry = *ke;
 
 	if (key->kio_entry >= STRING &&
-	    key->kio_entry <= (ushort_t)(STRING + 15)) {
+	    key->kio_entry <= (STRING + 15)) {
 		strtabindex = key->kio_entry-STRING;
 		bcopy(lower->kbtrans_keystringtab[strtabindex],
 		    key->kio_string, KTAB_STRLEN);
diff --git a/usr/src/uts/common/io/ldterm.c b/usr/src/uts/common/io/ldterm.c
index ff36dab948..2bf991769d 100644
--- a/usr/src/uts/common/io/ldterm.c
+++ b/usr/src/uts/common/io/ldterm.c
@@ -728,11 +728,25 @@ ldtermopen(queue_t *q, dev_t *devp, int oflag, int sflag, cred_t *crp)
 	tp->eucwioc.scrw[0] = 1;
 	tp->t_maxeuc = 1;	/* the max len in bytes of an EUC char */
 	tp->t_eucp = NULL;
-	tp->t_eucp_mp = NULL;
-	tp->t_eucwarn = 0;	/* no bad chars seen yet */
-
-	tp->t_csdata = default_cs_data;
 	tp->t_csmethods = cs_methods[LDTERM_CS_TYPE_EUC];
+	tp->t_csdata = default_cs_data;
+
+	/*
+	 * Try to switch to UTF-8 mode by allocating buffer for multibyte
+	 * chars, keep EUC if allocation fails.
+	 */
+	if ((tp->t_eucp_mp = allocb(_TTY_BUFSIZ, BPRI_HI)) != NULL) {
+		tp->t_eucp = tp->t_eucp_mp->b_rptr;
+		tp->t_state = TS_MEUC;	/* Multibyte mode. */
+		tp->t_maxeuc = 4; /* the max len in bytes of an UTF-8 char */
+		tp->t_csdata.codeset_type = LDTERM_CS_TYPE_UTF8;
+		tp->t_csdata.csinfo_num = 4;
+		/* locale_name needs string length with terminating NUL */
+		tp->t_csdata.locale_name = (char *)kmem_alloc(6, KM_SLEEP);
+		(void) strcpy(tp->t_csdata.locale_name, "UTF-8");
+		tp->t_csmethods = cs_methods[LDTERM_CS_TYPE_UTF8];
+	}
+	tp->t_eucwarn = 0;	/* no bad chars seen yet */
 
 	qprocson(q);
 
diff --git a/usr/src/uts/common/sys/consplat.h b/usr/src/uts/common/sys/consplat.h
index a9f6fe9633..d602c0875d 100644
--- a/usr/src/uts/common/sys/consplat.h
+++ b/usr/src/uts/common/sys/consplat.h
@@ -43,6 +43,7 @@ extern char *plat_stdoutpath(void);
 extern char *plat_diagpath(void);
 extern int plat_stdin_is_keyboard(void);
 extern int plat_stdout_is_framebuffer(void);
+extern void plat_tem_get_colors(uint8_t *, uint8_t *);
 extern void plat_tem_get_inverses(int *, int *);
 extern void plat_tem_get_prom_font_size(int *, int *);
 extern void plat_tem_get_prom_size(size_t *, size_t *);
diff --git a/usr/src/uts/common/sys/kbd.h b/usr/src/uts/common/sys/kbd.h
index a45c600750..c098d7a89d 100644
--- a/usr/src/uts/common/sys/kbd.h
+++ b/usr/src/uts/common/sys/kbd.h
@@ -26,8 +26,6 @@
 #ifndef _SYS_KBD_H
 #define	_SYS_KBD_H
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"	/* SunOS4.0 1.18 */
-
 #ifdef	__cplusplus
 extern "C" {
 #endif
@@ -225,15 +223,15 @@ struct keyboards {
  * keyboard struct appropriately.
  */
 
+typedef unsigned int keymap_entry_t;
 #ifdef KEYMAP_SIZE_VARIABLE
 
-typedef unsigned short keymap_entry_t;
 
 #else
 #define	KEYMAP_SIZE	128
 
 struct keymap {
-	unsigned short	keymap[KEYMAP_SIZE];	/* maps keycodes to actions */
+	keymap_entry_t	keymap[KEYMAP_SIZE];	/* maps keycodes to actions */
 };
 
 #endif
@@ -262,7 +260,7 @@ struct exception_map {
 	/*
 	 * This is our translated version of the matching sequence.
 	 */
-	unsigned short exc_entry;
+	keymap_entry_t exc_entry;
 };
 
 /*
@@ -319,26 +317,35 @@ struct keyboard {
 struct compose_sequence_t {
 	unsigned char	first;	/* first ASCII char after COMPOSE key */
 	unsigned char	second; /* second ASCII char after COMPOSE key */
-	unsigned char	iso;	/* equivalent ISO code */
+	keymap_entry_t	utf8;	/* equivalent UTF-8 code */
 };
 
 /*
  * Define the floating accent sequence structure.
  */
 struct fltaccent_sequence_t {
-	unsigned short	fa_entry;	/* floating accent keymap entry */
+	keymap_entry_t	fa_entry;	/* floating accent keymap entry */
 	unsigned char	ascii;		/* ASCII char after FA-type key */
-	unsigned char	iso;		/* equivalent ISO code */
+	keymap_entry_t	utf8;		/* equivalent UTF-8 code */
 };
 
 /*
+ * The top byte is used to store the flags, leaving 24 bits for char.
+ */
+#define	KEYCHAR(c)	((c) & 0x00ffffff)
+#define	KEYFLAGS(c)	((c) & ~0x00ffffff)
+
+/*
  * The "special" entries' top 4 bits are defined below.	 Generally they are
  * used with a 4-bit parameter (such as a bit number) in the low 4 bits.
  * The bytes whose top 4 bits are 0x0 thru 0x7 happen to be ascii
  * characters.	They are not special cased, but just normal cased.
  */
 
-#define	SHIFTKEYS	0x100	/* thru 0x10F.	This key helps to determine */
+#define	SPECIAL(h, l)	(((h) << 24) | (l))
+
+#define	SHIFTKEYS SPECIAL(0x1, 0)
+				/* thru 0x10F.	This key helps to determine */
 				/* the translation table used.	The bit */
 				/* position of its bit in "shiftmask" */
 				/* is added to the entry, eg */
@@ -347,7 +354,8 @@ struct fltaccent_sequence_t {
 				/* toggled.  Depending which tables you put */
 				/* it in, this works well for hold-down */
 				/* keys or press-on, press-off keys.  */
-#define	BUCKYBITS	0x200	/* thru 0x20F.	This key determines the state */
+#define	BUCKYBITS SPECIAL(0x2, 0)
+				/* thru 0x20F.	This key determines the state */
 				/* of one of the "bucky" bits above the */
 				/* returned ASCII character.  This is */
 				/* basically a way to pass mode-key-up/down */
@@ -366,33 +374,43 @@ struct fltaccent_sequence_t {
 				/* toggled.  Depending which tables you put */
 				/* it in, this works well for hold-down */
 				/* keys or press-on, press-off keys.  */
-#define	FUNNY		0x300	/* thru 0x30F.	This key does one of 16 funny */
+#define	FUNNY SPECIAL(0x3, 0)	/* thru 0x30F.	This key does one of 16 funny */
 				/* things based on the low 4 bits: */
-#define	NOP		0x300	/* This key does nothing. */
-#define	OOPS		0x301	/* This key exists but is undefined. */
-#define	HOLE		0x302	/* This key does not exist on the keyboard. */
+#define	NOP SPECIAL(0x3, 0x0)	/* This key does nothing. */
+#define	OOPS SPECIAL(0x3, 0x1) /* This key exists but is undefined. */
+#define	HOLE SPECIAL(0x3, 0x2) /* This key does not exist on the keyboard. */
 				/* Its position code should never be */
 				/* generated.  This indicates a software/ */
 				/* hardware mismatch, or bugs. */
-#define	RESET		0x306	/* Kbd was just reset */
-#define	ERROR		0x307	/* Kbd just detected an internal error */
-#define	IDLE		0x308	/* Kbd is idle (no keys down) */
-#define	COMPOSE		0x309	/* This key is the Compose key. */
-#define	NONL		0x30A	/* This key not affected by Num Lock */
+#define	RESET SPECIAL(0x3, 0x6) /* Kbd was just reset */
+#define	ERROR SPECIAL(0x3, 0x7) /* Kbd just detected an internal error */
+#define	IDLE SPECIAL(0x3, 0x8) /* Kbd is idle (no keys down) */
+#define	COMPOSE SPECIAL(0x3, 0x9) /* This key is the Compose key. */
+#define	NONL SPECIAL(0x3, 0xA) /* This key not affected by Num Lock */
 /* Combinations 0x30B to 0x30F are reserved for non-parameterized functions */
 
-#define	FA_CLASS	0x400	/* thru 0x40F.	These are for "floating */
+#define	FA_CLASS SPECIAL(0x4, 0)
+				/* thru 0x40F.	These are for "floating */
 				/* accent" characters.	The low-order 4 bits */
 				/* select one of those characters. */
 /* Definitions for the individual floating accents: */
-#define	FA_UMLAUT	0x400	/* umlaut accent */
-#define	FA_CFLEX	0x401	/* circumflex accent */
-#define	FA_TILDE	0x402	/* tilde accent */
-#define	FA_CEDILLA	0x403	/* cedilla accent */
-#define	FA_ACUTE	0x404	/* acute accent */
-#define	FA_GRAVE	0x405	/* grave accent */
-
-#define	STRING		0x500	/* thru 0x50F.	The low-order 4 bits index */
+#define	FA_UMLAUT SPECIAL(0x4, 0x0)	/* umlaut accent */
+#define	FA_CFLEX SPECIAL(0x4, 0x1)	/* circumflex accent */
+#define	FA_TILDE SPECIAL(0x4, 0x2)	/* tilde accent */
+#define	FA_CEDILLA SPECIAL(0x4, 0x3)	/* cedilla accent */
+#define	FA_ACUTE SPECIAL(0x4, 0x4)	/* acute accent */
+#define	FA_GRAVE SPECIAL(0x4, 0x5)	/* grave accent */
+#define	FA_MACRON SPECIAL(0x4, 0x6)	/* macron accent */
+#define	FA_BREVE SPECIAL(0x4, 0x7)	/* breve accent */
+#define	FA_DOT SPECIAL(0x4, 0x8)	/* dot accent */
+#define	FA_SLASH SPECIAL(0x4, 0x9)	/* slash accent */
+#define	FA_RING SPECIAL(0x4, 0xa)	/* ring accent */
+#define	FA_APOSTROPHE SPECIAL(0x4, 0xb)	/* apostrophe accent */
+#define	FA_DACUTE SPECIAL(0x4, 0xc)	/* double acute accent */
+#define	FA_OGONEK SPECIAL(0x4, 0xd)	/* ogonek accent */
+#define	FA_CARON SPECIAL(0x4, 0xe)	/* caron accent */
+
+#define	STRING SPECIAL(0x5, 0)	/* thru 0x50F.	The low-order 4 bits index */
 				/* a table select a string to be returned, */
 				/* char by char.  Each entry the table is */
 				/* null terminated. */
@@ -410,11 +428,11 @@ struct fltaccent_sequence_t {
  * the function key number within the group, and the next 4 bits indicate
  * the group.
  */
-#define	FUNCKEYS	0x600
-#define	LEFTFUNC	0x600	/* thru 0x60F.	The "left" group. */
-#define	RIGHTFUNC	0x610	/* thru 0x61F.	The "right" group. */
-#define	TOPFUNC		0x620	/* thru 0x62F.	The "top" group. */
-#define	BOTTOMFUNC	0x630	/* thru 0x63F.	The "bottom" group. */
+#define	FUNCKEYS	SPECIAL(0x6, 0)
+#define	LEFTFUNC SPECIAL(0x6, 0x0)	/* thru 0x60F.	The "left" group. */
+#define	RIGHTFUNC SPECIAL(0x6, 0x10)	/* thru 0x61F.	The "right" group. */
+#define	TOPFUNC SPECIAL(0x6, 0x20)	/* thru 0x62F.	The "top" group. */
+#define	BOTTOMFUNC SPECIAL(0x6, 0x30)	/* thru 0x63F.	The "bottom" group. */
 #define	LF(n)		(LEFTFUNC+(n)-1)
 #define	RF(n)		(RIGHTFUNC+(n)-1)
 #define	TF(n)		(TOPFUNC+(n)-1)
@@ -431,25 +449,25 @@ struct fltaccent_sequence_t {
  * where ESC is a single escape character and 0..9 indicate some number of
  * digits needed to encode the function key as a decimal number.
  */
-#define	PADKEYS		0x700
-#define	PADEQUAL	0x700		/* keypad = */
-#define	PADSLASH	0x701		/* keypad / */
-#define	PADSTAR		0x702		/* keypad * */
-#define	PADMINUS	0x703		/* keypad - */
-#define	PADSEP		0x704		/* keypad,  */
-#define	PAD7		0x705		/* keypad 7 */
-#define	PAD8		0x706		/* keypad 8 */
-#define	PAD9		0x707		/* keypad 9 */
-#define	PADPLUS		0x708		/* keypad + */
-#define	PAD4		0x709		/* keypad 4 */
-#define	PAD5		0x70A		/* keypad 5 */
-#define	PAD6		0x70B		/* keypad 6 */
-#define	PAD1		0x70C		/* keypad 1 */
-#define	PAD2		0x70D		/* keypad 2 */
-#define	PAD3		0x70E		/* keypad 3 */
-#define	PAD0		0x70F		/* keypad 0 */
-#define	PADDOT		0x710		/* keypad . */
-#define	PADENTER	0x711		/* keypad Enter */
+#define	PADKEYS		SPECIAL(0x7, 0)
+#define	PADEQUAL SPECIAL(0x7, 0x00)		/* keypad = */
+#define	PADSLASH SPECIAL(0x7, 0x01)		/* keypad / */
+#define	PADSTAR SPECIAL(0x7, 0x02)		/* keypad * */
+#define	PADMINUS SPECIAL(0x7, 0x03)		/* keypad - */
+#define	PADSEP SPECIAL(0x7, 0x04)		/* keypad,  */
+#define	PAD7 SPECIAL(0x7, 0x05)		/* keypad 7 */
+#define	PAD8 SPECIAL(0x7, 0x06)		/* keypad 8 */
+#define	PAD9 SPECIAL(0x7, 0x07)		/* keypad 9 */
+#define	PADPLUS SPECIAL(0x7, 0x08)		/* keypad + */
+#define	PAD4 SPECIAL(0x7, 0x09)		/* keypad 4 */
+#define	PAD5 SPECIAL(0x7, 0x0A)		/* keypad 5 */
+#define	PAD6 SPECIAL(0x7, 0x0B)		/* keypad 6 */
+#define	PAD1 SPECIAL(0x7, 0x0C)		/* keypad 1 */
+#define	PAD2 SPECIAL(0x7, 0x0D)		/* keypad 2 */
+#define	PAD3 SPECIAL(0x7, 0x0E)		/* keypad 3 */
+#define	PAD0 SPECIAL(0x7, 0x0F)		/* keypad 0 */
+#define	PADDOT SPECIAL(0x7, 0x10)		/* keypad . */
+#define	PADENTER SPECIAL(0x7, 0x11)		/* keypad Enter */
 
 #ifdef	__cplusplus
 }
diff --git a/usr/src/uts/common/sys/kbio.h b/usr/src/uts/common/sys/kbio.h
index e306902855..294710c002 100644
--- a/usr/src/uts/common/sys/kbio.h
+++ b/usr/src/uts/common/sys/kbio.h
@@ -26,8 +26,6 @@
 #ifndef _SYS_KBIO_H
 #define	_SYS_KBIO_H
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"	/* SunOS4.0 1.23 */
-
 #ifdef	__cplusplus
 extern "C" {
 #endif
@@ -146,7 +144,7 @@ struct kiockeymap {
 				/*  SHIFTMASK, CTRLMASK, UPMASK, */
 				/*  ALTGRAPHMASK) */
 	uchar_t	kio_station;	/* Physical keyboard key station (0-127) */
-	ushort_t kio_entry;	/* Translation table station's entry */
+	unsigned kio_entry;	/* Translation table station's entry */
 	char	kio_string[10];	/* Value for STRING entries (null terminated) */
 };
 
diff --git a/usr/src/uts/common/sys/vgareg.h b/usr/src/uts/common/sys/vgareg.h
index 3a2885a34b..230e9e1b2e 100644
--- a/usr/src/uts/common/sys/vgareg.h
+++ b/usr/src/uts/common/sys/vgareg.h
@@ -27,12 +27,16 @@
 #ifndef	_SYS_VGAREG_H
 #define	_SYS_VGAREG_H
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
+#define	VGA_REG_ADDR	0x3c0
+#define	VGA_REG_SIZE	0x20
+
+#define	VGA_MEM_ADDR	0xa0000
+#define	VGA_MEM_SIZE	0x20000
+
 /*
  * VGA frame buffer hardware definitions.
  */
diff --git a/usr/src/uts/common/sys/vgasubr.h b/usr/src/uts/common/sys/vgasubr.h
index bb266643b0..448079437c 100644
--- a/usr/src/uts/common/sys/vgasubr.h
+++ b/usr/src/uts/common/sys/vgasubr.h
@@ -27,42 +27,49 @@
 #ifndef	_SYS_VGASUBR_H
 #define	_SYS_VGASUBR_H
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"	/* SunOS4.1 1.11 */
-
 #ifdef	__cplusplus
 extern "C" {
 #endif
 
+#ifdef _KERNEL
+
 struct vgaregmap {
 	uint8_t			*addr;
 	ddi_acc_handle_t	handle;
 	boolean_t		mapped;
 };
+typedef struct vgaregmap *vgaregmap_t;
+
+#elif defined(_STANDALONE)
+
+typedef uint_t vgaregmap_t;
+
+#endif
 
-extern int vga_get_reg(struct vgaregmap *reg, int i);
-extern void vga_set_reg(struct vgaregmap *reg, int i, int v);
-extern int vga_get_crtc(struct vgaregmap *reg, int i);
-extern void vga_set_crtc(struct vgaregmap *reg, int i, int v);
-extern int vga_get_seq(struct vgaregmap *reg, int i);
-extern void vga_set_seq(struct vgaregmap *reg, int i, int v);
-extern int vga_get_grc(struct vgaregmap *reg, int i);
-extern void vga_set_grc(struct vgaregmap *reg, int i, int v);
-extern int vga_get_atr(struct vgaregmap *reg, int i);
-extern void vga_set_atr(struct vgaregmap *reg, int i, int v);
-extern void vga_put_cmap(struct vgaregmap *reg,
+extern int vga_get_reg(vgaregmap_t reg, int i);
+extern void vga_set_reg(vgaregmap_t reg, int i, int v);
+extern int vga_get_crtc(vgaregmap_t reg, int i);
+extern void vga_set_crtc(vgaregmap_t reg, int i, int v);
+extern int vga_get_seq(vgaregmap_t reg, int i);
+extern void vga_set_seq(vgaregmap_t reg, int i, int v);
+extern int vga_get_grc(vgaregmap_t reg, int i);
+extern void vga_set_grc(vgaregmap_t reg, int i, int v);
+extern int vga_get_atr(vgaregmap_t reg, int i);
+extern void vga_set_atr(vgaregmap_t reg, int i, int v);
+extern void vga_put_cmap(vgaregmap_t reg,
 	int index, unsigned char r, unsigned char g, unsigned char b);
-extern void vga_get_cmap(struct vgaregmap *reg,
+extern void vga_get_cmap(vgaregmap_t reg,
 	int index, unsigned char *r, unsigned char *g, unsigned char *b);
-extern void vga_get_hardware_settings(struct vgaregmap *reg,
+extern void vga_get_hardware_settings(vgaregmap_t reg,
 	int *width, int *height);
-extern void vga_set_indexed(struct vgaregmap *reg, int indexreg,
+extern void vga_set_indexed(vgaregmap_t reg, int indexreg,
 	int datareg, unsigned char index, unsigned char val);
-extern int vga_get_indexed(struct vgaregmap *reg, int indexreg,
+extern int vga_get_indexed(vgaregmap_t reg, int indexreg,
 	int datareg, unsigned char index);
 
 #define	VGA_MISC_TEXT	0x67
 #define	NUM_CRTC_REG	25
-#define	NUM_SEQ_REG    	5
+#define	NUM_SEQ_REG	5
 #define	NUM_GRC_REG	9
 #define	NUM_ATR_REG	21
 
@@ -73,7 +80,7 @@ extern unsigned char VGA_GRC_TEXT[NUM_GRC_REG];
 extern unsigned char VGA_TEXT_PALETTES[64][3];
 
 #if	defined(DEBUG)
-extern void vga_dump_regs(struct vgaregmap *reg,
+extern void vga_dump_regs(vgaregmap_t reg,
 	int maxseq, int maxcrtc, int maxatr, int maxgrc);
 #endif
 
diff --git a/usr/src/uts/common/sys/visual_io.h b/usr/src/uts/common/sys/visual_io.h
index db0acdda50..0194d00206 100644
--- a/usr/src/uts/common/sys/visual_io.h
+++ b/usr/src/uts/common/sys/visual_io.h
@@ -27,8 +27,6 @@
 #ifndef _SYS_VISUAL_IO_H
 #define	_SYS_VISUAL_IO_H
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -140,7 +138,7 @@ struct vis_cmap {
 };
 
 
-#ifdef _KERNEL
+#if defined(_KERNEL) || defined(_STANDALONE)
 /*
  * The following ioctls are used for communication between the layered
  * device and the framebuffer.  The layered driver calls the framebuffer
@@ -164,10 +162,11 @@ typedef short screen_size_t;
  * Union of pixel depths
  */
 typedef union {
-	unsigned char  mono;   /* one-bit */
-	unsigned char  four;   /* four bit */
-	unsigned char  eight;  /* eight bit */
-	unsigned char  twentyfour[3];  /* 24 bit */
+	unsigned char mono;		/* one-bit */
+	unsigned char four;		/* four bit */
+	unsigned char eight;		/* eight bit */
+	unsigned char sixteen[2];	/* 16 bit */
+	unsigned char twentyfour[3];	/* 24 bit */
 } color_t;
 
 /*
@@ -179,7 +178,7 @@ typedef union {
  * ioctl(fd, VIS_DEVINIT, struct vis_devinit *)
  */
 #define	VIS_DEVINIT	(VIOC|1)
-#define	VIS_CONS_REV		3 /* Console IO interface version */
+#define	VIS_CONS_REV		4 /* Console IO interface version */
 /* Modes */
 #define	VIS_TEXT		0 /* Use text mode when displaying data */
 #define	VIS_PIXEL		1 /* Use pixel mode when displaying data */
@@ -229,6 +228,18 @@ typedef union {
  */
 #define	VIS_CONSCOPY		(VIOC|7)
 
+/*
+ * VIS_CONSCLEAR:
+ * Clear the screen using provided color. Used on VIS_PIXEL mode.
+ *
+ * ioctl(fd, VIS_CONSCLEAR, struct vis_consclear *)
+ */
+#define	VIS_CONSCLEAR		(VIOC|8)
+
+struct vis_consclear {
+	unsigned char	bg_color; /* Background color */
+};
+
 struct vis_consdisplay {
 	screen_pos_t	row; /* Row to display data at */
 	screen_pos_t	col; /* Col to display data at */
@@ -284,6 +295,8 @@ struct vis_devinit; /* forward decl. for typedef */
 typedef void (*vis_modechg_cb_t)(struct vis_modechg_arg *,
     struct vis_devinit *);
 
+typedef uint32_t (*color_map_fn_t)(uint8_t color);
+
 struct vis_devinit {
 	/*
 	 * This set of fields are used as parameters passed from the
@@ -294,6 +307,7 @@ struct vis_devinit {
 	screen_size_t	height;		/* Height of the device */
 	screen_size_t	linebytes;	/* Bytes per scan line */
 	int		depth;		/* Device depth */
+	color_map_fn_t	color_map;	/* Color map tem -> fb */
 	short		mode;		/* Mode to use when displaying data */
 	struct vis_polledio *polledio;	/* Polled output routines */
 
@@ -305,7 +319,18 @@ struct vis_devinit {
 	struct vis_modechg_arg *modechg_arg; /* Mode change cb arg */
 };
 
-#endif	/* _KERNEL */
+struct visual_ops {
+	const struct vis_identifier *ident;
+	int (*kdsetmode)(int);
+	int (*devinit)(struct vis_devinit *);
+	void (*cons_copy)(struct vis_conscopy *);
+	void (*cons_display)(struct vis_consdisplay *);
+	void (*cons_cursor)(struct vis_conscursor *);
+	int (*cons_clear)(struct vis_consclear *);
+	int (*cons_put_cmap)(struct vis_cmap *);
+};
+
+#endif	/* _KERNEL || _STANDALONE */
 
 #ifdef __cplusplus
 }
diff --git a/usr/src/uts/intel/bnxe/Makefile b/usr/src/uts/intel/bnxe/Makefile
index 4b078ae559..0c3441c161 100644
--- a/usr/src/uts/intel/bnxe/Makefile
+++ b/usr/src/uts/intel/bnxe/Makefile
@@ -10,7 +10,7 @@
 #
 
 #
-# Copyright (c) 2014, Joyent, Inc.  All rights reserved.
+# Copyright (c) 2019, Joyent, Inc.
 #
 
 #
@@ -85,7 +85,6 @@ CPPFLAGS	+= -DLM_RXPKT_NON_CONTIGUOUS \
 		   -I$(SRCDIR)
 
 LDFLAGS		+= -dy -r -Ndrv/ip -Nmisc/mac
-#CERRWARN	+= -_gcc=-Wno-old-style-declaration
 CERRWARN	+= -_gcc=-Wno-switch
 CERRWARN	+= -_gcc=-Wno-uninitialized
 CERRWARN	+= -_gcc=-Wno-parentheses
@@ -99,6 +98,9 @@ CERRWARN	+= -_cc=-erroff=E_INTEGER_OVERFLOW_DETECTED
 CERRWARN	+= -_cc=-erroff=E_CONST_PROMOTED_UNSIGNED_LL
 CERRWARN	+= -_cc=-erroff=E_ENUM_VAL_OVERFLOWS_INT_MAX
 
+# a whole mess
+SMATCH=off
+
 LINTTAGS	+= -erroff=E_FUNC_RET_ALWAYS_IGNOR2
 LINTTAGS	+= -erroff=E_FUNC_RET_MAYBE_IGNORED2
 LINTTAGS	+= -erroff=E_STATIC_UNUSED
diff --git a/usr/src/uts/intel/kbtrans/Makefile b/usr/src/uts/intel/kbtrans/Makefile
index f5d8214e6c..29e6fda4e6 100644
--- a/usr/src/uts/intel/kbtrans/Makefile
+++ b/usr/src/uts/intel/kbtrans/Makefile
@@ -63,9 +63,6 @@ INSTALL_TARGET	= $(BINARY) $(ROOTMODULE)
 LINTTAGS	+= -erroff=E_BAD_PTR_CAST_ALIGN
 LINTTAGS	+= -erroff=E_ASSIGN_NARROW_CONV
 
-CERRWARN	+= -_gcc=-Wno-empty-body
-CERRWARN	+= -_gcc=-Wno-unused-braces
-
 .KEEP_STATE:
 
 def:		$(DEF_DEPS)